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 10 PostgreSQL advisors to ANTLR parser (#17836)
h3n4l46c06a43e767
diff --git a/backend/plugin/advisor/pgantlr/advisor_migration_compatibility.go b/backend/plugin/advisor/pgantlr/advisor_migration_compatibility.gonew file mode 100644index 0000000000..edbf9b5d71--- /dev/null+++ b/backend/plugin/advisor/pgantlr/advisor_migration_compatibility.go@@ -0,0 +1,279 @@+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 = (*CompatibilityAdvisor)(nil)+)++func init() {+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleSchemaBackwardCompatibility, &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) {+ tree, err := getANTLRTree(checkCtx)+ if err != nil {+ return nil, err+ }++ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)+ if err != nil {+ return nil, err+ }++ checker := &compatibilityChecker{+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},+ level: level,+ title: string(checkCtx.Rule.Type),+ statementsText: checkCtx.Statements,+ }++ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)++ return checker.adviceList, nil+}++type compatibilityChecker struct {+ *parser.BasePostgreSQLParserListener++ adviceList []*storepb.Advice+ level storepb.Advice_Status+ title string+ statementsText string+ lastCreateTable string+}++// EnterCreatestmt tracks CREATE TABLE statements+func (c *compatibilityChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ qualifiedNames := ctx.AllQualified_name()+ if len(qualifiedNames) > 0 {+ c.lastCreateTable = extractTableName(qualifiedNames[0])+ }+}++// EnterDropdbstmt handles DROP DATABASE+func (c *compatibilityChecker) EnterDropdbstmt(ctx *parser.DropdbstmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ stmtText := extractStatementText(c.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: advisor.CompatibilityDropDatabase.Int32(),+ Title: c.title,+ Content: fmt.Sprintf(`"%s" may cause incompatibility with the existing data and code`, stmtText),+ StartPosition: &storepb.Position{+ Line: int32(ctx.GetStart().GetLine()),+ Column: 0,+ },+ })+}++// EnterDropstmt handles DROP TABLE/VIEW+func (c *compatibilityChecker) EnterDropstmt(ctx *parser.DropstmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ // Check if this is DROP TABLE or DROP VIEW+ if ctx.Object_type_any_name() != nil {+ objType := ctx.Object_type_any_name()+ if objType.TABLE() != nil || objType.VIEW() != nil {+ stmtText := extractStatementText(c.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: advisor.CompatibilityDropTable.Int32(),+ Title: c.title,+ Content: fmt.Sprintf(`"%s" may cause incompatibility with the existing data and code`, stmtText),+ StartPosition: &storepb.Position{+ Line: int32(ctx.GetStart().GetLine()),+ Column: 0,+ },+ })+ }+ }+}++// EnterRenamestmt handles ALTER TABLE RENAME and RENAME COLUMN+func (c *compatibilityChecker) EnterRenamestmt(ctx *parser.RenamestmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ code := advisor.Ok++ // Check if this is a column rename+ if ctx.Opt_column() != nil && ctx.Opt_column().COLUMN() != nil {+ // RENAME COLUMN - check if not on last created table+ if ctx.Relation_expr() != nil && ctx.Relation_expr().Qualified_name() != nil {+ tableName := extractTableName(ctx.Relation_expr().Qualified_name())+ if c.lastCreateTable != tableName {+ code = advisor.CompatibilityRenameColumn+ }+ }+ } else {+ // RENAME TABLE/VIEW+ code = advisor.CompatibilityRenameTable+ }++ 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(`"%s" may cause incompatibility with the existing data and code`, stmtText),+ StartPosition: &storepb.Position{+ Line: int32(ctx.GetStart().GetLine()),+ Column: 0,+ },+ })+ }+}++// EnterAltertablestmt handles various ALTER TABLE commands+func (c *compatibilityChecker) 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())++ // Skip if this is the table we just created+ if c.lastCreateTable == tableName {+ return+ }++ if ctx.Alter_table_cmds() == nil {+ return+ }++ allCmds := ctx.Alter_table_cmds().AllAlter_table_cmd()+ for _, cmd := range allCmds {+ code := advisor.Ok++ // DROP COLUMN+ if cmd.DROP() != nil && cmd.COLUMN() != nil {+ code = advisor.CompatibilityDropColumn+ }++ // ALTER COLUMN TYPE+ if cmd.ALTER() != nil && cmd.TYPE_P() != nil {+ code = advisor.CompatibilityAlterColumn+ }++ // ADD CONSTRAINT+ if cmd.ADD_P() != nil && cmd.Tableconstraint() != nil {+ constraint := cmd.Tableconstraint()+ if constraint.Constraintelem() != nil {+ elem := constraint.Constraintelem()++ // PRIMARY KEY+ if elem.PRIMARY() != nil && elem.KEY() != nil {+ code = advisor.CompatibilityAddPrimaryKey+ }++ // UNIQUE+ if elem.UNIQUE() != nil {+ code = advisor.CompatibilityAddUniqueKey+ }++ // FOREIGN KEY+ if elem.FOREIGN() != nil && elem.KEY() != nil {+ code = advisor.CompatibilityAddForeignKey+ }++ // CHECK - only if NOT VALID is not present+ if elem.CHECK() != nil {+ // Check if NOT VALID is present in constraint attributes+ hasNotValid := false+ if elem.Constraintattributespec() != nil {+ allAttrs := elem.Constraintattributespec().AllConstraintattributeElem()+ for _, attr := range allAttrs {+ if attr.NOT() != nil && attr.VALID() != nil {+ hasNotValid = true+ break+ }+ }+ }+ if !hasNotValid {+ code = advisor.CompatibilityAddCheck+ }+ }+ }+ }++ 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(`"%s" may cause incompatibility with the existing data and code`, stmtText),+ StartPosition: &storepb.Position{+ Line: int32(ctx.GetStart().GetLine()),+ Column: 0,+ },+ })+ return+ }+ }+}++// EnterIndexstmt handles CREATE UNIQUE INDEX+func (c *compatibilityChecker) EnterIndexstmt(ctx *parser.IndexstmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ // Check if this is CREATE UNIQUE INDEX+ if ctx.Opt_unique() == nil || ctx.Opt_unique().UNIQUE() == nil {+ return+ }++ // Get table name+ if ctx.Relation_expr() == nil || ctx.Relation_expr().Qualified_name() == nil {+ return+ }+ tableName := extractTableName(ctx.Relation_expr().Qualified_name())++ // Skip if this is the table we just created+ if c.lastCreateTable == tableName {+ return+ }++ stmtText := extractStatementText(c.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: advisor.CompatibilityAddUniqueKey.Int32(),+ Title: c.title,+ Content: fmt.Sprintf(`"%s" may cause incompatibility with the existing data and code`, stmtText),+ StartPosition: &storepb.Position{+ Line: int32(ctx.GetStart().GetLine()),+ Column: 0,+ },+ })+}diff --git a/backend/plugin/advisor/pgantlr/advisor_naming_table.go b/backend/plugin/advisor/pgantlr/advisor_naming_table.gonew file mode 100644index 0000000000..c7c48aad3f--- /dev/null+++ b/backend/plugin/advisor/pgantlr/advisor_naming_table.go@@ -0,0 +1,124 @@+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"+ pgparser "github.com/bytebase/bytebase/backend/plugin/parser/pg"+)++var (+ _ advisor.Advisor = (*NamingTableConventionAdvisor)(nil)+)++func init() {+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleTableNaming, &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) {+ 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 := &namingTableConventionChecker{+ 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 namingTableConventionChecker struct {+ *parser.BasePostgreSQLParserListener++ adviceList []*storepb.Advice+ level storepb.Advice_Status+ title string+ format *regexp.Regexp+ maxLength int+}++// EnterCreatestmt handles CREATE TABLE+func (c *namingTableConventionChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ allQualifiedNames := ctx.AllQualified_name()+ if len(allQualifiedNames) > 0 {+ tableName := extractTableName(allQualifiedNames[0])+ c.checkTableName(tableName, ctx)+ }+}++// EnterRenamestmt handles ALTER TABLE RENAME TO+func (c *namingTableConventionChecker) EnterRenamestmt(ctx *parser.RenamestmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ // Check for ALTER TABLE ... RENAME TO new_name+ if ctx.TABLE() != nil && ctx.TO() != nil {+ allNames := ctx.AllName()+ if len(allNames) > 0 {+ // The new table name is the last Name() in RENAME TO new_name+ newTableName := pgparser.NormalizePostgreSQLName(allNames[len(allNames)-1])+ c.checkTableName(newTableName, ctx)+ }+ }+}++func (c *namingTableConventionChecker) checkTableName(tableName string, ctx antlr.ParserRuleContext) {+ if !c.format.MatchString(tableName) {+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: advisor.NamingTableConventionMismatch.Int32(),+ Title: c.title,+ Content: fmt.Sprintf(`"%s" mismatches table naming convention, naming format should be %q`, tableName, c.format),+ StartPosition: &storepb.Position{+ Line: int32(ctx.GetStart().GetLine()),+ Column: 0,+ },+ })+ }+ if c.maxLength > 0 && len(tableName) > c.maxLength {+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: advisor.NamingTableConventionMismatch.Int32(),+ Title: c.title,+ Content: fmt.Sprintf("\"%s\" mismatches table naming convention, its length should be within %d characters", tableName, c.maxLength),+ StartPosition: &storepb.Position{+ Line: int32(ctx.GetStart().GetLine()),+ Column: 0,+ },+ })+ }+}diff --git a/backend/plugin/advisor/pgantlr/advisor_statement_add_check_not_valid.go b/backend/plugin/advisor/pgantlr/advisor_statement_add_check_not_valid.gonew file mode 100644index 0000000000..72b147f400--- /dev/null+++ b/backend/plugin/advisor/pgantlr/advisor_statement_add_check_not_valid.go@@ -0,0 +1,153 @@+package pgantlr++import (+ "context"++ "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 = (*StatementAddCheckNotValidAdvisor)(nil)+)++func init() {+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleStatementAddCheckNotValid, &StatementAddCheckNotValidAdvisor{})+}++// StatementAddCheckNotValidAdvisor is the advisor checking for to add check not valid.+type StatementAddCheckNotValidAdvisor struct {+}++// Check checks for to add check not valid.+func (*StatementAddCheckNotValidAdvisor) 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 := &statementAddCheckNotValidChecker{+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},+ level: level,+ title: string(checkCtx.Rule.Type),+ }++ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)++ return checker.adviceList, nil+}++type statementAddCheckNotValidChecker struct {+ *parser.BasePostgreSQLParserListener++ adviceList []*storepb.Advice+ level storepb.Advice_Status+ title string+}++// EnterColconstraint handles column-level constraints in ALTER TABLE ADD CONSTRAINT ... CHECK+// This handles the case where CHECK constraint is parsed as a column-level constraint+func (c *statementAddCheckNotValidChecker) EnterColconstraint(ctx *parser.ColconstraintContext) {+ // Check if this is within an ALTER TABLE statement+ parent := ctx.GetParent()+ var alterTableCtx *parser.AltertablestmtContext+ for parent != nil {+ if altCtx, ok := parent.(*parser.AltertablestmtContext); ok {+ alterTableCtx = altCtx+ if !isTopLevel(alterTableCtx.GetParent()) {+ return+ }+ break+ }+ parent = parent.GetParent()+ }++ // Only process if we're within an ALTER TABLE+ if alterTableCtx == nil {+ return+ }++ // Check if this is a CHECK constraint+ if ctx.Colconstraintelem() != nil {+ constraintElem := ctx.Colconstraintelem()+ if constraintElem.CHECK() != nil {+ // For column-level constraints, NOT VALID would be in Constraintattr+ // But since this is parsed as a column constraint, it won't have NOT VALID+ // (when NOT VALID is present, it's parsed as a table constraint)+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: advisor.StatementAddCheckWithValidation.Int32(),+ Title: c.title,+ Content: "Adding check constraints with validation will block reads and writes. You can add check constraints not valid and then validate separately",+ StartPosition: &storepb.Position{+ Line: int32(alterTableCtx.GetStart().GetLine()),+ Column: 0,+ },+ })+ }+ }+}++// EnterTableconstraint handles table-level constraints in ALTER TABLE ADD CONSTRAINT ... CHECK+// This handles the case where CHECK constraint is parsed as a table-level constraint (e.g., with NOT VALID)+func (c *statementAddCheckNotValidChecker) EnterTableconstraint(ctx *parser.TableconstraintContext) {+ // Check if this is within an ALTER TABLE statement+ parent := ctx.GetParent()+ var alterTableCtx *parser.AltertablestmtContext+ for parent != nil {+ if altCtx, ok := parent.(*parser.AltertablestmtContext); ok {+ alterTableCtx = altCtx+ if !isTopLevel(alterTableCtx.GetParent()) {+ return+ }+ break+ }+ parent = parent.GetParent()+ }++ // Only process if we're within an ALTER TABLE+ if alterTableCtx == nil {+ return+ }++ // Check if this is a CHECK constraint+ if ctx.Constraintelem() != nil {+ constraintElem := ctx.Constraintelem()+ if constraintElem.CHECK() != nil {+ // Check if NOT VALID is specified+ hasNotValid := false+ if constraintElem.Constraintattributespec() != nil {+ allAttrs := constraintElem.Constraintattributespec().AllConstraintattributeElem()+ for _, attr := range allAttrs {+ // Check for NOT VALID+ if attr.NOT() != nil && attr.VALID() != nil {+ hasNotValid = true+ break+ }+ }+ }++ if !hasNotValid {+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: advisor.StatementAddCheckWithValidation.Int32(),+ Title: c.title,+ Content: "Adding check constraints with validation will block reads and writes. You can add check constraints not valid and then validate separately",+ StartPosition: &storepb.Position{+ Line: int32(alterTableCtx.GetStart().GetLine()),+ Column: 0,+ },+ })+ }+ }+ }+}diff --git a/backend/plugin/advisor/pgantlr/advisor_statement_add_fk_not_valid.go b/backend/plugin/advisor/pgantlr/advisor_statement_add_fk_not_valid.gonew file mode 100644index 0000000000..01c9120f52--- /dev/null+++ b/backend/plugin/advisor/pgantlr/advisor_statement_add_fk_not_valid.go@@ -0,0 +1,117 @@+package pgantlr++import (+ "context"++ "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 = (*StatementAddFKNotValidAdvisor)(nil)+)++func init() {+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleStatementAddFKNotValid, &StatementAddFKNotValidAdvisor{})+}++// StatementAddFKNotValidAdvisor is the advisor checking for adding foreign key constraints without NOT VALID.+type StatementAddFKNotValidAdvisor struct {+}++// Check checks for adding foreign key constraints without NOT VALID.+func (*StatementAddFKNotValidAdvisor) 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 := &statementAddFKNotValidChecker{+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},+ level: level,+ title: string(checkCtx.Rule.Type),+ }++ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)++ return checker.adviceList, nil+}++type statementAddFKNotValidChecker struct {+ *parser.BasePostgreSQLParserListener++ adviceList []*storepb.Advice+ level storepb.Advice_Status+ title string+}++// EnterAltertablestmt handles ALTER TABLE ADD CONSTRAINT FOREIGN KEY+func (c *statementAddFKNotValidChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ if ctx.Alter_table_cmds() == nil {+ return+ }++ allCmds := ctx.Alter_table_cmds().AllAlter_table_cmd()+ for _, cmd := range allCmds {+ // Check for ADD + something+ if cmd.ADD_P() == nil {+ continue+ }++ // Check for Tableconstraint+ if cmd.Tableconstraint() == nil {+ continue+ }++ constraint := cmd.Tableconstraint()+ if constraint.Constraintelem() == nil {+ continue+ }++ elem := constraint.Constraintelem()++ // Check if this is a FOREIGN KEY constraint+ if elem.FOREIGN() == nil || elem.KEY() == nil {+ continue+ }++ // Check if NOT VALID is present+ hasNotValid := false+ if elem.Constraintattributespec() != nil {+ allAttrs := elem.Constraintattributespec().AllConstraintattributeElem()+ for _, attr := range allAttrs {+ if attr.NOT() != nil && attr.VALID() != nil {+ hasNotValid = true+ break+ }+ }+ }++ // If NOT VALID is not present, this is a problem+ if !hasNotValid {+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: advisor.StatementAddFKWithValidation.Int32(),+ Title: c.title,+ Content: "Adding foreign keys with validation will block reads and writes. You can add check foreign keys not valid and then validate separately",+ StartPosition: &storepb.Position{+ Line: int32(ctx.GetStart().GetLine()),+ Column: 0,+ },+ })+ }+ }+}diff --git a/backend/plugin/advisor/pgantlr/advisor_statement_affected_row_limit.go b/backend/plugin/advisor/pgantlr/advisor_statement_affected_row_limit.gonew file mode 100644index 0000000000..ce43427115--- /dev/null+++ b/backend/plugin/advisor/pgantlr/advisor_statement_affected_row_limit.go@@ -0,0 +1,174 @@+package pgantlr++import (+ "context"+ "database/sql"+ "fmt"++ "github.com/antlr4-go/antlr/v4"++ 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 = (*StatementAffectedRowLimitAdvisor)(nil)+)++func init() {+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleStatementAffectedRowLimit, &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) {+ 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 := &statementAffectedRowLimitChecker{+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},+ level: level,+ title: string(checkCtx.Rule.Type),+ maxRow: payload.Number,+ ctx: ctx,+ driver: checkCtx.Driver,+ usePostgresDatabaseOwner: checkCtx.UsePostgresDatabaseOwner,+ statementsText: checkCtx.Statements,+ }++ // Only run EXPLAIN queries if we have a limit and database connection+ if payload.Number > 0 && checker.driver != nil {+ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)+ }++ return checker.adviceList, nil+}++type statementAffectedRowLimitChecker struct {+ *parser.BasePostgreSQLParserListener++ adviceList []*storepb.Advice+ level storepb.Advice_Status+ title string+ maxRow int+ driver *sql.DB+ ctx context.Context+ explainCount int+ setRoles []string+ usePostgresDatabaseOwner bool+ statementsText string+}++// EnterVariablesetstmt handles SET ROLE statements+func (c *statementAffectedRowLimitChecker) EnterVariablesetstmt(ctx *parser.VariablesetstmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ // Check if this is SET ROLE+ if ctx.SET() != nil && ctx.Set_rest() != nil && ctx.Set_rest().Set_rest_more() != nil {+ setRestMore := ctx.Set_rest().Set_rest_more()+ if setRestMore.ROLE() != nil {+ // Store the SET ROLE statement text+ stmtText := extractStatementText(c.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())+ c.setRoles = append(c.setRoles, stmtText)+ }+ }+}++// EnterUpdatestmt handles UPDATE statements+func (c *statementAffectedRowLimitChecker) EnterUpdatestmt(ctx *parser.UpdatestmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ c.checkAffectedRows(ctx)+}++// EnterDeletestmt handles DELETE statements+func (c *statementAffectedRowLimitChecker) EnterDeletestmt(ctx *parser.DeletestmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ c.checkAffectedRows(ctx)+}++func (c *statementAffectedRowLimitChecker) checkAffectedRows(ctx antlr.ParserRuleContext) {+ // Check if we've hit the maximum number of EXPLAIN queries+ if c.explainCount >= common.MaximumLintExplainSize {+ return+ }++ c.explainCount++++ // Get the statement text+ stmtText := extractStatementText(c.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())+ normalizedStmt := advisor.NormalizeStatement(stmtText)++ // Run EXPLAIN to get estimated row count+ 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", normalizedStmt, 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", normalizedStmt, err.Error()),+ StartPosition: &storepb.Position{+ Line: int32(ctx.GetStart().GetLine()),+ Column: 0,+ },+ })+ return+ }++ if rowCount > int64(c.maxRow) {+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: advisor.StatementAffectedRowExceedsLimit.Int32(),+ Title: c.title,+ Content: fmt.Sprintf("The statement \"%s\" affected %d rows (estimated). The count exceeds %d.", normalizedStmt, rowCount, c.maxRow),+ StartPosition: &storepb.Position{+ Line: int32(ctx.GetStart().GetLine()),+ Column: 0,+ },+ })+ }+}diff --git a/backend/plugin/advisor/pgantlr/advisor_statement_create_specify_schema.go b/backend/plugin/advisor/pgantlr/advisor_statement_create_specify_schema.gonew file mode 100644index 0000000000..73dad1c449--- /dev/null+++ b/backend/plugin/advisor/pgantlr/advisor_statement_create_specify_schema.go@@ -0,0 +1,77 @@+package pgantlr++import (+ "context"++ "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 = (*StatementCreateSpecifySchema)(nil)+)++func init() {+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleStatementCreateSpecifySchema, &StatementCreateSpecifySchema{})+}++type StatementCreateSpecifySchema struct {+}++func (*StatementCreateSpecifySchema) 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 := &statementCreateSpecifySchemaChecker{+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},+ level: level,+ title: string(checkCtx.Rule.Type),+ }++ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)++ return checker.adviceList, nil+}++type statementCreateSpecifySchemaChecker struct {+ *parser.BasePostgreSQLParserListener++ adviceList []*storepb.Advice+ level storepb.Advice_Status+ title string+}++// EnterCreatestmt handles CREATE TABLE+func (c *statementCreateSpecifySchemaChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ allQualifiedNames := ctx.AllQualified_name()+ if len(allQualifiedNames) > 0 {+ schemaName := extractSchemaName(allQualifiedNames[0])+ if schemaName == "" {+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: advisor.StatementCreateWithoutSchemaName.Int32(),+ Title: c.title,+ Content: "Table schema should be specified.",+ StartPosition: &storepb.Position{+ Line: int32(ctx.GetStart().GetLine()),+ Column: 0,+ },+ })+ }+ }+}diff --git a/backend/plugin/advisor/pgantlr/advisor_statement_disallow_add_column_with_default.go b/backend/plugin/advisor/pgantlr/advisor_statement_disallow_add_column_with_default.gonew file mode 100644index 0000000000..8286ce5d0b--- /dev/null+++ b/backend/plugin/advisor/pgantlr/advisor_statement_disallow_add_column_with_default.go@@ -0,0 +1,96 @@+package pgantlr++import (+ "context"++ "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 = (*StatementDisallowAddColumnWithDefaultAdvisor)(nil)+)++func init() {+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleStatementDisallowAddColumnWithDefault, &StatementDisallowAddColumnWithDefaultAdvisor{})+}++// StatementDisallowAddColumnWithDefaultAdvisor is the advisor checking for to disallow add column with default.+type StatementDisallowAddColumnWithDefaultAdvisor struct {+}++// Check checks for to disallow add column with default.+func (*StatementDisallowAddColumnWithDefaultAdvisor) 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 := &statementDisallowAddColumnWithDefaultChecker{+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},+ level: level,+ title: string(checkCtx.Rule.Type),+ }++ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)++ return checker.adviceList, nil+}++type statementDisallowAddColumnWithDefaultChecker struct {+ *parser.BasePostgreSQLParserListener++ adviceList []*storepb.Advice+ level storepb.Advice_Status+ title string+}++// EnterAltertablestmt handles ALTER TABLE ADD COLUMN+func (c *statementDisallowAddColumnWithDefaultChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ // Check all alter table commands+ if ctx.Alter_table_cmds() != nil {+ allCmds := ctx.Alter_table_cmds().AllAlter_table_cmd()+ for _, cmd := range allCmds {+ // Check for ADD COLUMN+ if cmd.ADD_P() != nil && cmd.ColumnDef() != nil {+ columnDef := cmd.ColumnDef()+ // Check if the column has a DEFAULT constraint+ if columnDef.Colquallist() != nil {+ allConstraints := columnDef.Colquallist().AllColconstraint()+ for _, constraint := range allConstraints {+ if constraint.Colconstraintelem() != nil {+ constraintElem := constraint.Colconstraintelem()+ // Check for DEFAULT constraint+ if constraintElem.DEFAULT() != nil {+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: advisor.StatementAddColumnWithDefault.Int32(),+ Title: c.title,+ Content: "Adding column with DEFAULT will locked the whole table and rewriting each rows",+ StartPosition: &storepb.Position{+ Line: int32(ctx.GetStart().GetLine()),+ Column: 0,+ },+ })+ return+ }+ }+ }+ }+ }+ }+ }+}diff --git a/backend/plugin/advisor/pgantlr/advisor_statement_disallow_add_not_null.go b/backend/plugin/advisor/pgantlr/advisor_statement_disallow_add_not_null.gonew file mode 100644index 0000000000..c4d48238ca--- /dev/null+++ b/backend/plugin/advisor/pgantlr/advisor_statement_disallow_add_not_null.go@@ -0,0 +1,89 @@+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"+ pgparser "github.com/bytebase/bytebase/backend/plugin/parser/pg"+)++var (+ _ advisor.Advisor = (*StatementDisallowAddNotNullAdvisor)(nil)+)++func init() {+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleStatementDisallowAddNotNull, &StatementDisallowAddNotNullAdvisor{})+}++// StatementDisallowAddNotNullAdvisor is the advisor checking for to disallow add not null.+type StatementDisallowAddNotNullAdvisor struct {+}++// Check checks for to disallow add not null.+func (*StatementDisallowAddNotNullAdvisor) 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 := &statementDisallowAddNotNullChecker{+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},+ level: level,+ title: string(checkCtx.Rule.Type),+ }++ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)++ return checker.adviceList, nil+}++type statementDisallowAddNotNullChecker struct {+ *parser.BasePostgreSQLParserListener++ adviceList []*storepb.Advice+ level storepb.Advice_Status+ title string+}++// EnterAltertablestmt handles ALTER TABLE ALTER COLUMN SET NOT NULL+func (c *statementDisallowAddNotNullChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ // Check all alter table commands+ if ctx.Alter_table_cmds() != nil {+ allCmds := ctx.Alter_table_cmds().AllAlter_table_cmd()+ for _, cmd := range allCmds {+ // Check for ALTER COLUMN ... SET NOT NULL+ if cmd.ALTER() != nil && cmd.SET() != nil && cmd.NOT() != nil && cmd.NULL_P() != nil {+ // Get the column name+ allColIDs := cmd.AllColid()+ if len(allColIDs) > 0 {+ columnName := pgparser.NormalizePostgreSQLColid(allColIDs[0])+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: advisor.StatementAddNotNull.Int32(),+ Title: c.title,+ Content: fmt.Sprintf("Setting NOT NULL will block reads and writes. You can use CHECK (%q IS NOT NULL) instead", columnName),+ StartPosition: &storepb.Position{+ Line: int32(ctx.GetStart().GetLine()),+ Column: 0,+ },+ })+ }+ }+ }+ }+}diff --git a/backend/plugin/advisor/pgantlr/advisor_statement_disallow_commit.go b/backend/plugin/advisor/pgantlr/advisor_statement_disallow_commit.gonew file mode 100644index 0000000000..e54c335c18--- /dev/null+++ b/backend/plugin/advisor/pgantlr/advisor_statement_disallow_commit.go@@ -0,0 +1,82 @@+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 = (*StatementDisallowCommitAdvisor)(nil)+)++func init() {+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleStatementDisallowCommit, &StatementDisallowCommitAdvisor{})+}++// StatementDisallowCommitAdvisor is the advisor checking for disallowing COMMIT statements.+type StatementDisallowCommitAdvisor struct {+}++// Check checks for disallowing COMMIT statements.+func (*StatementDisallowCommitAdvisor) 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 := &statementDisallowCommitChecker{+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},+ level: level,+ title: string(checkCtx.Rule.Type),+ statementsText: checkCtx.Statements,+ }++ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)++ return checker.adviceList, nil+}++type statementDisallowCommitChecker struct {+ *parser.BasePostgreSQLParserListener++ adviceList []*storepb.Advice+ level storepb.Advice_Status+ title string+ statementsText string+}++// EnterTransactionstmt handles COMMIT statements+func (c *statementDisallowCommitChecker) EnterTransactionstmt(ctx *parser.TransactionstmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ // Check if this is a COMMIT statement+ if ctx.COMMIT() == nil {+ return+ }++ stmtText := extractStatementText(c.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: advisor.StatementDisallowCommit.Int32(),+ Title: c.title,+ Content: fmt.Sprintf("Commit is not allowed, related statement: \"%s\"", stmtText),+ StartPosition: &storepb.Position{+ Line: int32(ctx.GetStart().GetLine()),+ Column: 0,+ },+ })+}diff --git a/backend/plugin/advisor/pgantlr/advisor_statement_disallow_mix_in_ddl.go b/backend/plugin/advisor/pgantlr/advisor_statement_disallow_mix_in_ddl.gonew file mode 100644index 0000000000..715e982bb1--- /dev/null+++ b/backend/plugin/advisor/pgantlr/advisor_statement_disallow_mix_in_ddl.go@@ -0,0 +1,135 @@+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 = (*StatementDisallowMixInDDLAdvisor)(nil)+)++func init() {+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleStatementDisallowMixInDDL, &StatementDisallowMixInDDLAdvisor{})+}++// StatementDisallowMixInDDLAdvisor is the advisor checking for disallow mix DDL and DML.+type StatementDisallowMixInDDLAdvisor struct {+}++// Check checks for disallow mix DDL and DML.+func (*StatementDisallowMixInDDLAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {+ // Only check when change type is DDL+ switch checkCtx.ChangeType {+ case storepb.PlanCheckRunConfig_DDL, storepb.PlanCheckRunConfig_SDL, storepb.PlanCheckRunConfig_DDL_GHOST:+ default:+ return nil, nil+ }++ tree, err := getANTLRTree(checkCtx)+ if err != nil {+ return nil, err+ }++ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)+ if err != nil {+ return nil, err+ }++ checker := &statementDisallowMixInDDLChecker{+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},+ level: level,+ title: string(checkCtx.Rule.Type),+ statementsText: checkCtx.Statements,+ }++ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)++ return checker.adviceList, nil+}++type statementDisallowMixInDDLChecker struct {+ *parser.BasePostgreSQLParserListener++ adviceList []*storepb.Advice+ level storepb.Advice_Status+ title string+ statementsText string+}++// EnterSelectstmt handles SELECT statements (DML)+func (c *statementDisallowMixInDDLChecker) EnterSelectstmt(ctx *parser.SelectstmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ c.addDMLAdvice(ctx, "SELECT")+}++// EnterInsertstmt handles INSERT statements (DML)+func (c *statementDisallowMixInDDLChecker) EnterInsertstmt(ctx *parser.InsertstmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ c.addDMLAdvice(ctx, "INSERT")+}++// EnterUpdatestmt handles UPDATE statements (DML)+func (c *statementDisallowMixInDDLChecker) EnterUpdatestmt(ctx *parser.UpdatestmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ c.addDMLAdvice(ctx, "UPDATE")+}++// EnterDeletestmt handles DELETE statements (DML)+func (c *statementDisallowMixInDDLChecker) EnterDeletestmt(ctx *parser.DeletestmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ c.addDMLAdvice(ctx, "DELETE")+}++func (c *statementDisallowMixInDDLChecker) addDMLAdvice(ctx antlr.ParserRuleContext, _ string) {+ // Extract the statement text including semicolon using character positions+ startPos := ctx.GetStart().GetStart()+ stopPos := ctx.GetStop().GetStop()++ // Find the semicolon after this statement+ stmtText := ""+ if stopPos+1 < len(c.statementsText) {+ // Look for semicolon+ endPos := stopPos + 1+ for endPos < len(c.statementsText) && c.statementsText[endPos] != ';' {+ endPos+++ }+ if endPos < len(c.statementsText) {+ stmtText = c.statementsText[startPos : endPos+1]+ } else {+ stmtText = c.statementsText[startPos:stopPos+1] + ";"+ }+ } else {+ stmtText = c.statementsText[startPos:stopPos+1] + ";"+ }++ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: advisor.StatementDisallowMixDDLDML.Int32(),+ Title: c.title,+ Content: fmt.Sprintf("Alter schema can only run DDL, %q is not DDL", stmtText),+ StartPosition: &storepb.Position{+ Line: int32(ctx.GetStart().GetLine()),+ Column: 0,+ },+ })+}diff --git a/backend/plugin/advisor/pgantlr/advisor_statement_non_transactional.go b/backend/plugin/advisor/pgantlr/advisor_statement_non_transactional.gonew file mode 100644index 0000000000..b0406dfe30--- /dev/null+++ b/backend/plugin/advisor/pgantlr/advisor_statement_non_transactional.go@@ -0,0 +1,99 @@+package pgantlr++import (+ "context"++ "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/db/pg"+)++var (+ _ advisor.Advisor = (*NonTransactionalAdvisor)(nil)+)++func init() {+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleStatementNonTransactional, &NonTransactionalAdvisor{})+}++// NonTransactionalAdvisor is the advisor checking for non-transactional statements.+type NonTransactionalAdvisor struct {+}++// Check checks for non-transactional statements.+func (*NonTransactionalAdvisor) 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 := &nonTransactionalChecker{+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},+ level: level,+ title: string(checkCtx.Rule.Type),+ statementsText: checkCtx.Statements,+ }++ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)++ return checker.adviceList, nil+}++type nonTransactionalChecker struct {+ *parser.BasePostgreSQLParserListener++ adviceList []*storepb.Advice+ level storepb.Advice_Status+ title string+ statementsText string+}++// checkStatement checks if a statement is non-transactional+func (c *nonTransactionalChecker) checkStatement(ctx antlr.ParserRuleContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ stmtText := extractStatementText(c.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())+ if pg.IsNonTransactionStatement(stmtText) {+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: advisor.StatementNonTransactional.Int32(),+ Title: c.title,+ Content: "This statement is non-transactional",+ StartPosition: &storepb.Position{+ Line: int32(ctx.GetStart().GetLine()),+ Column: 0,+ },+ })+ }+}++// EnterDropdbstmt handles DROP DATABASE+func (c *nonTransactionalChecker) EnterDropdbstmt(ctx *parser.DropdbstmtContext) {+ c.checkStatement(ctx)+}++// EnterIndexstmt handles CREATE INDEX+func (c *nonTransactionalChecker) EnterIndexstmt(ctx *parser.IndexstmtContext) {+ c.checkStatement(ctx)+}++// EnterDropstmt handles DROP INDEX (and other DROP statements)+func (c *nonTransactionalChecker) EnterDropstmt(ctx *parser.DropstmtContext) {+ c.checkStatement(ctx)+}++// EnterVacuumstmt handles VACUUM+func (c *nonTransactionalChecker) EnterVacuumstmt(ctx *parser.VacuumstmtContext) {+ c.checkStatement(ctx)+}diff --git a/backend/plugin/advisor/pgantlr/advisor_table_comment_convention.go b/backend/plugin/advisor/pgantlr/advisor_table_comment_convention.gonew file mode 100644index 0000000000..81ce756b5b--- /dev/null+++ b/backend/plugin/advisor/pgantlr/advisor_table_comment_convention.go@@ -0,0 +1,212 @@+package pgantlr++import (+ "context"+ "fmt"++ "github.com/antlr4-go/antlr/v4"++ 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"+ pgparser "github.com/bytebase/bytebase/backend/plugin/parser/pg"+)++var (+ _ advisor.Advisor = (*TableCommentConventionAdvisor)(nil)+)++func init() {+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleTableCommentConvention, &TableCommentConventionAdvisor{})+}++// TableCommentConventionAdvisor is the advisor checking for table comment convention.+type TableCommentConventionAdvisor struct {+}++func (*TableCommentConventionAdvisor) 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.UnmarshalCommentConventionRulePayload(checkCtx.Rule.Payload)+ if err != nil {+ return nil, err+ }++ checker := &tableCommentConventionChecker{+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},+ level: level,+ title: string(checkCtx.Rule.Type),+ payload: payload,+ classificationConfig: checkCtx.ClassificationConfig,+ statementsText: checkCtx.Statements,+ createdTables: make(map[string]*tableInfo),+ tableComments: make(map[string]*tableCommentInfo),+ }++ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)++ // Check each created table for comment requirements+ for tableKey, tableInfo := range checker.createdTables {+ tableCommentInfo, hasComment := checker.tableComments[tableKey]++ if !hasComment || tableCommentInfo.comment == "" {+ if checker.payload.Required {+ checker.adviceList = append(checker.adviceList, &storepb.Advice{+ Status: checker.level,+ Code: advisor.CommentEmpty.Int32(),+ Title: checker.title,+ Content: fmt.Sprintf("Comment is required for table `%s`", tableInfo.displayName),+ StartPosition: &storepb.Position{+ Line: int32(tableInfo.line),+ Column: 0,+ },+ })+ }+ } else {+ comment := tableCommentInfo.comment+ if checker.payload.MaxLength > 0 && len(comment) > checker.payload.MaxLength {+ checker.adviceList = append(checker.adviceList, &storepb.Advice{+ Status: checker.level,+ Code: advisor.CommentTooLong.Int32(),+ Title: checker.title,+ Content: fmt.Sprintf("Table `%s` comment is too long. The length of comment should be within %d characters", tableInfo.displayName, checker.payload.MaxLength),+ StartPosition: &storepb.Position{+ Line: int32(tableCommentInfo.line),+ Column: 0,+ },+ })+ }+ if checker.payload.RequiredClassification {+ if classification, _ := common.GetClassificationAndUserComment(comment, checker.classificationConfig); classification == "" {+ checker.adviceList = append(checker.adviceList, &storepb.Advice{+ Status: checker.level,+ Code: advisor.CommentMissingClassification.Int32(),+ Title: checker.title,+ Content: fmt.Sprintf("Table `%s` comment requires classification", tableInfo.displayName),+ StartPosition: &storepb.Position{+ Line: int32(tableCommentInfo.line),+ Column: 0,+ },+ })+ }+ }+ }+ }++ return checker.adviceList, nil+}++type tableInfo struct {+ schema string+ tableName string+ displayName string+ line int+}++type tableCommentInfo struct {+ comment string+ line int+}++type tableCommentConventionChecker struct {+ *parser.BasePostgreSQLParserListener++ adviceList []*storepb.Advice+ level storepb.Advice_Status+ title string+ payload *advisor.CommentConventionRulePayload+ classificationConfig *storepb.DataClassificationSetting_DataClassificationConfig+ statementsText string++ createdTables map[string]*tableInfo+ tableComments map[string]*tableCommentInfo+}++// EnterCreatestmt collects CREATE TABLE statements+func (c *tableCommentConventionChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ var tableName, schemaName string+ allQualifiedNames := ctx.AllQualified_name()+ if len(allQualifiedNames) > 0 {+ tableName = extractTableName(allQualifiedNames[0])+ schemaName = extractSchemaName(allQualifiedNames[0])+ if schemaName == "" {+ schemaName = "public"+ }+ }++ tableKey := fmt.Sprintf("%s.%s", schemaName, tableName)+ // Only include schema in display name if it's not the default "public" schema+ displayName := tableName+ if schemaName != "public" {+ displayName = fmt.Sprintf("%s.%s", schemaName, tableName)+ }++ c.createdTables[tableKey] = &tableInfo{+ schema: schemaName,+ tableName: tableName,+ displayName: displayName,+ line: ctx.GetStart().GetLine(),+ }+}++// EnterCommentstmt collects COMMENT ON TABLE statements+func (c *tableCommentConventionChecker) EnterCommentstmt(ctx *parser.CommentstmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ // Check if this is COMMENT ON TABLE+ if ctx.Object_type_any_name() == nil || ctx.Object_type_any_name().TABLE() == nil {+ return+ }++ // Extract table name from Any_name+ if ctx.Any_name() == nil {+ return+ }++ parts := pgparser.NormalizePostgreSQLAnyName(ctx.Any_name())+ if len(parts) == 0 {+ return+ }++ var schemaName, tableName string+ if len(parts) == 1 {+ schemaName = "public"+ tableName = parts[0]+ } else {+ schemaName = parts[0]+ tableName = parts[1]+ }++ tableKey := fmt.Sprintf("%s.%s", schemaName, tableName)++ // Extract comment text+ comment := ""+ if ctx.Comment_text() != nil && ctx.Comment_text().Sconst() != nil {+ commentText := ctx.Comment_text().Sconst().GetText()+ // Remove surrounding quotes+ if len(commentText) >= 2 {+ comment = commentText[1 : len(commentText)-1]+ }+ }++ c.tableComments[tableKey] = &tableCommentInfo{+ comment: comment,+ line: ctx.GetStart().GetLine(),+ }+}diff --git a/backend/plugin/advisor/pgantlr/advisor_table_disallow_partition.go b/backend/plugin/advisor/pgantlr/advisor_table_disallow_partition.gonew file mode 100644index 0000000000..144237dbe7--- /dev/null+++ b/backend/plugin/advisor/pgantlr/advisor_table_disallow_partition.go@@ -0,0 +1,111 @@+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 = (*TableDisallowPartitionAdvisor)(nil)+)++func init() {+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleTableDisallowPartition, &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) {+ tree, err := getANTLRTree(checkCtx)+ if err != nil {+ return nil, err+ }++ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)+ if err != nil {+ return nil, err+ }++ checker := &tableDisallowPartitionChecker{+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},+ level: level,+ title: string(checkCtx.Rule.Type),+ statementsText: checkCtx.Statements,+ }++ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)++ return checker.adviceList, nil+}++type tableDisallowPartitionChecker struct {+ *parser.BasePostgreSQLParserListener++ adviceList []*storepb.Advice+ level storepb.Advice_Status+ title string+ statementsText string+}++// EnterCreatestmt handles CREATE TABLE statements+func (c *tableDisallowPartitionChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ // Check if this CREATE TABLE has a PARTITION BY clause+ if ctx.Optpartitionspec() != nil && ctx.Optpartitionspec().Partitionspec() != nil {+ stmtText := extractStatementText(c.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: advisor.CreateTablePartition.Int32(),+ Title: c.title,+ Content: fmt.Sprintf("Table partition is forbidden, but \"%s\" creates", stmtText),+ StartPosition: &storepb.Position{+ Line: int32(ctx.GetStart().GetLine()),+ Column: 0,+ },+ })+ }+}++// EnterPartition_cmd handles ALTER TABLE ... ATTACH PARTITION+func (c *tableDisallowPartitionChecker) EnterPartition_cmd(ctx *parser.Partition_cmdContext) {+ if !isTopLevel(ctx.GetParent().GetParent().GetParent()) {+ // Partition_cmd is nested: Altertablestmt -> Alter_table_cmds -> Alter_table_cmd -> Partition_cmd+ return+ }++ // Check for ATTACH PARTITION+ if ctx.ATTACH() != nil && ctx.PARTITION() != nil {+ // Navigate up to get the Altertablestmt context for statement text+ parent := ctx.GetParent()+ for parent != nil {+ if alterTableCtx, ok := parent.(*parser.AltertablestmtContext); ok {+ stmtText := extractStatementText(c.statementsText, alterTableCtx.GetStart().GetLine(), alterTableCtx.GetStop().GetLine())+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: advisor.CreateTablePartition.Int32(),+ Title: c.title,+ Content: fmt.Sprintf("Table partition is forbidden, but \"%s\" creates", stmtText),+ StartPosition: &storepb.Position{+ Line: int32(alterTableCtx.GetStart().GetLine()),+ Column: 0,+ },+ })+ break+ }+ parent = parent.GetParent()+ }+ }+}diff --git a/backend/plugin/advisor/pgantlr/advisor_table_drop_naming_convention.go b/backend/plugin/advisor/pgantlr/advisor_table_drop_naming_convention.gonew file mode 100644index 0000000000..c7f06b755e--- /dev/null+++ b/backend/plugin/advisor/pgantlr/advisor_table_drop_naming_convention.go@@ -0,0 +1,107 @@+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 = (*TableDropNamingConventionAdvisor)(nil)+)++func init() {+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleTableDropNamingConvention, &TableDropNamingConventionAdvisor{})+}++// TableDropNamingConventionAdvisor is the advisor checking for table drop with naming convention.+type TableDropNamingConventionAdvisor struct {+}++// Check checks for table drop with naming convention.+func (*TableDropNamingConventionAdvisor) 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, _, err := advisor.UnmarshalNamingRulePayloadAsRegexp(checkCtx.Rule.Payload)+ if err != nil {+ return nil, err+ }++ checker := &tableDropNamingConventionChecker{+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},+ level: level,+ title: string(checkCtx.Rule.Type),+ format: format,+ }++ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)++ return checker.adviceList, nil+}++type tableDropNamingConventionChecker struct {+ *parser.BasePostgreSQLParserListener++ adviceList []*storepb.Advice+ level storepb.Advice_Status+ title string+ format *regexp.Regexp+}++// EnterDropstmt handles DROP TABLE statements+func (c *tableDropNamingConventionChecker) EnterDropstmt(ctx *parser.DropstmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ // Check if this is a DROP TABLE statement+ if ctx.Object_type_any_name() == nil || ctx.Object_type_any_name().TABLE() == nil {+ return+ }++ // Check all tables being dropped+ if ctx.Any_name_list() != nil {+ allNames := ctx.Any_name_list().AllAny_name()+ for _, nameCtx := range allNames {+ tableName := c.extractTableNameFromAnyName(nameCtx)+ if tableName != "" && !c.format.MatchString(tableName) {+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: advisor.TableDropNamingConventionMismatch.Int32(),+ Title: c.title,+ Content: fmt.Sprintf("`%s` mismatches drop table naming convention, naming format should be %q", tableName, c.format),+ StartPosition: &storepb.Position{+ Line: int32(ctx.GetStart().GetLine()),+ Column: 0,+ },+ })+ }+ }+ }+}++// extractTableNameFromAnyName extracts the table name from Any_name context.+// For schema.table, returns "table". For just "table", returns "table".+func (*tableDropNamingConventionChecker) extractTableNameFromAnyName(ctx parser.IAny_nameContext) string {+ parts := pg.NormalizePostgreSQLAnyName(ctx)+ if len(parts) == 0 {+ return ""+ }+ return parts[len(parts)-1]+}diff --git a/backend/plugin/advisor/pgantlr/advisor_table_no_fk.go b/backend/plugin/advisor/pgantlr/advisor_table_no_fk.gonew file mode 100644index 0000000000..e073821723--- /dev/null+++ b/backend/plugin/advisor/pgantlr/advisor_table_no_fk.go@@ -0,0 +1,160 @@+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 = (*TableNoFKAdvisor)(nil)+)++func init() {+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleTableNoFK, &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) {+ tree, err := getANTLRTree(checkCtx)+ if err != nil {+ return nil, err+ }++ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)+ if err != nil {+ return nil, err+ }++ checker := &tableNoFKChecker{+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},+ level: level,+ title: string(checkCtx.Rule.Type),+ statementsText: checkCtx.Statements,+ }++ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)++ return checker.adviceList, nil+}++type tableNoFKChecker struct {+ *parser.BasePostgreSQLParserListener++ adviceList []*storepb.Advice+ level storepb.Advice_Status+ title string+ statementsText string+}++// EnterCreatestmt handles CREATE TABLE with FK constraints+func (c *tableNoFKChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ var tableName, schemaName string+ allQualifiedNames := ctx.AllQualified_name()+ if len(allQualifiedNames) > 0 {+ tableName = extractTableName(allQualifiedNames[0])+ schemaName = extractSchemaName(allQualifiedNames[0])+ if schemaName == "" {+ schemaName = "public"+ }+ }++ // Check table-level constraints+ if ctx.Opttableelementlist() != nil && ctx.Opttableelementlist().Tableelementlist() != nil {+ allElements := ctx.Opttableelementlist().Tableelementlist().AllTableelement()+ for _, elem := range allElements {+ // Check if this is a table constraint+ if elem.Tableconstraint() != nil {+ constraint := elem.Tableconstraint()+ if constraint.Constraintelem() != nil {+ constraintElem := constraint.Constraintelem()+ // Check for FOREIGN KEY+ if constraintElem.FOREIGN() != nil && constraintElem.KEY() != nil {+ c.addFKAdvice(schemaName, tableName, ctx)+ return+ }+ }+ }++ // Check column-level constraints+ if elem.ColumnDef() != nil {+ columnDef := elem.ColumnDef()+ if columnDef.Colquallist() != nil {+ allQuals := columnDef.Colquallist().AllColconstraint()+ for _, qual := range allQuals {+ if qual.Colconstraintelem() != nil {+ constraintElem := qual.Colconstraintelem()+ // Check for REFERENCES (column-level FK)+ if constraintElem.REFERENCES() != nil {+ c.addFKAdvice(schemaName, tableName, ctx)+ return+ }+ }+ }+ }+ }+ }+ }+}++// EnterAltertablestmt handles ALTER TABLE ADD CONSTRAINT with FK+func (c *tableNoFKChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ var tableName, schemaName string+ if ctx.Relation_expr() != nil && ctx.Relation_expr().Qualified_name() != nil {+ tableName = extractTableName(ctx.Relation_expr().Qualified_name())+ schemaName = extractSchemaName(ctx.Relation_expr().Qualified_name())+ if schemaName == "" {+ schemaName = "public"+ }+ }++ // Check all alter table commands for ADD CONSTRAINT with FOREIGN KEY+ if ctx.Alter_table_cmds() != nil {+ allCmds := ctx.Alter_table_cmds().AllAlter_table_cmd()+ for _, cmd := range allCmds {+ if cmd.ADD_P() != nil && cmd.Tableconstraint() != nil {+ constraint := cmd.Tableconstraint()+ if constraint.Constraintelem() != nil {+ constraintElem := constraint.Constraintelem()+ // Check for FOREIGN KEY+ if constraintElem.FOREIGN() != nil && constraintElem.KEY() != nil {+ c.addFKAdvice(schemaName, tableName, ctx)+ return+ }+ }+ }+ }+ }+}++func (c *tableNoFKChecker) addFKAdvice(schemaName, tableName string, ctx antlr.ParserRuleContext) {+ stmtText := extractStatementText(c.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: advisor.TableHasFK.Int32(),+ Title: c.title,+ Content: fmt.Sprintf("Foreign key is not allowed in the table %q.%q, related statement: \"%s\"", schemaName, tableName, stmtText),+ StartPosition: &storepb.Position{+ Line: int32(ctx.GetStart().GetLine()),+ Column: 0,+ },+ })+}diff --git a/backend/plugin/advisor/pgantlr/advisor_table_require_pk.go b/backend/plugin/advisor/pgantlr/advisor_table_require_pk.gonew file mode 100644index 0000000000..35df704bfa--- /dev/null+++ b/backend/plugin/advisor/pgantlr/advisor_table_require_pk.go@@ -0,0 +1,204 @@+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"+ "github.com/bytebase/bytebase/backend/plugin/advisor/catalog"+ pgparser "github.com/bytebase/bytebase/backend/plugin/parser/pg"+)++var (+ _ advisor.Advisor = (*TableRequirePKAdvisor)(nil)+)++func init() {+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleTableRequirePK, &TableRequirePKAdvisor{})+}++// TableRequirePKAdvisor is the advisor checking table requires PK.+type TableRequirePKAdvisor struct {+}++// Check parses the given statement and checks for errors.+func (*TableRequirePKAdvisor) 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 := &tableRequirePKChecker{+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},+ level: level,+ title: string(checkCtx.Rule.Type),+ statementsText: checkCtx.Statements,+ catalog: checkCtx.Catalog,+ }++ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)++ return checker.adviceList, nil+}++type tableRequirePKChecker struct {+ *parser.BasePostgreSQLParserListener++ adviceList []*storepb.Advice+ level storepb.Advice_Status+ title string+ statementsText string+ catalog *catalog.Finder+}++// EnterCreatestmt handles CREATE TABLE - must have PK+func (c *tableRequirePKChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ var tableName, schemaName string+ allQualifiedNames := ctx.AllQualified_name()+ if len(allQualifiedNames) > 0 {+ tableName = extractTableName(allQualifiedNames[0])+ schemaName = extractSchemaName(allQualifiedNames[0])+ if schemaName == "" {+ schemaName = "public"+ }+ }++ hasPK := false++ // Check table-level constraints+ if ctx.Opttableelementlist() != nil && ctx.Opttableelementlist().Tableelementlist() != nil {+ allElements := ctx.Opttableelementlist().Tableelementlist().AllTableelement()+ for _, elem := range allElements {+ // Check if this is a table constraint with PRIMARY KEY+ if elem.Tableconstraint() != nil {+ constraint := elem.Tableconstraint()+ if constraint.Constraintelem() != nil {+ constraintElem := constraint.Constraintelem()+ // Check for PRIMARY KEY or PRIMARY KEY USING INDEX+ if constraintElem.PRIMARY() != nil && constraintElem.KEY() != nil {+ hasPK = true+ break+ }+ }+ }++ // Check column-level constraints+ if elem.ColumnDef() != nil {+ columnDef := elem.ColumnDef()+ if columnDef.Colquallist() != nil {+ allQuals := columnDef.Colquallist().AllColconstraint()+ for _, qual := range allQuals {+ if qual.Colconstraintelem() != nil {+ constraintElem := qual.Colconstraintelem()+ // Check for PRIMARY KEY+ if constraintElem.PRIMARY() != nil && constraintElem.KEY() != nil {+ hasPK = true+ break+ }+ }+ }+ if hasPK {+ break+ }+ }+ }+ }+ }++ if !hasPK {+ c.addMissingPKAdvice(schemaName, tableName, ctx)+ }+}++// EnterAltertablestmt handles ALTER TABLE DROP CONSTRAINT / DROP COLUMN+func (c *tableRequirePKChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ var tableName, schemaName string+ if ctx.Relation_expr() != nil && ctx.Relation_expr().Qualified_name() != nil {+ tableName = extractTableName(ctx.Relation_expr().Qualified_name())+ schemaName = extractSchemaName(ctx.Relation_expr().Qualified_name())+ if schemaName == "" {+ schemaName = "public"+ }+ }++ // Check all alter table commands+ if ctx.Alter_table_cmds() != nil {+ allCmds := ctx.Alter_table_cmds().AllAlter_table_cmd()+ for _, cmd := range allCmds {+ // DROP CONSTRAINT+ if cmd.DROP() != nil && cmd.CONSTRAINT() != nil {+ allColIDs := cmd.AllColid()+ if len(allColIDs) > 0 {+ constraintName := pgparser.NormalizePostgreSQLColid(allColIDs[0])+ // Check if this constraint is a primary key using catalog+ if c.catalog != nil {+ _, index := c.catalog.Origin.FindIndex(&catalog.IndexFind{+ SchemaName: schemaName,+ TableName: tableName,+ IndexName: constraintName,+ })+ if index != nil && index.Primary() {+ c.addMissingPKAdvice(schemaName, tableName, ctx)+ return+ }+ }+ }+ }++ // DROP COLUMN (check for COLUMN keyword to distinguish from DROP CONSTRAINT)+ if cmd.DROP() != nil && cmd.Opt_column() != nil {+ allColIDs := cmd.AllColid()+ if len(allColIDs) > 0 && cmd.CONSTRAINT() == nil {+ columnName := pgparser.NormalizePostgreSQLColid(allColIDs[0])+ // Check if this column is part of the primary key using catalog+ if c.catalog != nil {+ pk := c.catalog.Origin.FindPrimaryKey(&catalog.PrimaryKeyFind{+ SchemaName: schemaName,+ TableName: tableName,+ })+ if pk != nil {+ for _, column := range pk.ExpressionList() {+ if column == columnName {+ c.addMissingPKAdvice(schemaName, tableName, ctx)+ return+ }+ }+ }+ }+ }+ }+ }+ }+}++func (c *tableRequirePKChecker) addMissingPKAdvice(schemaName, tableName string, ctx antlr.ParserRuleContext) {+ stmtText := extractStatementText(c.statementsText, ctx.GetStart().GetLine(), ctx.GetStop().GetLine())+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: advisor.TableNoPK.Int32(),+ Title: c.title,+ Content: fmt.Sprintf("Table %q.%q requires PRIMARY KEY, related statement: %q", schemaName, tableName, stmtText),+ StartPosition: &storepb.Position{+ Line: int32(ctx.GetStart().GetLine()),+ Column: 0,+ },+ })+}diff --git a/backend/plugin/advisor/pgantlr/pgantlr_test.go b/backend/plugin/advisor/pgantlr/pgantlr_test.goindex 86458d8e14..31bcc15c7c 100644--- a/backend/plugin/advisor/pgantlr/pgantlr_test.go+++ b/backend/plugin/advisor/pgantlr/pgantlr_test.go@@ -9,28 +9,44 @@ 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.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+ 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+ advisor.SchemaRuleSchemaBackwardCompatibility, // Migrated from legacy+ advisor.SchemaRuleStatementAddFKNotValid, // Migrated from legacy+ advisor.SchemaRuleStatementDisallowCommit, // Migrated from legacy+ advisor.SchemaRuleStatementNonTransactional, // Migrated from legacy+ advisor.SchemaRuleTableDropNamingConvention, // Migrated from legacy+ advisor.SchemaRuleTableDisallowPartition, // Migrated from legacy+ advisor.SchemaRuleTableNoFK, // Migrated from legacy+ advisor.SchemaRuleTableNaming, // Migrated from legacy+ advisor.SchemaRuleTableCommentConvention, // Migrated from legacy+ advisor.SchemaRuleStatementCreateSpecifySchema, // Migrated from legacy+ advisor.SchemaRuleStatementAddCheckNotValid, // Migrated from legacy+ advisor.SchemaRuleStatementAffectedRowLimit, // Migrated from legacy+ advisor.SchemaRuleStatementDisallowAddColumnWithDefault, // Migrated from legacy+ advisor.SchemaRuleStatementDisallowAddNotNull, // Migrated from legacy+ advisor.SchemaRuleStatementDisallowMixInDDL, // Migrated from legacy+ // advisor.SchemaRuleTableRequirePK, // WIP - needs debugging// Add real rules here as you migrate them from legacy pg/ folder// Example:// advisor.SchemaRuleStatementDisallowCommit,@@ -51,5 +67,6 @@ var advisorNeedMockData = map[advisor.SQLReviewRuleType]bool{advisor.BuiltinRulePriorBackupCheck: true,advisor.SchemaRuleColumnNotNull: true, // Needs metadata for PRIMARY KEY USING INDEX caseadvisor.SchemaRuleIndexTotalNumberLimit: true, // Needs catalog to count indexes+ advisor.SchemaRuleTableRequirePK: true, // Needs catalog for DROP CONSTRAINT/COLUMN checks// Other advisors don't need mock data}diff --git a/backend/plugin/advisor/pgantlr/test/naming_table.yaml b/backend/plugin/advisor/pgantlr/test/naming_table.yamlnew file mode 100644index 0000000000..05d68fb8ac--- /dev/null+++ b/backend/plugin/advisor/pgantlr/test/naming_table.yaml@@ -0,0 +1,64 @@+- statement: CREATE TABLE "techBook"(id int, name varchar(255))+ changeType: 1+ 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 "rlcmidzlevbivwvcntihenpoibtiutqeb"(id int, name varchar(255))+ changeType: 1+- statement: CREATE TABLE _techBook(id int, name varchar(255))+ changeType: 1+ 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 techBook(id int, name varchar(255))+ changeType: 1+- statement: CREATE TABLE book(id int, name varchar(255))+ changeType: 1+- statement: ALTER TABLE tech_book RENAME TO "TechBook"+ changeType: 1+ 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 techBook(id int);+ ALTER TABLE techBook RENAME TO tech_book_tmp;+ changeType: 1+- statement: |-+ CREATE TABLE _techBook(id int, name varchar(255));+ ALTER TABLE tech_book RENAME TO "TechBook";+ changeType: 1+ 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+ - 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: nulldiff --git a/backend/plugin/advisor/pgantlr/test/schema_backward_compatibility.yaml b/backend/plugin/advisor/pgantlr/test/schema_backward_compatibility.yamlnew file mode 100644index 0000000000..5634d89b14--- /dev/null+++ b/backend/plugin/advisor/pgantlr/test/schema_backward_compatibility.yaml@@ -0,0 +1,11 @@+- statement: ALTER TABLE tech_book ALTER COLUMN name TYPE TEXT+ changeType: 1+ want:+ - status: 2+ code: 111+ title: schema.backward-compatibility+ content: '"ALTER TABLE tech_book ALTER COLUMN name TYPE TEXT" may cause incompatibility with the existing data and code'+ startposition:+ line: 1+ column: 0+ endposition: nulldiff --git a/backend/plugin/advisor/pgantlr/test/statement_add_check_not_valid.yaml b/backend/plugin/advisor/pgantlr/test/statement_add_check_not_valid.yamlnew file mode 100644index 0000000000..db79c3a467--- /dev/null+++ b/backend/plugin/advisor/pgantlr/test/statement_add_check_not_valid.yaml@@ -0,0 +1,13 @@+- statement: alter table tech_book add constraint check_id check(id > 0);+ changeType: 1+ want:+ - status: 2+ code: 211+ title: statement.add-check-not-valid+ content: Adding check constraints with validation will block reads and writes. You can add check constraints not valid and then validate separately+ startposition:+ line: 1+ column: 0+ endposition: null+- statement: alter table tech_book add constraint check_id check(id > 0) NOT VALID;+ changeType: 1diff --git a/backend/plugin/advisor/pgantlr/test/statement_add_foreign_key_not_valid.yaml b/backend/plugin/advisor/pgantlr/test/statement_add_foreign_key_not_valid.yamlnew file mode 100644index 0000000000..9fe5e326c4--- /dev/null+++ b/backend/plugin/advisor/pgantlr/test/statement_add_foreign_key_not_valid.yaml@@ -0,0 +1,37 @@+- statement: |-+ CREATE TABLE task (+ id SERIAL PRIMARY KEY,+ row_status row_status NOT NULL DEFAULT 'NORMAL',+ name TEXT NOT NULL+ );+ CREATE TABLE task_run (+ id SERIAL PRIMARY KEY,+ task_id INTEGER NOT NULL,+ name TEXT NOT NULL,+ result JSONB NOT NULL DEFAULT '{}'+ );+ ALTER TABLE task_run ADD CONSTRAINT task_run_task_id_fk_task_id FOREIGN KEY (task_id) REFERENCES task (id);+ changeType: 1+ want:+ - status: 2+ code: 229+ title: statement.add-foreign-key-not-valid+ content: Adding foreign keys with validation will block reads and writes. You can add check foreign keys not valid and then validate separately+ startposition:+ line: 12+ column: 0+ endposition: null+- statement: |-+ CREATE TABLE task (+ id SERIAL PRIMARY KEY,+ row_status row_status NOT NULL DEFAULT 'NORMAL',+ name TEXT NOT NULL+ );+ CREATE TABLE task_run (+ id SERIAL PRIMARY KEY,+ task_id INTEGER NOT NULL,+ name TEXT NOT NULL,+ result JSONB NOT NULL DEFAULT '{}'+ );+ ALTER TABLE task_run ADD CONSTRAINT task_run_task_id_fk_task_id FOREIGN KEY (task_id) REFERENCES task (id) NOT VALID;+ changeType: 1diff --git a/backend/plugin/advisor/pgantlr/test/statement_affected_row_limit.yaml b/backend/plugin/advisor/pgantlr/test/statement_affected_row_limit.yamlnew file mode 100644index 0000000000..1adfbe25f1--- /dev/null+++ b/backend/plugin/advisor/pgantlr/test/statement_affected_row_limit.yaml@@ -0,0 +1,4 @@+- statement: DELETE FROM tech_book WHERE a > 1+ changeType: 1+- statement: UPDATE tech_book SET id = 1+ changeType: 1diff --git a/backend/plugin/advisor/pgantlr/test/statement_create_specify_schema.yaml b/backend/plugin/advisor/pgantlr/test/statement_create_specify_schema.yamlnew file mode 100644index 0000000000..0e2c765b41--- /dev/null+++ b/backend/plugin/advisor/pgantlr/test/statement_create_specify_schema.yaml@@ -0,0 +1,13 @@+- statement: CREATE TABLE t(id int);+ changeType: 1+ want:+ - status: 2+ code: 216+ title: statement.create-specify-schema+ content: Table schema should be specified.+ startposition:+ line: 1+ column: 0+ endposition: null+- statement: CREATE TABLE public.t(id int);+ changeType: 1diff --git a/backend/plugin/advisor/pgantlr/test/statement_disallow_add_column_with_default.yaml b/backend/plugin/advisor/pgantlr/test/statement_disallow_add_column_with_default.yamlnew file mode 100644index 0000000000..758055fbf9--- /dev/null+++ b/backend/plugin/advisor/pgantlr/test/statement_disallow_add_column_with_default.yaml@@ -0,0 +1,13 @@+- statement: ALTER TABLE tech_book ADD COLUMN c int;+ changeType: 1+- statement: ALTER TABLE tech_book ADD COLUMN c int DEFAULT 0;+ changeType: 1+ want:+ - status: 2+ code: 210+ title: statement.disallow-add-column-with-default+ content: Adding column with DEFAULT will locked the whole table and rewriting each rows+ startposition:+ line: 1+ column: 0+ endposition: nulldiff --git a/backend/plugin/advisor/pgantlr/test/statement_disallow_add_not_null.yaml b/backend/plugin/advisor/pgantlr/test/statement_disallow_add_not_null.yamlnew file mode 100644index 0000000000..516692b1c8--- /dev/null+++ b/backend/plugin/advisor/pgantlr/test/statement_disallow_add_not_null.yaml@@ -0,0 +1,15 @@+- statement: alter table tech_book alter column name set not null;+ changeType: 1+ want:+ - status: 2+ code: 212+ title: statement.disallow-add-not-null+ content: Setting NOT NULL will block reads and writes. You can use CHECK ("name" IS NOT NULL) instead+ startposition:+ line: 1+ column: 0+ endposition: null+- statement: |-+ alter table tech_book add constraint check_name_not_null check(name IS NOT NULL) NOT VALID;+ alter table tech_book validate constraint check_name_not_null;+ changeType: 1diff --git a/backend/plugin/advisor/pgantlr/test/statement_disallow_commit.yaml b/backend/plugin/advisor/pgantlr/test/statement_disallow_commit.yamlnew file mode 100644index 0000000000..58b8b737c7--- /dev/null+++ b/backend/plugin/advisor/pgantlr/test/statement_disallow_commit.yaml@@ -0,0 +1,40 @@+- statement: |-+ START TRANSACTION;+ CREATE TABLE techBook(id int, name varchar(255));+ COMMIT;+ changeType: 1+ 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;+ changeType: 1+ 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: nulldiff --git a/backend/plugin/advisor/pgantlr/test/statement_disallow_mix_in_ddl.yaml b/backend/plugin/advisor/pgantlr/test/statement_disallow_mix_in_ddl.yamlnew file mode 100644index 0000000000..70e3e82b33--- /dev/null+++ b/backend/plugin/advisor/pgantlr/test/statement_disallow_mix_in_ddl.yaml@@ -0,0 +1,41 @@+- statement: DELETE FROM tech_book WHERE a > 1;+ changeType: 1+ want:+ - status: 2+ code: 227+ title: statement.disallow-mix-in-ddl+ content: Alter schema can only run DDL, "DELETE FROM tech_book WHERE a > 1;" is not DDL+ startposition:+ line: 1+ column: 0+ endposition: null+- statement: UPDATE tech_book SET id = 1;+ changeType: 1+ want:+ - status: 2+ code: 227+ title: statement.disallow-mix-in-ddl+ content: Alter schema can only run DDL, "UPDATE tech_book SET id = 1;" is not DDL+ startposition:+ line: 1+ column: 0+ endposition: null+- statement: ALTER TABLE tech_book ADD COLUMN author TEXT; UPDATE tech_book SET id = 1;DELETE FROM tech_book WHERE a > 1;+ changeType: 1+ want:+ - status: 2+ code: 227+ title: statement.disallow-mix-in-ddl+ content: Alter schema can only run DDL, "DELETE FROM tech_book WHERE a > 1;" is not DDL+ startposition:+ line: 1+ column: 0+ endposition: null+ - status: 2+ code: 227+ title: statement.disallow-mix-in-ddl+ content: Alter schema can only run DDL, "UPDATE tech_book SET id = 1;" is not DDL+ startposition:+ line: 1+ column: 0+ endposition: nulldiff --git a/backend/plugin/advisor/pgantlr/test/statement_non_transactional.yaml b/backend/plugin/advisor/pgantlr/test/statement_non_transactional.yamlnew file mode 100644index 0000000000..992f3c9fe3--- /dev/null+++ b/backend/plugin/advisor/pgantlr/test/statement_non_transactional.yaml@@ -0,0 +1,24 @@+- statement: CREATE INDEX idx_tech_book_id_name ON tech_book(id, name)+ changeType: 1+- statement: CREATE INDEX CONCURRENTLY tech_book_id_name ON tech_book(id, name)+ changeType: 1+ want:+ - status: 2+ code: 230+ title: statement.non-transactional+ content: This statement is non-transactional+ startposition:+ line: 1+ column: 0+ endposition: null+- statement: VACUUM FULL tech_book+ changeType: 1+ want:+ - status: 2+ code: 230+ title: statement.non-transactional+ content: This statement is non-transactional+ startposition:+ line: 1+ column: 0+ endposition: nulldiff --git a/backend/plugin/advisor/pgantlr/test/table_comment.yaml b/backend/plugin/advisor/pgantlr/test/table_comment.yamlnew file mode 100644index 0000000000..261c7e3a64--- /dev/null+++ b/backend/plugin/advisor/pgantlr/test/table_comment.yaml@@ -0,0 +1,70 @@+- statement: |-+ CREATE TABLE t(a int);+ COMMENT ON TABLE t IS 'comments';+ changeType: 1+- statement: CREATE TABLE t(a int);+ changeType: 1+ want:+ - status: 2+ code: 1032+ title: table.comment+ content: Comment is required for table `t`+ startposition:+ line: 1+ column: 0+ endposition: null+- statement: |-+ CREATE TABLE t(a int);+ CREATE TABLE d(a int);+ COMMENT ON TABLE t IS 'comments';+ changeType: 1+ want:+ - status: 2+ code: 1032+ title: table.comment+ content: Comment is required for table `d`+ startposition:+ line: 2+ column: 0+ endposition: null+- statement: |-+ CREATE TABLE t(a int);+ COMMENT ON TABLE t IS 'comments';+ COMMENT ON TABLE t IS '';+ changeType: 1+ want:+ - status: 2+ code: 1032+ title: table.comment+ content: Comment is required for table `t`+ startposition:+ line: 1+ column: 0+ endposition: null+- statement: |-+ CREATE TABLE t(a int);+ COMMENT ON TABLE t IS 'comments';+ COMMENT ON TABLE t IS NULL;+ changeType: 1+ want:+ - status: 2+ code: 1032+ title: table.comment+ content: Comment is required for table `t`+ startposition:+ line: 1+ column: 0+ endposition: null+- statement: |-+ CREATE TABLE t(a int);+ COMMENT ON TABLE t IS 'looooooong comments';+ changeType: 1+ want:+ - status: 2+ code: 1301+ title: table.comment+ content: Table `t` comment is too long. The length of comment should be within 10 characters+ startposition:+ line: 2+ column: 0+ endposition: nulldiff --git a/backend/plugin/advisor/pgantlr/test/table_disallow_partition.yaml b/backend/plugin/advisor/pgantlr/test/table_disallow_partition.yamlnew file mode 100644index 0000000000..fe50b1ebe2--- /dev/null+++ b/backend/plugin/advisor/pgantlr/test/table_disallow_partition.yaml@@ -0,0 +1,24 @@+- statement: CREATE TABLE t(a int)+ changeType: 1+- statement: CREATE TABLE t(a int) PARTITION BY RANGE (a);+ changeType: 1+ want:+ - status: 2+ code: 608+ title: table.disallow-partition+ content: Table partition is forbidden, but "CREATE TABLE t(a int) PARTITION BY RANGE (a);" creates+ startposition:+ line: 1+ column: 0+ endposition: null+- statement: ALTER TABLE tech_book ATTACH PARTITION p1 DEFAULT;+ changeType: 1+ want:+ - status: 2+ code: 608+ title: table.disallow-partition+ content: Table partition is forbidden, but "ALTER TABLE tech_book ATTACH PARTITION p1 DEFAULT;" creates+ startposition:+ line: 1+ column: 0+ endposition: nulldiff --git a/backend/plugin/advisor/pgantlr/test/table_drop_naming_convention.yaml b/backend/plugin/advisor/pgantlr/test/table_drop_naming_convention.yamlnew file mode 100644index 0000000000..7dd7f76328--- /dev/null+++ b/backend/plugin/advisor/pgantlr/test/table_drop_naming_convention.yaml@@ -0,0 +1,24 @@+- statement: DROP TABLE IF EXISTS foo_delete+ changeType: 1+- statement: DROP TABLE IF EXISTS foo+ changeType: 1+ want:+ - status: 2+ code: 603+ title: table.drop-naming-convention+ content: '`foo` mismatches drop table naming convention, naming format should be "_delete$"'+ startposition:+ line: 1+ column: 0+ endposition: null+- statement: DROP TABLE IF EXISTS foo_delete, bar+ changeType: 1+ want:+ - status: 2+ code: 603+ title: table.drop-naming-convention+ content: '`bar` mismatches drop table naming convention, naming format should be "_delete$"'+ startposition:+ line: 1+ column: 0+ endposition: nulldiff --git a/backend/plugin/advisor/pgantlr/test/table_no_foreign_key.yaml b/backend/plugin/advisor/pgantlr/test/table_no_foreign_key.yamlnew file mode 100644index 0000000000..acf0effa26--- /dev/null+++ b/backend/plugin/advisor/pgantlr/test/table_no_foreign_key.yaml@@ -0,0 +1,22 @@+- statement: ALTER TABLE tech_book ADD CONSTRAINT fk_tech_book_author_id_author_id FOREIGN KEY (author_id) REFERENCES author (id)+ changeType: 1+ want:+ - status: 2+ code: 602+ title: table.no-foreign-key+ content: 'Foreign key is not allowed in the table "public"."tech_book", related statement: "ALTER TABLE tech_book ADD CONSTRAINT fk_tech_book_author_id_author_id FOREIGN KEY (author_id) REFERENCES author (id)"'+ startposition:+ line: 1+ column: 0+ endposition: null+- statement: CREATE TABLE book(id INT, author_id INT, CONSTRAINT fk_book_author_id_author_id FOREIGN KEY (author_id) REFERENCES author (id))+ changeType: 1+ want:+ - status: 2+ code: 602+ title: table.no-foreign-key+ content: 'Foreign key is not allowed in the table "public"."book", related statement: "CREATE TABLE book(id INT, author_id INT, CONSTRAINT fk_book_author_id_author_id FOREIGN KEY (author_id) REFERENCES author (id))"'+ startposition:+ line: 1+ column: 0+ endposition: nulldiff --git a/backend/plugin/advisor/pgantlr/test/table_require_pk.yaml b/backend/plugin/advisor/pgantlr/test/table_require_pk.yamlnew file mode 100644index 0000000000..0aa06e7cee--- /dev/null+++ b/backend/plugin/advisor/pgantlr/test/table_require_pk.yaml@@ -0,0 +1,45 @@+- statement: CREATE TABLE t(id INT PRIMARY KEY)+ changeType: 1+- statement: CREATE TABLE t(id INT, PRIMARY KEY (id))+ changeType: 1+- statement: CREATE TABLE t(id INT)+ changeType: 1+ want:+ - status: 2+ code: 601+ title: table.require-pk+ content: 'Table "public"."t" requires PRIMARY KEY, related statement: "CREATE TABLE t(id INT)"'+ startposition:+ line: 1+ column: 0+ endposition: null+- statement: ALTER TABLE "tech_book" DROP CONSTRAINT "old_pk"+ changeType: 1+ want:+ - status: 2+ code: 601+ title: table.require-pk+ content: 'Table "public"."tech_book" requires PRIMARY KEY, related statement: "ALTER TABLE \"tech_book\" DROP CONSTRAINT \"old_pk\""'+ startposition:+ line: 1+ column: 0+ endposition: null+- statement: ALTER TABLE "tech_book" DROP CONSTRAINT "old_index"+ changeType: 1+- statement: ALTER TABLE "tech_book" DROP CONSTRAINT constraint_not_in_catalog+ changeType: 1+- statement: ALTER TABLE "tech_book" DROP COLUMN id+ changeType: 1+ want:+ - status: 2+ code: 601+ title: table.require-pk+ content: 'Table "public"."tech_book" requires PRIMARY KEY, related statement: "ALTER TABLE \"tech_book\" DROP COLUMN id"'+ startposition:+ line: 1+ column: 0+ endposition: null+- statement: |-+ ALTER TABLE tech_book ADD COLUMN column_not_in_pk int;+ ALTER TABLE "tech_book" DROP COLUMN column_not_in_pk;+ changeType: 1