Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
feat: migrate 5 PostgreSQL advisors to ANTLR (#17830)
h3n4l81a777759ec7
diff --git a/backend/plugin/advisor/pgantlr/advisor_index_total_number_limit.go b/backend/plugin/advisor/pgantlr/advisor_index_total_number_limit.gonew file mode 100644index 0000000000..13b6f37e91--- /dev/null+++ b/backend/plugin/advisor/pgantlr/advisor_index_total_number_limit.go@@ -0,0 +1,267 @@+package pgantlr++import (+ "context"+ "fmt"+ "slices"++ "github.com/antlr4-go/antlr/v4"++ parser "github.com/bytebase/parser/postgresql"++ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/advisor/catalog"+)++var (+ _ advisor.Advisor = (*IndexTotalNumberLimitAdvisor)(nil)+)++func init() {+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleIndexTotalNumberLimit, &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) {+ tree, err := getANTLRTree(checkCtx)+ if err != nil {+ return nil, err+ }++ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)+ if err != nil {+ return nil, err+ }+ payload, err := advisor.UnmarshalNumberTypeRulePayload(checkCtx.Rule.Payload)+ if err != nil {+ return nil, err+ }++ checker := &indexTotalNumberLimitChecker{+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},+ level: level,+ title: string(checkCtx.Rule.Type),+ max: payload.Number,+ catalog: checkCtx.Catalog,+ tableLine: make(tableLineMap),+ }++ if checker.catalog.Final.Usable() {+ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)+ }++ return checker.generateAdvice(), nil+}++type tableLine struct {+ schema string+ table string+ line int+}++type tableLineMap map[string]tableLine++func (m tableLineMap) set(schema string, table string, line int) {+ if schema == "" {+ schema = "public"+ }+ m[fmt.Sprintf("%q.%q", schema, table)] = tableLine{+ schema: schema,+ table: table,+ line: line,+ }+}++type indexTotalNumberLimitChecker struct {+ *parser.BasePostgreSQLParserListener++ adviceList []*storepb.Advice+ level storepb.Advice_Status+ title string+ max int+ catalog *catalog.Finder+ tableLine tableLineMap+}++func (c *indexTotalNumberLimitChecker) generateAdvice() []*storepb.Advice {+ var tableList []tableLine+ for _, table := range c.tableLine {+ tableList = append(tableList, table)+ }+ slices.SortFunc(tableList, func(i, j tableLine) int {+ if i.line < j.line {+ return -1+ }+ if i.line > j.line {+ return 1+ }+ return 0+ })++ for _, table := range tableList {+ tableInfo := c.catalog.Final.FindTable(&catalog.TableFind{+ SchemaName: table.schema,+ TableName: table.table,+ })+ if tableInfo != nil && tableInfo.CountIndex() > c.max {+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: advisor.IndexCountExceedsLimit.Int32(),+ Title: c.title,+ Content: fmt.Sprintf("The count of index in table %q.%q should be no more than %d, but found %d", table.schema, table.table, c.max, tableInfo.CountIndex()),+ StartPosition: &storepb.Position{+ Line: int32(table.line),+ Column: 0,+ },+ })+ }+ }++ return c.adviceList+}++func (c *indexTotalNumberLimitChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ qualifiedNames := ctx.AllQualified_name()+ if len(qualifiedNames) == 0 {+ return+ }++ tableName := extractTableName(qualifiedNames[0])+ if tableName == "" {+ return+ }++ schemaName := extractSchemaName(qualifiedNames[0])++ // Check if this CREATE TABLE statement creates any indexes+ // (PRIMARY KEY or UNIQUE constraints)+ if ctx.Opttableelementlist() != nil && ctx.Opttableelementlist().Tableelementlist() != nil {+ allElements := ctx.Opttableelementlist().Tableelementlist().AllTableelement()+ for _, elem := range allElements {+ // Check column-level constraints+ if elem.ColumnDef() != nil {+ if hasIndexConstraint(elem.ColumnDef()) {+ c.tableLine.set(schemaName, tableName, ctx.GetStop().GetLine())+ return+ }+ }++ // Check table-level constraints+ if elem.Tableconstraint() != nil && hasTableIndexConstraint(elem.Tableconstraint()) {+ c.tableLine.set(schemaName, tableName, ctx.GetStop().GetLine())+ return+ }+ }+ }+}++func (c *indexTotalNumberLimitChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ if ctx.Relation_expr() == nil || ctx.Relation_expr().Qualified_name() == nil {+ return+ }++ tableName := extractTableName(ctx.Relation_expr().Qualified_name())+ if tableName == "" {+ return+ }++ schemaName := extractSchemaName(ctx.Relation_expr().Qualified_name())++ // Check ALTER TABLE commands that create indexes+ if ctx.Alter_table_cmds() != nil {+ allCmds := ctx.Alter_table_cmds().AllAlter_table_cmd()+ for _, cmd := range allCmds {+ // ADD COLUMN with PRIMARY KEY or UNIQUE+ if cmd.ADD_P() != nil && cmd.ColumnDef() != nil {+ if hasIndexConstraint(cmd.ColumnDef()) {+ c.tableLine.set(schemaName, tableName, ctx.GetStop().GetLine())+ return+ }+ }++ // ADD CONSTRAINT (PRIMARY KEY or UNIQUE)+ if cmd.ADD_P() != nil && cmd.Tableconstraint() != nil {+ if hasTableIndexConstraint(cmd.Tableconstraint()) {+ c.tableLine.set(schemaName, tableName, ctx.GetStop().GetLine())+ return+ }+ }+ }+ }+}++func (c *indexTotalNumberLimitChecker) EnterIndexstmt(ctx *parser.IndexstmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ if ctx.Relation_expr() == nil || ctx.Relation_expr().Qualified_name() == nil {+ return+ }++ tableName := extractTableName(ctx.Relation_expr().Qualified_name())+ if tableName == "" {+ return+ }++ schemaName := extractSchemaName(ctx.Relation_expr().Qualified_name())+ c.tableLine.set(schemaName, tableName, ctx.GetStop().GetLine())+}++// hasIndexConstraint checks if a column definition has PRIMARY KEY or UNIQUE constraint+func hasIndexConstraint(colDef parser.IColumnDefContext) bool {+ if colDef.Colquallist() == nil {+ return false+ }++ allConstraints := colDef.Colquallist().AllColconstraint()+ for _, constraint := range allConstraints {+ if constraint.Colconstraintelem() != nil {+ elem := constraint.Colconstraintelem()+ // PRIMARY KEY creates an index+ if elem.PRIMARY() != nil && elem.KEY() != nil {+ return true+ }+ // UNIQUE creates an index+ if elem.UNIQUE() != nil {+ return true+ }+ }+ }++ return false+}++// hasTableIndexConstraint checks if a table constraint is PRIMARY KEY or UNIQUE+func hasTableIndexConstraint(constraint parser.ITableconstraintContext) bool {+ if constraint == nil || constraint.Constraintelem() == nil {+ return false+ }++ elem := constraint.Constraintelem()++ // PRIMARY KEY creates an index+ if elem.PRIMARY() != nil && elem.KEY() != nil {+ return true+ }++ // UNIQUE creates an index+ if elem.UNIQUE() != nil {+ return true+ }++ return false+}diff --git a/backend/plugin/advisor/pgantlr/advisor_insert_disallow_order_by_rand.go b/backend/plugin/advisor/pgantlr/advisor_insert_disallow_order_by_rand.gonew file mode 100644index 0000000000..ccd9095ca1--- /dev/null+++ b/backend/plugin/advisor/pgantlr/advisor_insert_disallow_order_by_rand.go@@ -0,0 +1,153 @@+package pgantlr++import (+ "context"+ "fmt"+ "strings"++ "github.com/antlr4-go/antlr/v4"++ parser "github.com/bytebase/parser/postgresql"++ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/plugin/advisor"+)++var (+ _ advisor.Advisor = (*InsertDisallowOrderByRandAdvisor)(nil)+)++func init() {+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleStatementInsertDisallowOrderByRand, &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) {+ tree, err := getANTLRTree(checkCtx)+ if err != nil {+ return nil, err+ }++ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)+ if err != nil {+ return nil, err+ }++ checker := &insertDisallowOrderByRandChecker{+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},+ level: level,+ title: string(checkCtx.Rule.Type),+ statementsText: checkCtx.Statements,+ }++ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)++ return checker.adviceList, nil+}++type insertDisallowOrderByRandChecker struct {+ *parser.BasePostgreSQLParserListener++ adviceList []*storepb.Advice+ level storepb.Advice_Status+ title string+ statementsText string+}++func (c *insertDisallowOrderByRandChecker) EnterInsertstmt(ctx *parser.InsertstmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ // Check if this is INSERT...SELECT+ if ctx.Insert_rest() == nil || ctx.Insert_rest().Selectstmt() == nil {+ return+ }++ // Check for ORDER BY random() in the SELECT statement+ if c.hasOrderByRandom(ctx.Insert_rest().Selectstmt()) {+ // Extract the statement text from the original statements+ stmtText := extractStatementText(c.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())++ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: advisor.InsertUseOrderByRand.Int32(),+ Title: c.title,+ Content: fmt.Sprintf("The INSERT statement uses ORDER BY random() or random_between(), related statement \"%s\"", stmtText),+ StartPosition: &storepb.Position{+ Line: int32(ctx.GetStart().GetLine()),+ Column: 0,+ },+ })+ }+}++// hasOrderByRandom checks if a SELECT statement has ORDER BY random() or random_between()+func (*insertDisallowOrderByRandChecker) hasOrderByRandom(selectCtx parser.ISelectstmtContext) bool {+ if selectCtx == nil {+ return false+ }++ // Check both Select_no_parens and Select_with_parens+ if selectCtx.Select_no_parens() != nil {+ if hasOrderByRandomInSelect(selectCtx.Select_no_parens()) {+ return true+ }+ }++ if selectCtx.Select_with_parens() != nil {+ // Select_with_parens might contain another Selectstmt+ // We need to recursively check+ return hasOrderByRandomInParens(selectCtx.Select_with_parens())+ }++ return false+}++// hasOrderByRandomInSelect checks Select_no_parens for ORDER BY random()+func hasOrderByRandomInSelect(selectCtx parser.ISelect_no_parensContext) bool {+ if selectCtx == nil {+ return false+ }++ // Check Opt_sort_clause (ORDER BY clause)+ if selectCtx.Opt_sort_clause() != nil && selectCtx.Opt_sort_clause().Sort_clause() != nil {+ sortClause := selectCtx.Opt_sort_clause().Sort_clause()+ // Get all sort by items via Sortby_list+ if sortClause.Sortby_list() != nil {+ allSortBy := sortClause.Sortby_list().AllSortby()+ for _, sortBy := range allSortBy {+ if sortBy.A_expr() != nil {+ text := strings.ToLower(sortBy.A_expr().GetText())+ if strings.Contains(text, "random()") || strings.Contains(text, "random_between()") {+ return true+ }+ }+ }+ }+ }++ return false+}++// hasOrderByRandomInParens checks Select_with_parens recursively+func hasOrderByRandomInParens(selectCtx parser.ISelect_with_parensContext) bool {+ if selectCtx == nil {+ return false+ }++ // Select_with_parens can contain Select_no_parens or another Select_with_parens+ if selectCtx.Select_no_parens() != nil {+ return hasOrderByRandomInSelect(selectCtx.Select_no_parens())+ }++ if selectCtx.Select_with_parens() != nil {+ return hasOrderByRandomInParens(selectCtx.Select_with_parens())+ }++ return false+}diff --git a/backend/plugin/advisor/pgantlr/advisor_insert_must_specify_column.go b/backend/plugin/advisor/pgantlr/advisor_insert_must_specify_column.gonew file mode 100644index 0000000000..850001baa4--- /dev/null+++ b/backend/plugin/advisor/pgantlr/advisor_insert_must_specify_column.go@@ -0,0 +1,91 @@+package pgantlr++import (+ "context"+ "fmt"++ "github.com/antlr4-go/antlr/v4"++ parser "github.com/bytebase/parser/postgresql"++ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/plugin/advisor"+)++var (+ _ advisor.Advisor = (*InsertMustSpecifyColumnAdvisor)(nil)+)++func init() {+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleStatementInsertMustSpecifyColumn, &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) {+ tree, err := getANTLRTree(checkCtx)+ if err != nil {+ return nil, err+ }++ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)+ if err != nil {+ return nil, err+ }++ checker := &insertMustSpecifyColumnChecker{+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},+ level: level,+ title: string(checkCtx.Rule.Type),+ statementsText: checkCtx.Statements,+ }++ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)++ return checker.adviceList, nil+}++type insertMustSpecifyColumnChecker struct {+ *parser.BasePostgreSQLParserListener++ adviceList []*storepb.Advice+ level storepb.Advice_Status+ title string+ statementsText string+}++func (c *insertMustSpecifyColumnChecker) EnterInsertstmt(ctx *parser.InsertstmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ // Check if column list is specified+ // In PostgreSQL, INSERT has an optional insert_column_list+ // If insert_column_list is not specified or empty, we should report it+ if ctx.Insert_rest() == nil {+ return+ }++ // Check if there's an insert_column_list+ // Insert_column_list exists, which means columns are specified+ hasColumnList := ctx.Insert_rest().Insert_column_list() != nil++ if !hasColumnList {+ // Extract the statement text from the original statements+ stmtText := extractStatementText(c.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())++ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: advisor.InsertNotSpecifyColumn.Int32(),+ Title: c.title,+ Content: fmt.Sprintf("The INSERT statement must specify columns but \"%s\" does not", stmtText),+ StartPosition: &storepb.Position{+ Line: int32(ctx.GetStart().GetLine()),+ Column: 0,+ },+ })+ }+}diff --git a/backend/plugin/advisor/pgantlr/advisor_insert_row_limit.go b/backend/plugin/advisor/pgantlr/advisor_insert_row_limit.gonew file mode 100644index 0000000000..7afc80480b--- /dev/null+++ b/backend/plugin/advisor/pgantlr/advisor_insert_row_limit.go@@ -0,0 +1,308 @@+package pgantlr++import (+ "context"+ "database/sql"+ "fmt"+ "regexp"+ "strconv"++ "github.com/antlr4-go/antlr/v4"+ "github.com/pkg/errors"++ parser "github.com/bytebase/parser/postgresql"++ "github.com/bytebase/bytebase/backend/common"+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/plugin/advisor"+)++var (+ _ advisor.Advisor = (*InsertRowLimitAdvisor)(nil)+)++func init() {+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleStatementInsertRowLimit, &InsertRowLimitAdvisor{})+}++// InsertRowLimitAdvisor is the advisor checking for to limit INSERT rows.+type InsertRowLimitAdvisor struct {+}++// Check checks for the INSERT row limit.+func (*InsertRowLimitAdvisor) Check(ctx context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {+ tree, err := getANTLRTree(checkCtx)+ if err != nil {+ return nil, err+ }++ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)+ if err != nil {+ return nil, err+ }+ payload, err := advisor.UnmarshalNumberTypeRulePayload(checkCtx.Rule.Payload)+ if err != nil {+ return nil, err+ }++ checker := &insertRowLimitChecker{+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},+ level: level,+ title: string(checkCtx.Rule.Type),+ maxRow: payload.Number,+ driver: checkCtx.Driver,+ ctx: ctx,+ statementsText: checkCtx.Statements,+ UsePostgresDatabaseOwner: checkCtx.UsePostgresDatabaseOwner,+ }++ if payload.Number > 0 {+ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)+ }++ return checker.adviceList, nil+}++type insertRowLimitChecker struct {+ *parser.BasePostgreSQLParserListener++ adviceList []*storepb.Advice+ level storepb.Advice_Status+ title string+ maxRow int+ driver *sql.DB+ ctx context.Context+ statementsText string+ explainCount int+ setRoles []string+ UsePostgresDatabaseOwner bool+}++func (c *insertRowLimitChecker) EnterVariablesetstmt(ctx *parser.VariablesetstmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ // Track SET ROLE statements+ if ctx.Set_rest() != nil && ctx.Set_rest().Set_rest_more() != nil {+ setRestMore := ctx.Set_rest().Set_rest_more()+ // Check if this is SET ROLE+ if setRestMore.ROLE() != nil {+ c.setRoles = append(c.setRoles, ctx.GetText())+ }+ }+}++func (c *insertRowLimitChecker) EnterInsertstmt(ctx *parser.InsertstmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ code := advisor.Ok+ rows := int64(0)++ // Check if this is INSERT ... VALUES or INSERT ... SELECT+ if ctx.Insert_rest() != nil && ctx.Insert_rest().Selectstmt() != nil {+ // Count the number of value lists if this is VALUES+ rowCount := countValueLists(ctx.Insert_rest().Selectstmt())+ if rowCount > 0 {+ // This is INSERT ... VALUES+ if rowCount > c.maxRow {+ code = advisor.InsertTooManyRows+ rows = int64(rowCount)+ }+ } else if c.driver != nil {+ // For INSERT ... SELECT, use EXPLAIN+ if c.explainCount >= common.MaximumLintExplainSize {+ return+ }+ c.explainCount++++ stmtText := extractStatementText(c.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())+ res, err := advisor.Query(c.ctx, advisor.QueryContext{+ UsePostgresDatabaseOwner: c.UsePostgresDatabaseOwner,+ PreExecutions: c.setRoles,+ }, c.driver, storepb.Engine_POSTGRES, fmt.Sprintf("EXPLAIN %s", stmtText))++ if err != nil {+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: advisor.InsertTooManyRows.Int32(),+ Title: c.title,+ Content: fmt.Sprintf("\"%s\" dry runs failed: %s", stmtText, err.Error()),+ StartPosition: &storepb.Position{+ Line: int32(ctx.GetStart().GetLine()),+ Column: 0,+ },+ })+ return+ }++ rowCount, err := getAffectedRows(res)+ if err != nil {+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: advisor.Internal.Int32(),+ Title: c.title,+ Content: fmt.Sprintf("failed to get row count for \"%s\": %s", stmtText, err.Error()),+ StartPosition: &storepb.Position{+ Line: int32(ctx.GetStart().GetLine()),+ Column: 0,+ },+ })+ return+ }++ if rowCount > int64(c.maxRow) {+ code = advisor.InsertTooManyRows+ rows = rowCount+ }+ }+ }++ if code != advisor.Ok {+ stmtText := extractStatementText(c.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: code.Int32(),+ Title: c.title,+ Content: fmt.Sprintf("The statement \"%s\" inserts %d rows. The count exceeds %d.", stmtText, rows, c.maxRow),+ StartPosition: &storepb.Position{+ Line: int32(ctx.GetStart().GetLine()),+ Column: 0,+ },+ })+ }+}++// countValueLists counts the number of value lists in an INSERT ... VALUES statement+// Returns 0 if this is not a VALUES statement (e.g., INSERT ... SELECT)+func countValueLists(selectStmt parser.ISelectstmtContext) int {+ if selectStmt == nil {+ return 0+ }++ // Navigate to the values_clause+ // SELECT can be select_no_parens or select_with_parens+ if selectStmt.Select_no_parens() != nil {+ return countValuesInSelectNoParens(selectStmt.Select_no_parens())+ }++ if selectStmt.Select_with_parens() != nil {+ return countValuesInSelectWithParens(selectStmt.Select_with_parens())+ }++ return 0+}++// countValuesInSelectNoParens counts VALUES rows in a select_no_parens+func countValuesInSelectNoParens(selectCtx parser.ISelect_no_parensContext) int {+ if selectCtx == nil || selectCtx.Select_clause() == nil {+ return 0+ }++ // Check if this is a values_clause+ return countValuesInSelectClause(selectCtx.Select_clause())+}++// countValuesInSelectWithParens counts VALUES rows in a select_with_parens+func countValuesInSelectWithParens(selectCtx parser.ISelect_with_parensContext) int {+ if selectCtx == nil {+ return 0+ }++ if selectCtx.Select_no_parens() != nil {+ return countValuesInSelectNoParens(selectCtx.Select_no_parens())+ }++ if selectCtx.Select_with_parens() != nil {+ return countValuesInSelectWithParens(selectCtx.Select_with_parens())+ }++ return 0+}++// countValuesInSelectClause counts VALUES rows in a select_clause+func countValuesInSelectClause(selectClause parser.ISelect_clauseContext) int {+ if selectClause == nil {+ return 0+ }++ // select_clause has AllSimple_select_intersect+ allIntersect := selectClause.AllSimple_select_intersect()+ if len(allIntersect) == 0 {+ return 0+ }++ // Check the first one for values_clause+ return countValuesInSimpleSelectIntersect(allIntersect[0])+}++// countValuesInSimpleSelectIntersect counts VALUES rows in simple_select_intersect+func countValuesInSimpleSelectIntersect(intersect parser.ISimple_select_intersectContext) int {+ if intersect == nil {+ return 0+ }++ // Get all simple_select_pramary+ allPrimary := intersect.AllSimple_select_pramary()+ if len(allPrimary) == 0 {+ return 0+ }++ // Check the first one for values_clause+ return countValuesInPrimary(allPrimary[0])+}++// countValuesInPrimary counts VALUES rows in simple_select_pramary+func countValuesInPrimary(primary parser.ISimple_select_pramaryContext) int {+ if primary == nil || primary.Values_clause() == nil {+ return 0+ }++ // values_clause: VALUES (expr_list) (, (expr_list))*+ // Count the number of COMMA tokens + 1+ valuesClause := primary.Values_clause()+ commaCount := len(valuesClause.AllCOMMA())+ return commaCount + 1+}++func getAffectedRows(res []any) (int64, error) {+ // the res struct is []any{columnName, columnTable, rowDataList}+ if len(res) != 3 {+ return 0, errors.Errorf("expected 3 but got %d", len(res))+ }+ rowList, ok := res[2].([]any)+ if !ok {+ return 0, errors.Errorf("expected []any but got %t", res[2])+ }+ // EXPLAIN output has at least 2 rows+ if len(rowList) < 2 {+ return 0, errors.Errorf("not found any data")+ }+ // We need row 2+ rowTwo, ok := rowList[1].([]any)+ if !ok {+ return 0, errors.Errorf("expected []any but got %t", rowList[0])+ }+ // PostgreSQL EXPLAIN result has one column+ if len(rowTwo) != 1 {+ return 0, errors.Errorf("expected one but got %d", len(rowTwo))+ }+ // Get the string value+ text, ok := rowTwo[0].(string)+ if !ok {+ return 0, errors.Errorf("expected string but got %t", rowTwo[0])+ }++ rowsRegexp := regexp.MustCompile("rows=([0-9]+)")+ matches := rowsRegexp.FindStringSubmatch(text)+ if len(matches) != 2 {+ return 0, errors.Errorf("failed to find rows in %q", text)+ }+ value, err := strconv.ParseInt(matches[1], 10, 64)+ if err != nil {+ return 0, errors.Errorf("failed to get integer from %q", matches[1])+ }+ return value, nil+}diff --git a/backend/plugin/advisor/pgantlr/advisor_naming_column.go b/backend/plugin/advisor/pgantlr/advisor_naming_column.gonew file mode 100644index 0000000000..4f3b55eb40--- /dev/null+++ b/backend/plugin/advisor/pgantlr/advisor_naming_column.go@@ -0,0 +1,188 @@+package pgantlr++import (+ "context"+ "fmt"+ "regexp"++ "github.com/antlr4-go/antlr/v4"++ parser "github.com/bytebase/parser/postgresql"++ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/pg"+)++var (+ _ advisor.Advisor = (*NamingColumnConventionAdvisor)(nil)+)++func init() {+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleColumnNaming, &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) {+ tree, err := getANTLRTree(checkCtx)+ if err != nil {+ return nil, err+ }++ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)+ if err != nil {+ return nil, err+ }++ format, maxLength, err := advisor.UnmarshalNamingRulePayloadAsRegexp(checkCtx.Rule.Payload)+ if err != nil {+ return nil, err+ }++ checker := &namingColumnConventionChecker{+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},+ level: level,+ title: string(checkCtx.Rule.Type),+ format: format,+ maxLength: maxLength,+ }++ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)++ return checker.adviceList, nil+}++type namingColumnConventionChecker struct {+ *parser.BasePostgreSQLParserListener++ adviceList []*storepb.Advice+ level storepb.Advice_Status+ title string+ format *regexp.Regexp+ maxLength int+}++// EnterCreatestmt handles CREATE TABLE statements+func (c *namingColumnConventionChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ // Get table name+ qualifiedNames := ctx.AllQualified_name()+ if len(qualifiedNames) == 0 {+ return+ }+ tableName := extractTableName(qualifiedNames[0])++ // Get OptTableElementList which contains column definitions+ if ctx.Opttableelementlist() == nil || ctx.Opttableelementlist().Tableelementlist() == nil {+ return+ }++ // Iterate through all table elements+ allElements := ctx.Opttableelementlist().Tableelementlist().AllTableelement()+ for _, elem := range allElements {+ // Check if this is a column definition+ if elem.ColumnDef() != nil {+ colDef := elem.ColumnDef()+ if colDef.Colid() != nil {+ columnName := pg.NormalizePostgreSQLColid(colDef.Colid())+ c.checkColumnName(tableName, columnName, elem.GetStart().GetLine())+ }+ }+ }+}++// EnterAltertablestmt handles ALTER TABLE ADD COLUMN statements+func (c *namingColumnConventionChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ // Get table name+ if ctx.Relation_expr() == nil || ctx.Relation_expr().Qualified_name() == nil {+ return+ }+ tableName := extractTableName(ctx.Relation_expr().Qualified_name())++ // Get ALTER TABLE commands+ if ctx.Alter_table_cmds() == nil {+ return+ }++ allCmds := ctx.Alter_table_cmds().AllAlter_table_cmd()+ for _, cmd := range allCmds {+ // Check for ADD COLUMN+ if cmd.ADD_P() != nil && cmd.ColumnDef() != nil {+ colDef := cmd.ColumnDef()+ if colDef.Colid() != nil {+ columnName := pg.NormalizePostgreSQLColid(colDef.Colid())+ c.checkColumnName(tableName, columnName, cmd.GetStart().GetLine())+ }+ }+ }+}++// EnterRenamestmt handles RENAME COLUMN statements+func (c *namingColumnConventionChecker) EnterRenamestmt(ctx *parser.RenamestmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ // Check if this is RENAME COLUMN+ if ctx.Opt_column() == nil || ctx.Opt_column().COLUMN() == nil {+ return+ }++ // Get table name+ var tableName string+ if ctx.Relation_expr() != nil && ctx.Relation_expr().Qualified_name() != nil {+ tableName = extractTableName(ctx.Relation_expr().Qualified_name())+ }+ if tableName == "" {+ return+ }++ // Get new column name+ allNames := ctx.AllName()+ if len(allNames) < 2 {+ return+ }++ newColumnName := pg.NormalizePostgreSQLName(allNames[1])+ c.checkColumnName(tableName, newColumnName, ctx.GetStart().GetLine())+}++// checkColumnName validates a column name against the format and max length rules+func (c *namingColumnConventionChecker) checkColumnName(tableName, columnName string, line int) {+ if !c.format.MatchString(columnName) {+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: advisor.NamingColumnConventionMismatch.Int32(),+ Title: c.title,+ Content: fmt.Sprintf("\"%s\".\"%s\" mismatches column naming convention, naming format should be %q", tableName, columnName, c.format),+ StartPosition: &storepb.Position{+ Line: int32(line),+ Column: 0,+ },+ })+ }++ if c.maxLength > 0 && len(columnName) > c.maxLength {+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: advisor.NamingColumnConventionMismatch.Int32(),+ Title: c.title,+ Content: fmt.Sprintf("\"%s\".\"%s\" mismatches column naming convention, its length should be within %d characters", tableName, columnName, c.maxLength),+ StartPosition: &storepb.Position{+ Line: int32(line),+ Column: 0,+ },+ })+ }+}diff --git a/backend/plugin/advisor/pgantlr/pgantlr_test.go b/backend/plugin/advisor/pgantlr/pgantlr_test.goindex 5cd5969463..86458d8e14 100644--- a/backend/plugin/advisor/pgantlr/pgantlr_test.go+++ b/backend/plugin/advisor/pgantlr/pgantlr_test.go@@ -9,23 +9,28 @@ import (func TestPostgreSQLANTLRRules(t *testing.T) {antlrRules := []advisor.SQLReviewRuleType{- HelloWorldRule, // Test advisor to verify framework works- advisor.BuiltinRulePriorBackupCheck, // Migrated from legacy- advisor.SchemaRuleCharsetAllowlist, // Migrated from legacy- advisor.SchemaRuleCollationAllowlist, // Migrated from legacy- advisor.SchemaRuleColumnCommentConvention, // Migrated from legacy- advisor.SchemaRuleColumnDefaultDisallowVolatile, // Migrated from legacy- advisor.SchemaRuleColumnDisallowChangeType, // Migrated from legacy- advisor.SchemaRuleColumnMaximumCharacterLength, // Migrated from legacy- advisor.SchemaRuleColumnNotNull, // Migrated from legacy- advisor.SchemaRuleColumnRequireDefault, // Migrated from legacy- advisor.SchemaRuleColumnTypeDisallowList, // Migrated from legacy- advisor.SchemaRuleCommentLength, // Migrated from legacy- advisor.SchemaRuleCreateIndexConcurrently, // Migrated from legacy- advisor.SchemaRuleIndexKeyNumberLimit, // Migrated from legacy- advisor.SchemaRuleIndexNoDuplicateColumn, // Migrated from legacy- advisor.SchemaRuleIndexPrimaryKeyTypeAllowlist, // Migrated from legacy- advisor.SchemaRuleRequiredColumn, // Migrated from legacy+ HelloWorldRule, // Test advisor to verify framework works+ advisor.BuiltinRulePriorBackupCheck, // Migrated from legacy+ advisor.SchemaRuleCharsetAllowlist, // Migrated from legacy+ advisor.SchemaRuleCollationAllowlist, // Migrated from legacy+ advisor.SchemaRuleColumnCommentConvention, // Migrated from legacy+ advisor.SchemaRuleColumnDefaultDisallowVolatile, // Migrated from legacy+ advisor.SchemaRuleColumnDisallowChangeType, // Migrated from legacy+ advisor.SchemaRuleColumnMaximumCharacterLength, // Migrated from legacy+ advisor.SchemaRuleColumnNotNull, // Migrated from legacy+ advisor.SchemaRuleColumnRequireDefault, // Migrated from legacy+ advisor.SchemaRuleColumnTypeDisallowList, // Migrated from legacy+ advisor.SchemaRuleCommentLength, // Migrated from legacy+ advisor.SchemaRuleCreateIndexConcurrently, // Migrated from legacy+ advisor.SchemaRuleIndexKeyNumberLimit, // Migrated from legacy+ advisor.SchemaRuleIndexNoDuplicateColumn, // Migrated from legacy+ advisor.SchemaRuleIndexPrimaryKeyTypeAllowlist, // Migrated from legacy+ advisor.SchemaRuleIndexTotalNumberLimit, // Migrated from legacy+ advisor.SchemaRuleRequiredColumn, // Migrated from legacy+ advisor.SchemaRuleStatementInsertDisallowOrderByRand, // Migrated from legacy+ advisor.SchemaRuleStatementInsertMustSpecifyColumn, // Migrated from legacy+ advisor.SchemaRuleStatementInsertRowLimit, // Migrated from legacy+ advisor.SchemaRuleColumnNaming, // Migrated from legacy// Add real rules here as you migrate them from legacy pg/ folder// Example:// advisor.SchemaRuleStatementDisallowCommit,@@ -43,7 +48,8 @@ func TestPostgreSQLANTLRRules(t *testing.T) {// Add SQL review type here if you need metadata for test.var advisorNeedMockData = map[advisor.SQLReviewRuleType]bool{// advisor.SchemaRuleFullyQualifiedObjectName: true,- advisor.BuiltinRulePriorBackupCheck: true,- advisor.SchemaRuleColumnNotNull: true, // Needs metadata for PRIMARY KEY USING INDEX case+ advisor.BuiltinRulePriorBackupCheck: true,+ advisor.SchemaRuleColumnNotNull: true, // Needs metadata for PRIMARY KEY USING INDEX case+ advisor.SchemaRuleIndexTotalNumberLimit: true, // Needs catalog to count indexes// Other advisors don't need mock data}diff --git a/backend/plugin/advisor/pgantlr/test/index_total_number_limit.yaml b/backend/plugin/advisor/pgantlr/test/index_total_number_limit.yamlnew file mode 100644index 0000000000..0da89ace7c--- /dev/null+++ b/backend/plugin/advisor/pgantlr/test/index_total_number_limit.yaml@@ -0,0 +1,57 @@+- statement: CREATE TABLE t(a int, b int, c int, unique (a, b, c))+ changeType: 1+- statement: CREATE INDEX idx_id_name on tech_book(id, name)+ changeType: 1+- 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);+ changeType: 1+ want:+ - status: 2+ code: 813+ title: index.total-number-limit+ content: The count of index in table "public"."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);+ changeType: 1+ want:+ - status: 2+ code: 813+ title: index.total-number-limit+ content: The count of index in table "public"."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,+ CONSTRAINT idx_a_b_1 UNIQUE (a, b),+ CONSTRAINT idx_a_b_2 UNIQUE (a, b),+ CONSTRAINT idx_a_b_3 UNIQUE (a, b),+ CONSTRAINT idx_a_b_4 UNIQUE (a, b),+ CONSTRAINT idx_a_b_5 UNIQUE (a, b));+ changeType: 1+ want:+ - status: 2+ code: 813+ title: index.total-number-limit+ content: The count of index in table "public"."t" should be no more than 5, but found 6+ startposition:+ line: 9+ column: 0+ endposition: nulldiff --git a/backend/plugin/advisor/pgantlr/test/naming_column.yaml b/backend/plugin/advisor/pgantlr/test/naming_column.yamlnew file mode 100644index 0000000000..476da7f842--- /dev/null+++ b/backend/plugin/advisor/pgantlr/test/naming_column.yaml@@ -0,0 +1,51 @@+- statement: CREATE TABLE book(id int, "creatorId" int)+ changeType: 1+ 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, qavszgslczmsacubtvyymzhojfytkcmon int)+ changeType: 1+- statement: CREATE TABLE book(id int, creator_Id int)+ changeType: 1+- statement: CREATE TABLE book(id int, creator_id int)+ changeType: 1+- statement: |-+ CREATE TABLE book(id int, creator_id int);+ ALTER TABLE book ADD COLUMN "creatorId" int+ changeType: 1+ 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+- statement: |-+ CREATE TABLE book(id int, creator_id int);+ ALTER TABLE book ADD COLUMN "creator" int+ changeType: 1+- statement: |-+ CREATE TABLE book(id int, creator_id int);+ ALTER TABLE book RENAME COLUMN creator_id TO "creatorId"+ changeType: 1+ 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+- statement: |-+ CREATE TABLE book(id int, creator_id int);+ ALTER TABLE book RENAME COLUMN creator_id TO "creator"+ changeType: 1diff --git a/backend/plugin/advisor/pgantlr/test/statement_insert_disallow_order_by_rand.yaml b/backend/plugin/advisor/pgantlr/test/statement_insert_disallow_order_by_rand.yamlnew file mode 100644index 0000000000..1a68ee82e8--- /dev/null+++ b/backend/plugin/advisor/pgantlr/test/statement_insert_disallow_order_by_rand.yaml@@ -0,0 +1,13 @@+- statement: INSERT INTO tech_book VALUES(1, "a")+ changeType: 1+- statement: INSERT INTO tech_book SELECT * FROM tech_book ORDER BY random()+ changeType: 1+ want:+ - status: 2+ code: 1108+ title: statement.insert.disallow-order-by-rand+ content: The INSERT statement uses ORDER BY random() or random_between(), related statement "INSERT INTO tech_book SELECT * FROM tech_book ORDER BY random()"+ startposition:+ line: 1+ column: 0+ endposition: nulldiff --git a/backend/plugin/advisor/pgantlr/test/statement_insert_must_specify_column.yaml b/backend/plugin/advisor/pgantlr/test/statement_insert_must_specify_column.yamlnew file mode 100644index 0000000000..b089a7fc59--- /dev/null+++ b/backend/plugin/advisor/pgantlr/test/statement_insert_must_specify_column.yaml@@ -0,0 +1,13 @@+- statement: INSERT INTO tech_book(id, name) VALUES (1, '1')+ changeType: 1+- statement: INSERT INTO tech_book VALUES (1, '1')+ changeType: 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: 1+ column: 0+ endposition: nulldiff --git a/backend/plugin/advisor/pgantlr/test/statement_insert_row_limit.yaml b/backend/plugin/advisor/pgantlr/test/statement_insert_row_limit.yamlnew file mode 100644index 0000000000..ff6a96ce06--- /dev/null+++ b/backend/plugin/advisor/pgantlr/test/statement_insert_row_limit.yaml@@ -0,0 +1,15 @@+- statement: INSERT INTO tech_book values(1, 'a')+ changeType: 1+- statement: INSERT INTO tech_book values(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e'), (6, 'f')+ changeType: 1+ want:+ - status: 2+ code: 1101+ title: statement.insert.row-limit+ content: The statement "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: 1+ column: 0+ endposition: null+- statement: INSERT INTO tech_book SELECT * FROM tech_book;+ changeType: 1diff --git a/backend/plugin/advisor/pgantlr/test_helper.go b/backend/plugin/advisor/pgantlr/test_helper.goindex 83e4dfafdb..952e1c71d3 100644--- a/backend/plugin/advisor/pgantlr/test_helper.go+++ b/backend/plugin/advisor/pgantlr/test_helper.go@@ -16,6 +16,7 @@ import ("github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/catalog""github.com/bytebase/bytebase/backend/plugin/parser/pg"+ pglegacy "github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy")// TestCase is the data struct for test.@@ -74,6 +75,14 @@ func RunANTLRAdvisorRuleTest(t *testing.T, rule advisor.SQLReviewRuleType, dbTyptree, err := pg.ParsePostgreSQL(tc.Statement)require.NoError(t, err, "Failed to parse SQL: %s", tc.Statement)+ // Also parse with legacy parser for catalog WalkThrough+ if needMetaData {+ legacyAST, err := pglegacy.Parse(pglegacy.ParseContext{}, tc.Statement)+ require.NoError(t, err, "Failed to parse SQL with legacy parser: %s", tc.Statement)+ err = finder.WalkThrough(legacyAST)+ require.NoError(t, err, "Failed to walk through catalog: %s", tc.Statement)+ }+ruleList := []*storepb.SQLReviewRule{{Type: string(rule),diff --git a/backend/plugin/advisor/pgantlr/utils.go b/backend/plugin/advisor/pgantlr/utils.goindex 3b12202b24..1ad3db8da3 100644--- a/backend/plugin/advisor/pgantlr/utils.go+++ b/backend/plugin/advisor/pgantlr/utils.go@@ -2,6 +2,7 @@ package pgantlrimport ("strconv"+ "strings""github.com/antlr4-go/antlr/v4"parser "github.com/bytebase/parser/postgresql"@@ -54,6 +55,16 @@ func extractTableName(ctx parser.IQualified_nameContext) string {return parts[len(parts)-1]}+// extractSchemaName extracts the schema name (first component) from a qualified name.+// Returns empty string if only table name is provided (implying default schema).+func extractSchemaName(ctx parser.IQualified_nameContext) string {+ parts := pg.NormalizePostgreSQLQualifiedName(ctx)+ if len(parts) <= 1 {+ return ""+ }+ return parts[0]+}+// extractIntegerConstant extracts an integer value from an Iconst context.// Returns the integer value and an error if parsing fails.func extractIntegerConstant(ctx parser.IIconstContext) (int, error) {@@ -82,3 +93,28 @@ func extractStringConstant(ctx parser.ISconstContext) string {}return text}++// extractStatementText extracts a statement from the full statements text using line numbers.+// Handles multi-line statements by extracting all lines from startLine to endLine.+func extractStatementText(statementsText string, startLine, endLine int) string {+ lines := strings.Split(statementsText, "\n")+ if startLine < 1 || startLine > len(lines) {+ return ""+ }++ // Convert to 0-indexed+ startIdx := startLine - 1+ endIdx := endLine - 1++ if endIdx >= len(lines) {+ endIdx = len(lines) - 1+ }++ // Extract the lines for this statement+ var stmtLines []string+ for i := startIdx; i <= endIdx; i++ {+ stmtLines = append(stmtLines, lines[i])+ }++ return strings.TrimSpace(strings.Join(stmtLines, " "))+}