Skip to content

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

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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
index 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 case
advisor.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.yaml
new file mode 100644
index 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: null
diff --git a/backend/plugin/advisor/pgantlr/test/schema_backward_compatibility.yaml b/backend/plugin/advisor/pgantlr/test/schema_backward_compatibility.yaml
new file mode 100644
index 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: null
diff --git a/backend/plugin/advisor/pgantlr/test/statement_add_check_not_valid.yaml b/backend/plugin/advisor/pgantlr/test/statement_add_check_not_valid.yaml
new file mode 100644
index 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: 1
diff --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.yaml
new file mode 100644
index 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: 1
diff --git a/backend/plugin/advisor/pgantlr/test/statement_affected_row_limit.yaml b/backend/plugin/advisor/pgantlr/test/statement_affected_row_limit.yaml
new file mode 100644
index 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: 1
diff --git a/backend/plugin/advisor/pgantlr/test/statement_create_specify_schema.yaml b/backend/plugin/advisor/pgantlr/test/statement_create_specify_schema.yaml
new file mode 100644
index 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: 1
diff --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.yaml
new file mode 100644
index 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: null
diff --git a/backend/plugin/advisor/pgantlr/test/statement_disallow_add_not_null.yaml b/backend/plugin/advisor/pgantlr/test/statement_disallow_add_not_null.yaml
new file mode 100644
index 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: 1
diff --git a/backend/plugin/advisor/pgantlr/test/statement_disallow_commit.yaml b/backend/plugin/advisor/pgantlr/test/statement_disallow_commit.yaml
new file mode 100644
index 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: null
diff --git a/backend/plugin/advisor/pgantlr/test/statement_disallow_mix_in_ddl.yaml b/backend/plugin/advisor/pgantlr/test/statement_disallow_mix_in_ddl.yaml
new file mode 100644
index 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: null
diff --git a/backend/plugin/advisor/pgantlr/test/statement_non_transactional.yaml b/backend/plugin/advisor/pgantlr/test/statement_non_transactional.yaml
new file mode 100644
index 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: null
diff --git a/backend/plugin/advisor/pgantlr/test/table_comment.yaml b/backend/plugin/advisor/pgantlr/test/table_comment.yaml
new file mode 100644
index 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: null
diff --git a/backend/plugin/advisor/pgantlr/test/table_disallow_partition.yaml b/backend/plugin/advisor/pgantlr/test/table_disallow_partition.yaml
new file mode 100644
index 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: null
diff --git a/backend/plugin/advisor/pgantlr/test/table_drop_naming_convention.yaml b/backend/plugin/advisor/pgantlr/test/table_drop_naming_convention.yaml
new file mode 100644
index 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: null
diff --git a/backend/plugin/advisor/pgantlr/test/table_no_foreign_key.yaml b/backend/plugin/advisor/pgantlr/test/table_no_foreign_key.yaml
new file mode 100644
index 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: null
diff --git a/backend/plugin/advisor/pgantlr/test/table_require_pk.yaml b/backend/plugin/advisor/pgantlr/test/table_require_pk.yaml
new file mode 100644
index 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