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 more PostgreSQL advisors to ANTLR parser (#17859)
h3n4l71098bfb14c5
diff --git a/backend/plugin/advisor/pgantlr/advisor_naming_foreign_key_convention.go b/backend/plugin/advisor/pgantlr/advisor_naming_foreign_key_convention.gonew file mode 100644index 0000000000..6e047a2b67--- /dev/null+++ b/backend/plugin/advisor/pgantlr/advisor_naming_foreign_key_convention.go@@ -0,0 +1,330 @@+package pgantlr++import (+ "context"+ "fmt"+ "regexp"+ "strings"++ "github.com/antlr4-go/antlr/v4"++ parser "github.com/bytebase/parser/postgresql"++ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/plugin/advisor"+ pgparser "github.com/bytebase/bytebase/backend/plugin/parser/pg"+)++var (+ _ advisor.Advisor = (*NamingFKConventionAdvisor)(nil)+)++func init() {+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleFKNaming, &NamingFKConventionAdvisor{})+}++// NamingFKConventionAdvisor is the advisor checking for foreign key naming convention.+type NamingFKConventionAdvisor struct {+}++// Check checks for foreign key naming convention.+func (*NamingFKConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {+ tree, err := getANTLRTree(checkCtx)+ if err != nil {+ return nil, err+ }++ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)+ if err != nil {+ return nil, err+ }++ format, templateList, maxLength, err := advisor.UnmarshalNamingRulePayloadAsTemplate(advisor.SQLReviewRuleType(checkCtx.Rule.Type), checkCtx.Rule.Payload)+ if err != nil {+ return nil, err+ }++ checker := &namingFKConventionChecker{+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},+ level: level,+ title: string(checkCtx.Rule.Type),+ format: format,+ maxLength: maxLength,+ templateList: templateList,+ }++ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)++ return checker.adviceList, nil+}++type namingFKConventionChecker struct {+ *parser.BasePostgreSQLParserListener++ adviceList []*storepb.Advice+ level storepb.Advice_Status+ title string+ format string+ maxLength int+ templateList []string+}++type fkMetaData struct {+ indexName string+ tableName string+ line int+ metaData map[string]string+}++// EnterCreatestmt handles CREATE TABLE with FOREIGN KEY constraints+func (c *namingFKConventionChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ if ctx.Opttableelementlist() == nil {+ return+ }++ allQualifiedNames := ctx.AllQualified_name()+ if len(allQualifiedNames) == 0 {+ return+ }++ tableName := extractTableName(allQualifiedNames[0])++ // Check table-level and column-level constraints+ if ctx.Opttableelementlist().Tableelementlist() != nil {+ for _, element := range ctx.Opttableelementlist().Tableelementlist().AllTableelement() {+ // Check table-level constraints+ if element.Tableconstraint() != nil {+ metadata := c.extractFKMetadata(element.Tableconstraint(), tableName, ctx.GetStart().GetLine())+ if metadata != nil {+ c.checkFKMetadata(metadata)+ }+ }++ // Check column-level constraints+ if element.ColumnDef() != nil {+ columnDef := element.ColumnDef()+ if columnDef.Colquallist() != nil {+ allQuals := columnDef.Colquallist().AllColconstraint()+ for _, qual := range allQuals {+ metadata := c.extractColumnFKMetadata(qual, tableName, columnDef, columnDef.GetStart().GetLine())+ if metadata != nil {+ c.checkFKMetadata(metadata)+ }+ }+ }+ }+ }+ }+}++// EnterAltertablestmt handles ALTER TABLE ADD CONSTRAINT FOREIGN KEY+func (c *namingFKConventionChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ if ctx.Relation_expr() == nil {+ return+ }++ tableName := extractTableName(ctx.Relation_expr().Qualified_name())++ if ctx.Alter_table_cmds() == nil {+ return+ }++ allCmds := ctx.Alter_table_cmds().AllAlter_table_cmd()+ for _, cmd := range allCmds {+ // Check for ADD + Tableconstraint+ if cmd.ADD_P() != nil && cmd.Tableconstraint() != nil {+ metadata := c.extractFKMetadata(cmd.Tableconstraint(), tableName, cmd.GetStart().GetLine())+ if metadata != nil {+ c.checkFKMetadata(metadata)+ }+ }++ // Check for ADD COLUMN with inline foreign key constraint+ if cmd.ADD_P() != nil && cmd.ColumnDef() != nil {+ columnDef := cmd.ColumnDef()+ if columnDef.Colquallist() != nil {+ allQuals := columnDef.Colquallist().AllColconstraint()+ for _, qual := range allQuals {+ metadata := c.extractColumnFKMetadata(qual, tableName, columnDef, columnDef.GetStart().GetLine())+ if metadata != nil {+ c.checkFKMetadata(metadata)+ }+ }+ }+ }+ }+}++func (*namingFKConventionChecker) extractFKMetadata(constraint parser.ITableconstraintContext, tableName string, line int) *fkMetaData {+ if constraint.Constraintelem() == nil {+ return nil+ }++ elem := constraint.Constraintelem()++ // Check if this is a FOREIGN KEY constraint+ if elem.FOREIGN() == nil || elem.KEY() == nil {+ return nil+ }++ // Extract constraint name+ constraintName := ""+ if constraint.Name() != nil {+ constraintName = pgparser.NormalizePostgreSQLName(constraint.Name())+ }++ // Extract referencing columns+ var referencingColumns []string+ if elem.Columnlist() != nil {+ for _, colElem := range elem.Columnlist().AllColumnElem() {+ if colElem.Colid() != nil {+ referencingColumns = append(referencingColumns, pgparser.NormalizePostgreSQLColid(colElem.Colid()))+ }+ }+ }++ // Extract referenced table and columns+ var referencedTable string+ var referencedColumns []string+ if elem.Qualified_name() != nil {+ referencedTable = extractTableName(elem.Qualified_name())+ }++ if elem.Opt_column_list() != nil && elem.Opt_column_list().Columnlist() != nil {+ for _, colElem := range elem.Opt_column_list().Columnlist().AllColumnElem() {+ if colElem.Colid() != nil {+ referencedColumns = append(referencedColumns, pgparser.NormalizePostgreSQLColid(colElem.Colid()))+ }+ }+ }++ metaData := map[string]string{+ advisor.ReferencingTableNameTemplateToken: tableName,+ advisor.ReferencingColumnNameTemplateToken: strings.Join(referencingColumns, "_"),+ advisor.ReferencedTableNameTemplateToken: referencedTable,+ advisor.ReferencedColumnNameTemplateToken: strings.Join(referencedColumns, "_"),+ }++ return &fkMetaData{+ indexName: constraintName,+ tableName: tableName,+ line: line,+ metaData: metaData,+ }+}++func (*namingFKConventionChecker) extractColumnFKMetadata(qual parser.IColconstraintContext, tableName string, columnDef parser.IColumnDefContext, line int) *fkMetaData {+ if qual.Colconstraintelem() == nil {+ return nil+ }++ elem := qual.Colconstraintelem()++ // Check if this is a REFERENCES constraint (inline foreign key)+ if elem.REFERENCES() == nil {+ return nil+ }++ // Extract constraint name+ constraintName := ""+ if qual.Name() != nil {+ constraintName = pgparser.NormalizePostgreSQLName(qual.Name())+ }++ // Extract referencing column (the column being defined)+ var referencingColumn string+ if columnDef.Colid() != nil {+ referencingColumn = pgparser.NormalizePostgreSQLColid(columnDef.Colid())+ }++ // Extract referenced table and columns+ var referencedTable string+ var referencedColumns []string+ if elem.Qualified_name() != nil {+ referencedTable = extractTableName(elem.Qualified_name())+ }++ if elem.Opt_column_list() != nil && elem.Opt_column_list().Columnlist() != nil {+ for _, colElem := range elem.Opt_column_list().Columnlist().AllColumnElem() {+ if colElem.Colid() != nil {+ referencedColumns = append(referencedColumns, pgparser.NormalizePostgreSQLColid(colElem.Colid()))+ }+ }+ }++ metaData := map[string]string{+ advisor.ReferencingTableNameTemplateToken: tableName,+ advisor.ReferencingColumnNameTemplateToken: referencingColumn,+ advisor.ReferencedTableNameTemplateToken: referencedTable,+ advisor.ReferencedColumnNameTemplateToken: strings.Join(referencedColumns, "_"),+ }++ return &fkMetaData{+ indexName: constraintName,+ tableName: tableName,+ line: line,+ metaData: metaData,+ }+}++func (c *namingFKConventionChecker) checkFKMetadata(fkData *fkMetaData) {+ regex, err := c.getTemplateRegexp(fkData.metaData)+ if err != nil {+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: advisor.Internal.Int32(),+ Title: "Internal error for foreign key naming convention rule",+ Content: fmt.Sprintf("Failed to compile regex: %s", err.Error()),+ StartPosition: &storepb.Position{+ Line: int32(fkData.line),+ Column: 0,+ },+ })+ return+ }++ if !regex.MatchString(fkData.indexName) {+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: advisor.NamingFKConventionMismatch.Int32(),+ Title: c.title,+ Content: fmt.Sprintf(`Foreign key in table "%s" mismatches the naming convention, expect %q but found "%s"`, fkData.tableName, regex, fkData.indexName),+ StartPosition: &storepb.Position{+ Line: int32(fkData.line),+ Column: 0,+ },+ })+ }++ if c.maxLength > 0 && len(fkData.indexName) > c.maxLength {+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: advisor.NamingFKConventionMismatch.Int32(),+ Title: c.title,+ Content: fmt.Sprintf(`Foreign key "%s" in table "%s" mismatches the naming convention, its length should be within %d characters`, fkData.indexName, fkData.tableName, c.maxLength),+ StartPosition: &storepb.Position{+ Line: int32(fkData.line),+ Column: 0,+ },+ })+ }+}++func (c *namingFKConventionChecker) getTemplateRegexp(tokens map[string]string) (*regexp.Regexp, error) {+ template := c.format+ for _, key := range c.templateList {+ if token, ok := tokens[key]; ok {+ template = strings.ReplaceAll(template, key, token)+ }+ }++ return regexp.Compile(template)+}diff --git a/backend/plugin/advisor/pgantlr/advisor_naming_fully_qualified.go b/backend/plugin/advisor/pgantlr/advisor_naming_fully_qualified.gonew file mode 100644index 0000000000..c24de9bd1f--- /dev/null+++ b/backend/plugin/advisor/pgantlr/advisor_naming_fully_qualified.go@@ -0,0 +1,345 @@+package pgantlr++import (+ "context"+ "fmt"+ "regexp"+ "strings"++ "github.com/antlr4-go/antlr/v4"+ parser "github.com/bytebase/parser/postgresql"++ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"+ pgparser "github.com/bytebase/bytebase/backend/plugin/parser/pg"+)++var (+ _ advisor.Advisor = (*FullyQualifiedObjectNameAdvisor)(nil)+)++func init() {+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleFullyQualifiedObjectName, &FullyQualifiedObjectNameAdvisor{})+}++// FullyQualifiedObjectNameAdvisor is the advisor checking for fully qualified object names.+type FullyQualifiedObjectNameAdvisor struct {+}++// Check checks for fully qualified object names.+func (*FullyQualifiedObjectNameAdvisor) 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 := &fullyQualifiedObjectNameChecker{+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},+ level: level,+ title: string(checkCtx.Rule.Type),+ dbSchema: checkCtx.DBSchema,+ statementsText: checkCtx.Statements,+ }++ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)++ return checker.adviceList, nil+}++type fullyQualifiedObjectNameChecker struct {+ *parser.BasePostgreSQLParserListener++ adviceList []*storepb.Advice+ level storepb.Advice_Status+ title string+ dbSchema *storepb.DatabaseSchemaMetadata+ statementsText string+}++// EnterCreatestmt handles CREATE TABLE+func (c *fullyQualifiedObjectNameChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ allQualifiedNames := ctx.AllQualified_name()+ if len(allQualifiedNames) > 0 {+ c.checkQualifiedName(allQualifiedNames[0], ctx.GetStop().GetLine())+ }+}++// EnterCreateseqstmt handles CREATE SEQUENCE+func (c *fullyQualifiedObjectNameChecker) EnterCreateseqstmt(ctx *parser.CreateseqstmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ if ctx.Qualified_name() != nil {+ c.checkQualifiedName(ctx.Qualified_name(), ctx.GetStop().GetLine())+ }+}++// EnterCreatetrigstmt handles CREATE TRIGGER+func (c *fullyQualifiedObjectNameChecker) EnterCreatetrigstmt(ctx *parser.CreatetrigstmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ // Check the table name in the ON clause+ if ctx.Qualified_name() != nil {+ c.checkQualifiedName(ctx.Qualified_name(), ctx.GetStop().GetLine())+ }+}++// EnterIndexstmt handles CREATE INDEX+func (c *fullyQualifiedObjectNameChecker) EnterIndexstmt(ctx *parser.IndexstmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ // Check the table name in the ON clause+ if ctx.Relation_expr() != nil && ctx.Relation_expr().Qualified_name() != nil {+ c.checkQualifiedName(ctx.Relation_expr().Qualified_name(), ctx.GetStop().GetLine())+ }+}++// EnterDropstmt handles DROP TABLE, DROP SEQUENCE, DROP INDEX+func (c *fullyQualifiedObjectNameChecker) EnterDropstmt(ctx *parser.DropstmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ // Check all qualified names in the drop statement+ if ctx.Any_name_list() != nil {+ for _, anyName := range ctx.Any_name_list().AllAny_name() {+ c.checkAnyName(anyName, ctx.GetStop().GetLine())+ }+ }+}++// EnterAltertablestmt handles ALTER TABLE+func (c *fullyQualifiedObjectNameChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ if ctx.Relation_expr() != nil && ctx.Relation_expr().Qualified_name() != nil {+ c.checkQualifiedName(ctx.Relation_expr().Qualified_name(), ctx.GetStop().GetLine())+ }+}++// EnterAlterseqstmt handles ALTER SEQUENCE+func (c *fullyQualifiedObjectNameChecker) EnterAlterseqstmt(ctx *parser.AlterseqstmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ if ctx.Qualified_name() != nil {+ c.checkQualifiedName(ctx.Qualified_name(), ctx.GetStop().GetLine())+ }+}++// EnterRenamestmt handles ALTER TABLE RENAME+func (c *fullyQualifiedObjectNameChecker) EnterRenamestmt(ctx *parser.RenamestmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ if ctx.Relation_expr() != nil && ctx.Relation_expr().Qualified_name() != nil {+ c.checkQualifiedName(ctx.Relation_expr().Qualified_name(), ctx.GetStop().GetLine())+ }+}++// EnterInsertstmt handles INSERT+func (c *fullyQualifiedObjectNameChecker) EnterInsertstmt(ctx *parser.InsertstmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ if ctx.Insert_target() != nil && ctx.Insert_target().Qualified_name() != nil {+ c.checkQualifiedName(ctx.Insert_target().Qualified_name(), ctx.GetStop().GetLine())+ }+}++// EnterUpdatestmt handles UPDATE+func (c *fullyQualifiedObjectNameChecker) EnterUpdatestmt(ctx *parser.UpdatestmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ if ctx.Relation_expr_opt_alias() != nil && ctx.Relation_expr_opt_alias().Relation_expr() != nil {+ if ctx.Relation_expr_opt_alias().Relation_expr().Qualified_name() != nil {+ c.checkQualifiedName(ctx.Relation_expr_opt_alias().Relation_expr().Qualified_name(), ctx.GetStop().GetLine())+ }+ }+}++// EnterSelectstmt handles SELECT+func (c *fullyQualifiedObjectNameChecker) EnterSelectstmt(ctx *parser.SelectstmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ // For SELECT statements, we need to extract tables from the query+ // and check them against the database schema+ if c.dbSchema == nil {+ return+ }++ // Extract the statement text for this SELECT+ startLine := ctx.GetStop().GetLine()+ endLine := ctx.GetStop().GetLine()+ statementText := extractStatementText(c.statementsText, startLine, endLine)++ if statementText == "" {+ return+ }++ // Find all table references in the SELECT statement+ for _, tableName := range c.findAllTablesInSelect(statementText) {+ objName := tableName.String()+ if !c.isFullyQualified(objName) {+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: int32(advisor.NamingNotFullyQualifiedName),+ Title: c.title,+ Content: fmt.Sprintf("unqualified object name: '%s'", objName),+ StartPosition: &storepb.Position{+ Line: int32(startLine),+ Column: 0,+ },+ })+ }+ }+}++// checkQualifiedName checks if a qualified name is fully qualified+func (c *fullyQualifiedObjectNameChecker) checkQualifiedName(ctx parser.IQualified_nameContext, line int) {+ if ctx == nil {+ return+ }++ parts := pgparser.NormalizePostgreSQLQualifiedName(ctx)+ objName := strings.Join(parts, ".")++ if !c.isFullyQualified(objName) {+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: int32(advisor.NamingNotFullyQualifiedName),+ Title: c.title,+ Content: fmt.Sprintf("unqualified object name: '%s'", objName),+ StartPosition: &storepb.Position{+ Line: int32(line),+ Column: 0,+ },+ })+ }+}++// checkAnyName checks if an any_name is fully qualified+func (c *fullyQualifiedObjectNameChecker) checkAnyName(ctx parser.IAny_nameContext, line int) {+ if ctx == nil {+ return+ }++ // Extract parts from any_name (schema.object or object)+ parts := pgparser.NormalizePostgreSQLAnyName(ctx)+ objName := strings.Join(parts, ".")++ if !c.isFullyQualified(objName) {+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: int32(advisor.NamingNotFullyQualifiedName),+ Title: c.title,+ Content: fmt.Sprintf("unqualified object name: '%s'", objName),+ StartPosition: &storepb.Position{+ Line: int32(line),+ Column: 0,+ },+ })+ }+}++// isFullyQualified checks if an object name is fully qualified (contains a dot)+func (*fullyQualifiedObjectNameChecker) isFullyQualified(objName string) bool {+ if objName == "" {+ return true+ }+ re := regexp.MustCompile(`.+\..+`)+ return re.MatchString(objName)+}++// findAllTablesInSelect finds all table references in a SELECT statement+func (c *fullyQualifiedObjectNameChecker) findAllTablesInSelect(statement string) []base.ColumnResource {+ // Parse the statement to extract table references+ result, err := pgparser.ParsePostgreSQL(statement)+ if err != nil {+ return nil+ }++ // Use a visitor to find all table references+ collector := &tableReferenceCollector{+ schemaNameMap: c.getSchemaNameMapFromPublic(),+ }++ if result.Tree != nil {+ antlr.ParseTreeWalkerDefault.Walk(collector, result.Tree)+ }++ return collector.tables+}++// getSchemaNameMapFromPublic creates a map of table names from the database schema+func (c *fullyQualifiedObjectNameChecker) getSchemaNameMapFromPublic() map[string]bool {+ if c.dbSchema == nil || c.dbSchema.Schemas == nil {+ return nil+ }++ filterMap := map[string]bool{}+ for _, schema := range c.dbSchema.Schemas {+ // Tables+ for _, tbl := range schema.Tables {+ filterMap[tbl.Name] = true+ }+ // External Tables+ for _, tbl := range schema.ExternalTables {+ filterMap[tbl.Name] = true+ }+ }+ return filterMap+}++// tableReferenceCollector collects table references from a SELECT statement+type tableReferenceCollector struct {+ *parser.BasePostgreSQLParserListener++ tables []base.ColumnResource+ schemaNameMap map[string]bool+}++// EnterTable_ref collects table references+func (c *tableReferenceCollector) EnterTable_ref(ctx *parser.Table_refContext) {+ // Look for relation_expr in the table_ref+ if ctx.Relation_expr() != nil && ctx.Relation_expr().Qualified_name() != nil {+ parts := pgparser.NormalizePostgreSQLQualifiedName(ctx.Relation_expr().Qualified_name())++ resource := base.ColumnResource{}+ if len(parts) == 2 {+ resource.Schema = parts[0]+ resource.Table = parts[1]+ } else if len(parts) == 1 {+ resource.Table = parts[0]+ }++ // Only add if the table exists in the schema+ if c.schemaNameMap == nil || c.schemaNameMap[resource.Table] {+ c.tables = append(c.tables, resource)+ }+ }+}diff --git a/backend/plugin/advisor/pgantlr/advisor_naming_index_convention.go b/backend/plugin/advisor/pgantlr/advisor_naming_index_convention.gonew file mode 100644index 0000000000..c150480bf5--- /dev/null+++ b/backend/plugin/advisor/pgantlr/advisor_naming_index_convention.go@@ -0,0 +1,214 @@+package pgantlr++import (+ "context"+ "fmt"+ "strings"++ "github.com/antlr4-go/antlr/v4"++ parser "github.com/bytebase/parser/postgresql"++ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/advisor/catalog"+ pgparser "github.com/bytebase/bytebase/backend/plugin/parser/pg"+)++var (+ _ advisor.Advisor = (*NamingIndexConventionAdvisor)(nil)+)++func init() {+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleIDXNaming, &NamingIndexConventionAdvisor{})+}++// NamingIndexConventionAdvisor is the advisor checking for index naming convention.+type NamingIndexConventionAdvisor struct {+}++// Check checks for index naming convention.+func (*NamingIndexConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {+ tree, err := getANTLRTree(checkCtx)+ if err != nil {+ return nil, err+ }++ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)+ if err != nil {+ return nil, err+ }++ format, templateList, maxLength, err := advisor.UnmarshalNamingRulePayloadAsTemplate(advisor.SQLReviewRuleType(checkCtx.Rule.Type), checkCtx.Rule.Payload)+ if err != nil {+ return nil, err+ }++ checker := &namingIndexConventionChecker{+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},+ level: level,+ title: string(checkCtx.Rule.Type),+ format: format,+ maxLength: maxLength,+ templateList: templateList,+ catalog: checkCtx.Catalog,+ }++ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)++ return checker.adviceList, nil+}++type namingIndexConventionChecker struct {+ *parser.BasePostgreSQLParserListener++ adviceList []*storepb.Advice+ level storepb.Advice_Status+ title string+ format string+ maxLength int+ templateList []string+ catalog *catalog.Finder+}++// EnterIndexstmt checks CREATE INDEX statements+func (c *namingIndexConventionChecker) EnterIndexstmt(ctx *parser.IndexstmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ // Check if this is a UNIQUE index - if so, skip it+ if ctx.Opt_unique() != nil && ctx.Opt_unique().UNIQUE() != nil {+ return+ }++ // Get index name+ indexName := ""+ if ctx.Name() != nil {+ indexName = pgparser.NormalizePostgreSQLName(ctx.Name())+ }+ if indexName == "" {+ return+ }++ // Get table name+ tableName := ""+ if ctx.Relation_expr() != nil && ctx.Relation_expr().Qualified_name() != nil {+ tableName = extractTableName(ctx.Relation_expr().Qualified_name())+ }+ if tableName == "" {+ return+ }++ // Get column list+ var columnList []string+ if ctx.Index_params() != nil {+ allParams := ctx.Index_params().AllIndex_elem()+ for _, param := range allParams {+ if param.Colid() != nil {+ colName := pgparser.NormalizePostgreSQLColid(param.Colid())+ columnList = append(columnList, colName)+ }+ }+ }++ c.checkIndexName(indexName, tableName, columnList, ctx.GetStart().GetLine())+}++// EnterRenamestmt checks ALTER INDEX ... RENAME TO statements+func (c *namingIndexConventionChecker) EnterRenamestmt(ctx *parser.RenamestmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ // Check for ALTER INDEX ... RENAME TO+ if ctx.INDEX() != nil && ctx.TO() != nil {+ allNames := ctx.AllName()+ if len(allNames) < 1 {+ return+ }++ // Get old index name from qualified_name+ var oldIndexName string+ if ctx.Qualified_name() != nil {+ parts := pgparser.NormalizePostgreSQLQualifiedName(ctx.Qualified_name())+ if len(parts) > 0 {+ oldIndexName = parts[len(parts)-1]+ }+ }++ // Get new index name from the name after TO+ newIndexName := pgparser.NormalizePostgreSQLName(allNames[0])++ // Look up the index in catalog to determine if it's a regular index (not unique, not PK)+ if c.catalog != nil && oldIndexName != "" {+ tableName, index := c.findIndex("", "", oldIndexName)+ if index != nil {+ // Only check if it's a regular index (not unique, not primary)+ if !index.Unique() && !index.Primary() {+ c.checkIndexName(newIndexName, tableName, index.ExpressionList(), ctx.GetStart().GetLine())+ }+ }+ }+ }+}++func (c *namingIndexConventionChecker) checkIndexName(indexName, tableName string, columnList []string, line int) {+ metaData := map[string]string{+ advisor.ColumnListTemplateToken: strings.Join(columnList, "_"),+ advisor.TableNameTemplateToken: tableName,+ }++ regex, err := getTemplateRegexp(c.format, c.templateList, metaData)+ if err != nil {+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: advisor.Internal.Int32(),+ Title: "Internal error for index naming convention rule",+ Content: fmt.Sprintf("Failed to compile regex: %v", err),+ StartPosition: &storepb.Position{+ Line: int32(line),+ Column: 0,+ },+ })+ return+ }++ if !regex.MatchString(indexName) {+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: advisor.NamingIndexConventionMismatch.Int32(),+ Title: c.title,+ Content: fmt.Sprintf("Index in table %q mismatches the naming convention, expect %q but found %q", tableName, regex, indexName),+ StartPosition: &storepb.Position{+ Line: int32(line),+ Column: 0,+ },+ })+ }++ if c.maxLength > 0 && len(indexName) > c.maxLength {+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: advisor.NamingIndexConventionMismatch.Int32(),+ Title: c.title,+ Content: fmt.Sprintf("Index %q in table %q mismatches the naming convention, its length should be within %d characters", indexName, tableName, c.maxLength),+ StartPosition: &storepb.Position{+ Line: int32(line),+ Column: 0,+ },+ })+ }+}++// findIndex returns index found in catalogs, nil if not found.+func (c *namingIndexConventionChecker) findIndex(schemaName string, tableName string, indexName string) (string, *catalog.IndexState) {+ if c.catalog == nil {+ return "", nil+ }+ return c.catalog.Origin.FindIndex(&catalog.IndexFind{+ SchemaName: normalizeSchemaName(schemaName),+ TableName: tableName,+ IndexName: indexName,+ })+}diff --git a/backend/plugin/advisor/pgantlr/advisor_naming_primary_key_convention.go b/backend/plugin/advisor/pgantlr/advisor_naming_primary_key_convention.gonew file mode 100644index 0000000000..e6e7200ed1--- /dev/null+++ b/backend/plugin/advisor/pgantlr/advisor_naming_primary_key_convention.go@@ -0,0 +1,369 @@+package pgantlr++import (+ "context"+ "fmt"+ "strings"++ "github.com/antlr4-go/antlr/v4"++ parser "github.com/bytebase/parser/postgresql"++ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/advisor/catalog"+ pgparser "github.com/bytebase/bytebase/backend/plugin/parser/pg"+)++var (+ _ advisor.Advisor = (*NamingPKConventionAdvisor)(nil)+)++func init() {+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRulePKNaming, &NamingPKConventionAdvisor{})+}++// NamingPKConventionAdvisor is the advisor checking for primary key naming convention.+type NamingPKConventionAdvisor struct {+}++// Check checks for primary key naming convention.+func (*NamingPKConventionAdvisor) 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, templateList, maxLength, err := advisor.UnmarshalNamingRulePayloadAsTemplate(advisor.SQLReviewRuleType(checkCtx.Rule.Type), checkCtx.Rule.Payload)+ if err != nil {+ return nil, err+ }++ checker := &namingPKConventionChecker{+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},+ level: level,+ title: string(checkCtx.Rule.Type),+ format: format,+ maxLength: maxLength,+ templateList: templateList,+ catalog: checkCtx.Catalog,+ statementsText: checkCtx.Statements,+ }++ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)++ return checker.adviceList, nil+}++type namingPKConventionChecker struct {+ *parser.BasePostgreSQLParserListener++ adviceList []*storepb.Advice+ level storepb.Advice_Status+ title string+ format string+ maxLength int+ templateList []string+ catalog *catalog.Finder+ statementsText string+}++type pkMetaData struct {+ pkName string+ tableName string+ schemaName string+ line int+ metaData map[string]string+}++// EnterCreatestmt handles CREATE TABLE with PRIMARY KEY constraints+func (c *namingPKConventionChecker) 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 table-level PRIMARY KEY constraint+ if elem.Tableconstraint() != nil {+ constraint := elem.Tableconstraint()+ if pkData := c.getPKMetaDataFromTableConstraint(constraint, tableName, schemaName, constraint.GetStart().GetLine()); pkData != nil {+ c.checkPKName(pkData)+ }+ }++ // Check column-level PRIMARY KEY constraint - commented out for now+ // Column-level constraints typically don't have explicit names in the test cases+ }+ }+}++// EnterAltertablestmt handles ALTER TABLE ADD CONSTRAINT PRIMARY KEY+func (c *namingPKConventionChecker) 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 {+ // ADD CONSTRAINT+ if cmd.ADD_P() != nil && cmd.Tableconstraint() != nil {+ constraint := cmd.Tableconstraint()+ if pkData := c.getPKMetaDataFromTableConstraint(constraint, tableName, schemaName, constraint.GetStart().GetLine()); pkData != nil {+ c.checkPKName(pkData)+ }+ }+ }+ }+}++// EnterRenamestmt handles ALTER TABLE RENAME CONSTRAINT and ALTER INDEX RENAME TO+func (c *namingPKConventionChecker) EnterRenamestmt(ctx *parser.RenamestmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ allNames := ctx.AllName()++ // Check for ALTER TABLE ... RENAME CONSTRAINT old_name TO new_name+ // Example: ALTER TABLE tech_book RENAME CONSTRAINT old_pk TO new_pk+ if ctx.TABLE() != nil && ctx.CONSTRAINT() != nil && ctx.TO() != nil {+ var tableName, schemaName string+ // Get table name from Relation_expr()+ 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 len(allNames) >= 2 {+ oldName := pgparser.NormalizePostgreSQLName(allNames[len(allNames)-2])+ newName := pgparser.NormalizePostgreSQLName(allNames[len(allNames)-1])++ // Check if old constraint is a primary key using catalog+ if c.catalog != nil {+ normalizedSchema := schemaName+ if normalizedSchema == "" {+ normalizedSchema = "public"+ }+ _, index := c.catalog.Origin.FindIndex(&catalog.IndexFind{+ SchemaName: normalizedSchema,+ TableName: tableName,+ IndexName: oldName,+ })+ if index != nil && index.Primary() {+ metaData := map[string]string{+ advisor.ColumnListTemplateToken: strings.Join(index.ExpressionList(), "_"),+ advisor.TableNameTemplateToken: tableName,+ }+ pkData := &pkMetaData{+ pkName: newName,+ tableName: tableName,+ schemaName: schemaName,+ line: ctx.GetStart().GetLine(),+ metaData: metaData,+ }+ c.checkPKName(pkData)+ }+ }+ }+ }++ // Check for ALTER INDEX ... RENAME TO new_name+ // Example: ALTER INDEX old_pk RENAME TO new_pk+ if ctx.INDEX() != nil && ctx.TO() != nil {+ var oldIndexName, schemaName string++ // Try Qualified_name first (direct qualified name)+ if ctx.Qualified_name() != nil {+ oldIndexName = extractTableName(ctx.Qualified_name())+ schemaName = extractSchemaName(ctx.Qualified_name())+ } else if ctx.Relation_expr() != nil && ctx.Relation_expr().Qualified_name() != nil {+ // Fall back to Relation_expr+ oldIndexName = extractTableName(ctx.Relation_expr().Qualified_name())+ schemaName = extractSchemaName(ctx.Relation_expr().Qualified_name())+ }++ if oldIndexName != "" && len(allNames) > 0 {+ newIndexName := pgparser.NormalizePostgreSQLName(allNames[len(allNames)-1])++ // Check if this index is a primary key using catalog+ if c.catalog != nil {+ normalizedSchema := schemaName+ if normalizedSchema == "" {+ normalizedSchema = "public"+ }+ // "ALTER INDEX name RENAME TO new_name" doesn't specify table name+ tableName, index := c.catalog.Origin.FindIndex(&catalog.IndexFind{+ SchemaName: normalizedSchema,+ TableName: "", // Empty table name for ALTER INDEX+ IndexName: oldIndexName,+ })+ if index != nil && index.Primary() {+ metaData := map[string]string{+ advisor.ColumnListTemplateToken: strings.Join(index.ExpressionList(), "_"),+ advisor.TableNameTemplateToken: tableName,+ }+ pkData := &pkMetaData{+ pkName: newIndexName,+ tableName: tableName,+ schemaName: normalizedSchema,+ line: ctx.GetStart().GetLine(),+ metaData: metaData,+ }+ c.checkPKName(pkData)+ }+ }+ }+ }+}++func (c *namingPKConventionChecker) getPKMetaDataFromTableConstraint(constraint parser.ITableconstraintContext, tableName, schemaName string, line int) *pkMetaData {+ if constraint == nil || constraint.Constraintelem() == nil {+ return nil+ }++ elem := constraint.Constraintelem()++ // Check if this is a PRIMARY KEY constraint+ if elem.PRIMARY() != nil && elem.KEY() != nil {+ var pkName string+ var columnList []string++ // Try to get constraint name using GetText() on constraint itself and parsing it+ // Format is usually: CONSTRAINT name PRIMARY KEY (columns) or just PRIMARY KEY (columns)+ constraintText := constraint.GetText()+ // Check if it starts with CONSTRAINT keyword+ if strings.HasPrefix(strings.ToUpper(constraintText), "CONSTRAINT") {+ // Extract the name between CONSTRAINT and PRIMARY+ parts := strings.Split(constraintText, "PRIMARY")+ if len(parts) > 0 {+ // Remove "CONSTRAINT" prefix+ namePart := strings.TrimPrefix(strings.ToUpper(parts[0]), "CONSTRAINT")+ namePart = strings.TrimSpace(strings.ToLower(namePart))+ // The name is before the keyword PRIMARY+ // This is a simplified extraction+ if namePart != "" && !strings.Contains(namePart, "(") {+ pkName = namePart+ }+ }+ }++ // Get column list+ if elem.Columnlist() != nil {+ allColumns := elem.Columnlist().AllColumnElem()+ for _, col := range allColumns {+ if col.Colid() != nil {+ columnList = append(columnList, pgparser.NormalizePostgreSQLColid(col.Colid()))+ }+ }+ }++ // PRIMARY KEY USING INDEX+ if elem.Existingindex() != nil && elem.Existingindex().Name() != nil {+ // Extract index name properly+ indexName := pgparser.NormalizePostgreSQLName(elem.Existingindex().Name())+ // Find the index in catalog to get column list+ if c.catalog != nil && indexName != "" {+ normalizedSchema := schemaName+ if normalizedSchema == "" {+ normalizedSchema = "public"+ }+ _, index := c.catalog.Origin.FindIndex(&catalog.IndexFind{+ SchemaName: normalizedSchema,+ TableName: tableName,+ IndexName: indexName,+ })+ if index != nil {+ columnList = index.ExpressionList()+ }+ }+ }++ if pkName != "" {+ metaData := map[string]string{+ advisor.ColumnListTemplateToken: strings.Join(columnList, "_"),+ advisor.TableNameTemplateToken: tableName,+ }+ return &pkMetaData{+ pkName: pkName,+ tableName: tableName,+ schemaName: schemaName,+ line: line,+ metaData: metaData,+ }+ }+ }++ return nil+}++func (c *namingPKConventionChecker) checkPKName(pkData *pkMetaData) {+ regex, err := getTemplateRegexp(c.format, c.templateList, pkData.metaData)+ if err != nil {+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: advisor.Internal.Int32(),+ Title: "Internal error for primary key naming convention rule",+ Content: fmt.Sprintf("Failed to compile regex: %v", err),+ StartPosition: &storepb.Position{+ Line: int32(pkData.line),+ Column: 0,+ },+ })+ return+ }++ if !regex.MatchString(pkData.pkName) {+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: advisor.NamingPKConventionMismatch.Int32(),+ Title: c.title,+ Content: fmt.Sprintf(`Primary key in table "%s" mismatches the naming convention, expect %q but found "%s"`, pkData.tableName, regex, pkData.pkName),+ StartPosition: &storepb.Position{+ Line: int32(pkData.line),+ Column: 0,+ },+ })+ }++ if c.maxLength > 0 && len(pkData.pkName) > c.maxLength {+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: advisor.NamingPKConventionMismatch.Int32(),+ Title: c.title,+ Content: fmt.Sprintf(`Primary key "%s" in table "%s" mismatches the naming convention, its length should be within %d characters`, pkData.pkName, pkData.tableName, c.maxLength),+ StartPosition: &storepb.Position{+ Line: int32(pkData.line),+ Column: 0,+ },+ })+ }+}diff --git a/backend/plugin/advisor/pgantlr/advisor_naming_unique_key_convention.go b/backend/plugin/advisor/pgantlr/advisor_naming_unique_key_convention.gonew file mode 100644index 0000000000..d60835f1f8--- /dev/null+++ b/backend/plugin/advisor/pgantlr/advisor_naming_unique_key_convention.go@@ -0,0 +1,395 @@+package pgantlr++import (+ "context"+ "fmt"+ "regexp"+ "strings"++ "github.com/antlr4-go/antlr/v4"+ parser "github.com/bytebase/parser/postgresql"++ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/plugin/advisor"+ "github.com/bytebase/bytebase/backend/plugin/advisor/catalog"+ pgparser "github.com/bytebase/bytebase/backend/plugin/parser/pg"+)++var (+ _ advisor.Advisor = (*NamingUKConventionAdvisor)(nil)+)++func init() {+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleUKNaming, &NamingUKConventionAdvisor{})+}++// NamingUKConventionAdvisor is the advisor checking for unique key naming convention.+type NamingUKConventionAdvisor struct {+}++// Check checks for unique key naming convention.+func (*NamingUKConventionAdvisor) 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, templateList, maxLength, err := advisor.UnmarshalNamingRulePayloadAsTemplate(advisor.SQLReviewRuleType(checkCtx.Rule.Type), checkCtx.Rule.Payload)+ if err != nil {+ return nil, err+ }++ checker := &namingUKConventionChecker{+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},+ level: level,+ title: string(checkCtx.Rule.Type),+ format: format,+ maxLength: maxLength,+ templateList: templateList,+ catalog: checkCtx.Catalog,+ }++ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)++ return checker.adviceList, nil+}++type namingUKConventionChecker struct {+ *parser.BasePostgreSQLParserListener++ adviceList []*storepb.Advice+ level storepb.Advice_Status+ title string+ format string+ maxLength int+ templateList []string+ catalog *catalog.Finder+}++//nolint:unused+type indexMetaData struct {+ indexName string+ tableName string+ line int+ metaData map[string]string+}++// EnterIndexstmt handles CREATE UNIQUE INDEX statements+func (c *namingUKConventionChecker) EnterIndexstmt(ctx *parser.IndexstmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ // Only check UNIQUE indexes+ if ctx.Opt_unique() == nil || ctx.Opt_unique().UNIQUE() == nil {+ return+ }++ indexName := ""+ if ctx.Name() != nil {+ indexName = pgparser.NormalizePostgreSQLName(ctx.Name())+ }++ tableName := ""+ if ctx.Relation_expr() != nil && ctx.Relation_expr().Qualified_name() != nil {+ tableName = extractTableName(ctx.Relation_expr().Qualified_name())+ }++ // Extract column list+ var columnList []string+ if ctx.Index_params() != nil {+ allParams := ctx.Index_params().AllIndex_elem()+ for _, param := range allParams {+ if param.Colid() != nil {+ colName := pgparser.NormalizePostgreSQLColid(param.Colid())+ columnList = append(columnList, colName)+ }+ }+ }++ metaData := map[string]string{+ advisor.ColumnListTemplateToken: strings.Join(columnList, "_"),+ advisor.TableNameTemplateToken: tableName,+ }++ c.checkUniqueKeyName(indexName, tableName, metaData, ctx.GetStart().GetLine())+}++// EnterCreatestmt handles CREATE TABLE with UNIQUE constraints+func (c *namingUKConventionChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ qualifiedNames := ctx.AllQualified_name()+ if len(qualifiedNames) == 0 {+ return+ }++ tableName := extractTableName(qualifiedNames[0])+ if tableName == "" {+ return+ }++ // Check table-level constraints+ if ctx.Opttableelementlist() != nil && ctx.Opttableelementlist().Tableelementlist() != nil {+ allElements := ctx.Opttableelementlist().Tableelementlist().AllTableelement()+ for _, elem := range allElements {+ if elem.Tableconstraint() != nil {+ c.checkTableConstraint(elem.Tableconstraint(), tableName, elem.GetStart().GetLine())+ }+ // Check column-level constraints+ if elem.ColumnDef() != nil {+ c.checkColumnDef(elem.ColumnDef(), tableName)+ }+ }+ }+}++// EnterAltertablestmt handles ALTER TABLE statements+func (c *namingUKConventionChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ if ctx.Relation_expr() == nil || ctx.Relation_expr().Qualified_name() == nil {+ return+ }++ tableName := extractTableName(ctx.Relation_expr().Qualified_name())+ if tableName == "" {+ return+ }++ if ctx.Alter_table_cmds() != nil {+ allCmds := ctx.Alter_table_cmds().AllAlter_table_cmd()+ for _, cmd := range allCmds {+ // ADD CONSTRAINT+ if cmd.ADD_P() != nil && cmd.Tableconstraint() != nil {+ c.checkTableConstraint(cmd.Tableconstraint(), tableName, ctx.GetStart().GetLine())+ }+ // ADD COLUMN with constraints+ if cmd.ADD_P() != nil && cmd.ColumnDef() != nil {+ c.checkColumnDef(cmd.ColumnDef(), tableName)+ }+ }+ }++ // Note: ALTER TABLE ... RENAME CONSTRAINT is handled in EnterRenamestmt+ // because PostgreSQL parser treats "ALTER TABLE t RENAME CONSTRAINT old TO new"+ // as a rename statement, not as an alter_table_cmd+}++// EnterRenamestmt handles ALTER INDEX ... RENAME TO and ALTER TABLE ... RENAME CONSTRAINT statements+func (c *namingUKConventionChecker) EnterRenamestmt(ctx *parser.RenamestmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ // Check for ALTER INDEX ... RENAME TO+ if ctx.INDEX() != nil && ctx.TO() != nil {+ allNames := ctx.AllName()+ if len(allNames) < 1 {+ return+ }++ // Get old index name from qualified_name+ var oldIndexName string+ if ctx.Qualified_name() != nil {+ parts := pgparser.NormalizePostgreSQLQualifiedName(ctx.Qualified_name())+ if len(parts) > 0 {+ oldIndexName = parts[len(parts)-1]+ }+ }++ // Get new index name from the name after TO+ newIndexName := pgparser.NormalizePostgreSQLName(allNames[0])++ // Look up the index in catalog to determine if it's a unique key+ if c.catalog != nil && oldIndexName != "" {+ tableName, index := c.findIndex("", "", oldIndexName)+ if index != nil && index.Unique() && !index.Primary() {+ c.checkUniqueKeyName(newIndexName, tableName, map[string]string{+ advisor.ColumnListTemplateToken: strings.Join(index.ExpressionList(), "_"),+ advisor.TableNameTemplateToken: tableName,+ }, ctx.GetStart().GetLine())+ }+ }+ }++ // Check for ALTER TABLE ... RENAME CONSTRAINT+ if ctx.CONSTRAINT() != nil && ctx.TO() != nil && c.catalog != nil {+ allNames := ctx.AllName()+ if len(allNames) >= 2 {+ oldConstraintName := pgparser.NormalizePostgreSQLName(allNames[0])+ newConstraintName := pgparser.NormalizePostgreSQLName(allNames[1])++ // Get table name from the statement+ 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())+ }++ // Check if this is a unique key constraint in catalog+ foundTableName, index := c.findIndex(schemaName, tableName, oldConstraintName)+ if index != nil && index.Unique() && !index.Primary() {+ metaData := map[string]string{+ advisor.ColumnListTemplateToken: strings.Join(index.ExpressionList(), "_"),+ advisor.TableNameTemplateToken: foundTableName,+ }+ c.checkUniqueKeyName(newConstraintName, foundTableName, metaData, ctx.GetStart().GetLine())+ }+ }+ }+}++func (c *namingUKConventionChecker) checkTableConstraint(constraint parser.ITableconstraintContext, tableName string, line int) {+ if constraint == nil {+ return+ }++ constraintName := ""+ if constraint.Name() != nil {+ constraintName = pgparser.NormalizePostgreSQLName(constraint.Name())+ }++ if constraint.Constraintelem() != nil {+ elem := constraint.Constraintelem()++ // UNIQUE constraint+ if elem.UNIQUE() != nil {+ var columnList []string+ if elem.Columnlist() != nil {+ allColumns := elem.Columnlist().AllColumnElem()+ for _, col := range allColumns {+ if col.Colid() != nil {+ colName := pgparser.NormalizePostgreSQLColid(col.Colid())+ columnList = append(columnList, colName)+ }+ }+ } else if elem.Existingindex() != nil && elem.Existingindex().Name() != nil {+ // Handle UNIQUE USING INDEX - the column list is in the existing index+ indexName := pgparser.NormalizePostgreSQLName(elem.Existingindex().Name())+ foundTableName, index := c.findIndex("", tableName, indexName)+ if index != nil {+ columnList = index.ExpressionList()+ tableName = foundTableName+ }+ }++ // Only check if we have a constraint name (unnamed constraints are auto-generated)+ if constraintName != "" {+ metaData := map[string]string{+ advisor.ColumnListTemplateToken: strings.Join(columnList, "_"),+ advisor.TableNameTemplateToken: tableName,+ }+ c.checkUniqueKeyName(constraintName, tableName, metaData, line)+ }+ }+ }+}++func (c *namingUKConventionChecker) checkColumnDef(columndef parser.IColumnDefContext, tableName string) {+ if columndef == nil {+ return+ }++ colName := ""+ if columndef.Colid() != nil {+ colName = pgparser.NormalizePostgreSQLColid(columndef.Colid())+ }++ // Check column-level constraints+ if columndef.Colquallist() != nil {+ allQuals := columndef.Colquallist().AllColconstraint()+ for _, qual := range allQuals {+ if qual.Colconstraintelem() != nil {+ elem := qual.Colconstraintelem()+ // Check for UNIQUE constraint+ if elem.UNIQUE() != nil {+ // Column-level unique constraints with names+ constraintName := ""+ if qual.Name() != nil {+ constraintName = pgparser.NormalizePostgreSQLName(qual.Name())+ }++ // Only check if we have a constraint name+ if constraintName != "" {+ metaData := map[string]string{+ advisor.ColumnListTemplateToken: colName,+ advisor.TableNameTemplateToken: tableName,+ }+ c.checkUniqueKeyName(constraintName, tableName, metaData, qual.GetStart().GetLine())+ }+ }+ }+ }+ }+}++func (c *namingUKConventionChecker) checkUniqueKeyName(indexName, tableName string, metaData map[string]string, line int) {+ regex, err := c.getTemplateRegexp(metaData)+ if err != nil {+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: advisor.Internal.Int32(),+ Title: "Internal error for unique key naming convention rule",+ Content: fmt.Sprintf("Failed to compile regex for unique key naming convention: %v", err),+ })+ return+ }++ if !regex.MatchString(indexName) {+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: advisor.NamingUKConventionMismatch.Int32(),+ Title: c.title,+ Content: fmt.Sprintf(`Unique key in table "%s" mismatches the naming convention, expect %q but found "%s"`, tableName, regex, indexName),+ StartPosition: &storepb.Position{+ Line: int32(line),+ Column: 0,+ },+ })+ }++ if c.maxLength > 0 && len(indexName) > c.maxLength {+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: advisor.NamingUKConventionMismatch.Int32(),+ Title: c.title,+ Content: fmt.Sprintf(`Unique key "%s" in table "%s" mismatches the naming convention, its length should be within %d characters`, indexName, tableName, c.maxLength),+ StartPosition: &storepb.Position{+ Line: int32(line),+ Column: 0,+ },+ })+ }+}++func (c *namingUKConventionChecker) getTemplateRegexp(tokens map[string]string) (*regexp.Regexp, error) {+ template := c.format+ for _, key := range c.templateList {+ if token, ok := tokens[key]; ok {+ template = strings.ReplaceAll(template, key, token)+ }+ }+ return regexp.Compile(template)+}++// findIndex returns index found in catalogs, nil if not found.+func (c *namingUKConventionChecker) findIndex(schemaName string, tableName string, indexName string) (string, *catalog.IndexState) {+ if c.catalog == nil {+ return "", nil+ }+ return c.catalog.Origin.FindIndex(&catalog.IndexFind{+ SchemaName: normalizeSchemaName(schemaName),+ TableName: tableName,+ IndexName: indexName,+ })+}diff --git a/backend/plugin/advisor/pgantlr/advisor_statement_check_set_role_variable.go b/backend/plugin/advisor/pgantlr/advisor_statement_check_set_role_variable.gonew file mode 100644index 0000000000..c4476371b2--- /dev/null+++ b/backend/plugin/advisor/pgantlr/advisor_statement_check_set_role_variable.go@@ -0,0 +1,111 @@+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 = (*StatementCheckSetRoleVariable)(nil)+)++func init() {+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleStatementCheckSetRoleVariable, &StatementCheckSetRoleVariable{})+}++type StatementCheckSetRoleVariable struct {+}++func (*StatementCheckSetRoleVariable) 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 := &statementCheckSetRoleVariableChecker{+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},+ level: level,+ title: string(checkCtx.Rule.Type),+ }++ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)++ if !checker.hasSetRole {+ return []*storepb.Advice{{+ Status: level,+ Code: advisor.StatementCheckSetRoleVariable.Int32(),+ Title: checker.title,+ Content: "No SET ROLE statement found.",+ StartPosition: nil,+ }}, nil+ }++ return nil, nil+}++type statementCheckSetRoleVariableChecker struct {+ *parser.BasePostgreSQLParserListener++ level storepb.Advice_Status+ title string+ hasSetRole bool+ foundNonSetStmt bool+}++// EnterVariablesetstmt handles SET statements+func (c *statementCheckSetRoleVariableChecker) EnterVariablesetstmt(ctx *parser.VariablesetstmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ // If we already found a non-SET statement, skip this+ if c.foundNonSetStmt {+ return+ }++ // Check if this is a SET ROLE statement+ setRest := ctx.Set_rest()+ if setRest != nil {+ setRestMore := setRest.Set_rest_more()+ if setRestMore != nil && setRestMore.ROLE() != nil {+ c.hasSetRole = true+ }+ }+}++// EnterEveryRule is called for every rule entry to detect non-SET statements+func (c *statementCheckSetRoleVariableChecker) EnterEveryRule(ctx antlr.ParserRuleContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ // If we already found a non-SET statement, no need to continue checking+ if c.foundNonSetStmt {+ return+ }++ // Check if this is a non-SET statement at the top level+ // We only care about statements that are not VariablesetstmtContext+ if _, isSetStmt := ctx.(*parser.VariablesetstmtContext); !isSetStmt {+ // Check if this is a statement node (not structural nodes like Stmt, Root, etc.)+ switch ctx.(type) {+ case *parser.RootContext, *parser.StmtblockContext, *parser.StmtmultiContext, *parser.StmtContext:+ // These are structural nodes, not actual statements+ return+ default:+ // This is a non-SET statement+ c.foundNonSetStmt = true+ }+ }+}diff --git a/backend/plugin/advisor/pgantlr/advisor_statement_disallow_mix_in_dml.go b/backend/plugin/advisor/pgantlr/advisor_statement_disallow_mix_in_dml.gonew file mode 100644index 0000000000..7ed70acbf2--- /dev/null+++ b/backend/plugin/advisor/pgantlr/advisor_statement_disallow_mix_in_dml.go@@ -0,0 +1,252 @@+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 = (*StatementDisallowMixInDMLAdvisor)(nil)+)++func init() {+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleStatementDisallowMixInDML, &StatementDisallowMixInDMLAdvisor{})+}++// StatementDisallowMixInDMLAdvisor is the advisor checking for disallow mix DDL and DML.+type StatementDisallowMixInDMLAdvisor struct {+}++// Check checks for disallow mix DDL and DML.+func (*StatementDisallowMixInDMLAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {+ // Only check when change type is DML+ switch checkCtx.ChangeType {+ case storepb.PlanCheckRunConfig_DML:+ 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 := &statementDisallowMixInDMLChecker{+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},+ level: level,+ title: string(checkCtx.Rule.Type),+ statementsText: checkCtx.Statements,+ }++ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)++ return checker.adviceList, nil+}++type statementDisallowMixInDMLChecker struct {+ *parser.BasePostgreSQLParserListener++ adviceList []*storepb.Advice+ level storepb.Advice_Status+ title string+ statementsText string+}++// EnterCreatestmt handles CREATE TABLE statements (DDL)+func (c *statementDisallowMixInDMLChecker) EnterCreatestmt(ctx *parser.CreatestmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ c.addDDLAdvice(ctx, "CREATE TABLE")+}++// EnterIndexstmt handles CREATE INDEX statements (DDL)+func (c *statementDisallowMixInDMLChecker) EnterIndexstmt(ctx *parser.IndexstmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ c.addDDLAdvice(ctx, "CREATE INDEX")+}++// EnterAltertablestmt handles ALTER TABLE statements (DDL)+func (c *statementDisallowMixInDMLChecker) EnterAltertablestmt(ctx *parser.AltertablestmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ c.addDDLAdvice(ctx, "ALTER TABLE")+}++// EnterDropstmt handles DROP statements (DDL)+func (c *statementDisallowMixInDMLChecker) EnterDropstmt(ctx *parser.DropstmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ c.addDDLAdvice(ctx, "DROP")+}++// EnterCreateschemastmt handles CREATE SCHEMA statements (DDL)+func (c *statementDisallowMixInDMLChecker) EnterCreateschemastmt(ctx *parser.CreateschemastmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ c.addDDLAdvice(ctx, "CREATE SCHEMA")+}++// EnterCreateseqstmt handles CREATE SEQUENCE statements (DDL)+func (c *statementDisallowMixInDMLChecker) EnterCreateseqstmt(ctx *parser.CreateseqstmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ c.addDDLAdvice(ctx, "CREATE SEQUENCE")+}++// EnterAlterseqstmt handles ALTER SEQUENCE statements (DDL)+func (c *statementDisallowMixInDMLChecker) EnterAlterseqstmt(ctx *parser.AlterseqstmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ c.addDDLAdvice(ctx, "ALTER SEQUENCE")+}++// EnterViewstmt handles CREATE VIEW statements (DDL)+func (c *statementDisallowMixInDMLChecker) EnterViewstmt(ctx *parser.ViewstmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ c.addDDLAdvice(ctx, "CREATE VIEW")+}++// EnterCreatefunctionstmt handles CREATE FUNCTION statements (DDL)+func (c *statementDisallowMixInDMLChecker) EnterCreatefunctionstmt(ctx *parser.CreatefunctionstmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ c.addDDLAdvice(ctx, "CREATE FUNCTION")+}++// EnterCreatetrigstmt handles CREATE TRIGGER statements (DDL)+func (c *statementDisallowMixInDMLChecker) EnterCreatetrigstmt(ctx *parser.CreatetrigstmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ c.addDDLAdvice(ctx, "CREATE TRIGGER")+}++// EnterRenamestmt handles RENAME statements (DDL)+func (c *statementDisallowMixInDMLChecker) EnterRenamestmt(ctx *parser.RenamestmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ c.addDDLAdvice(ctx, "RENAME")+}++// EnterAlterobjectschemastmt handles ALTER ... SET SCHEMA statements (DDL)+func (c *statementDisallowMixInDMLChecker) EnterAlterobjectschemastmt(ctx *parser.AlterobjectschemastmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ c.addDDLAdvice(ctx, "ALTER SET SCHEMA")+}++// EnterAlterenumstmt handles ALTER TYPE ... ADD VALUE statements (DDL)+func (c *statementDisallowMixInDMLChecker) EnterAlterenumstmt(ctx *parser.AlterenumstmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ c.addDDLAdvice(ctx, "ALTER TYPE")+}++// EnterAltercompositetypestmt handles ALTER TYPE (composite) statements (DDL)+func (c *statementDisallowMixInDMLChecker) EnterAltercompositetypestmt(ctx *parser.AltercompositetypestmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ c.addDDLAdvice(ctx, "ALTER TYPE")+}++// EnterCreateextensionstmt handles CREATE EXTENSION statements (DDL)+func (c *statementDisallowMixInDMLChecker) EnterCreateextensionstmt(ctx *parser.CreateextensionstmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ c.addDDLAdvice(ctx, "CREATE EXTENSION")+}++// EnterCreatedbstmt handles CREATE DATABASE statements (DDL)+func (c *statementDisallowMixInDMLChecker) EnterCreatedbstmt(ctx *parser.CreatedbstmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ c.addDDLAdvice(ctx, "CREATE DATABASE")+}++// EnterCreatematviewstmt handles CREATE MATERIALIZED VIEW statements (DDL)+func (c *statementDisallowMixInDMLChecker) EnterCreatematviewstmt(ctx *parser.CreatematviewstmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ c.addDDLAdvice(ctx, "CREATE MATERIALIZED VIEW")+}++func (c *statementDisallowMixInDMLChecker) addDDLAdvice(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("Data change can only run DML, %q is not DML", stmtText),+ StartPosition: &storepb.Position{+ Line: int32(ctx.GetStart().GetLine()),+ Column: 0,+ },+ })+}diff --git a/backend/plugin/advisor/pgantlr/advisor_statement_disallow_on_del_cascade.go b/backend/plugin/advisor/pgantlr/advisor_statement_disallow_on_del_cascade.gonew file mode 100644index 0000000000..9541eee1ac--- /dev/null+++ b/backend/plugin/advisor/pgantlr/advisor_statement_disallow_on_del_cascade.go@@ -0,0 +1,103 @@+package pgantlr++import (+ "context"++ "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 = (*StatementDisallowOnDelCascadeAdvisor)(nil)+)++func init() {+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleStatementDisallowOnDelCascade, &StatementDisallowOnDelCascadeAdvisor{})+}++// StatementDisallowOnDelCascadeAdvisor is the advisor checking for ON DELETE CASCADE.+type StatementDisallowOnDelCascadeAdvisor struct {+}++// Check checks for ON DELETE CASCADE.+func (*StatementDisallowOnDelCascadeAdvisor) 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 := &statementDisallowOnDelCascadeChecker{+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},+ level: level,+ title: string(checkCtx.Rule.Type),+ statementsText: checkCtx.Statements,+ }++ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)++ return checker.adviceList, nil+}++type statementDisallowOnDelCascadeChecker struct {+ *parser.BasePostgreSQLParserListener++ adviceList []*storepb.Advice+ level storepb.Advice_Status+ title string+ statementsText string+}++// EnterKey_delete checks for ON DELETE CASCADE+func (c *statementDisallowOnDelCascadeChecker) EnterKey_delete(ctx *parser.Key_deleteContext) {+ // Check if this has CASCADE as the key_action+ if ctx.Key_action() != nil {+ keyAction := ctx.Key_action()+ // Check if this is CASCADE+ if keyAction.CASCADE() != nil {+ // Find the top-level statement context+ var stmtCtx antlr.ParserRuleContext+ current := ctx.GetParent()+ for current != nil {+ if isTopLevel(current) {+ if prc, ok := current.(antlr.ParserRuleContext); ok {+ stmtCtx = prc+ }+ break+ }+ current = current.GetParent()+ }++ if stmtCtx != nil {+ // Note: To match legacy pg-query behavior, we need to use GetLine() - 1+ // The legacy advisor uses pg_query's stmt_location which points to the position+ // right before the statement (often a newline), while ANTLR's GetLine() points+ // to the actual line where the statement starts. This creates an off-by-one+ // when there are statements before the CREATE TABLE.+ line := stmtCtx.GetStart().GetLine() - 1+ if line < 1 {+ line = 1+ }+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: advisor.StatementDisallowCascade.Int32(),+ Title: c.title,+ Content: "The CASCADE option is not permitted for ON DELETE clauses",+ StartPosition: common.ConvertANTLRPositionToPosition(&common.ANTLRPosition{+ Line: int32(line),+ Column: 0,+ }, c.statementsText),+ })+ }+ }+ }+}diff --git a/backend/plugin/advisor/pgantlr/advisor_statement_disallow_rm_tbl_cascade.go b/backend/plugin/advisor/pgantlr/advisor_statement_disallow_rm_tbl_cascade.gonew file mode 100644index 0000000000..0d856d8f79--- /dev/null+++ b/backend/plugin/advisor/pgantlr/advisor_statement_disallow_rm_tbl_cascade.go@@ -0,0 +1,110 @@+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 = (*StatementDisallowRemoveTblCascadeAdvisor)(nil)+)++func init() {+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleStatementDisallowRemoveTblCascade, &StatementDisallowRemoveTblCascadeAdvisor{})+}++// StatementDisallowRemoveTblCascadeAdvisor is the advisor checking for disallow CASCADE option when removing tables.+type StatementDisallowRemoveTblCascadeAdvisor struct {+}++// Check checks for CASCADE option in DROP TABLE and TRUNCATE TABLE statements.+func (*StatementDisallowRemoveTblCascadeAdvisor) 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 := &statementDisallowRemoveTblCascadeChecker{+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},+ level: level,+ title: string(checkCtx.Rule.Type),+ }++ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)++ return checker.adviceList, nil+}++type statementDisallowRemoveTblCascadeChecker struct {+ *parser.BasePostgreSQLParserListener++ adviceList []*storepb.Advice+ level storepb.Advice_Status+ title string+}++// EnterDropstmt handles DROP TABLE statements with CASCADE+func (c *statementDisallowRemoveTblCascadeChecker) 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 for CASCADE option+ if c.hasCascadeOption(ctx.Opt_drop_behavior()) {+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: advisor.StatementDisallowCascade.Int32(),+ Title: c.title,+ Content: "The use of CASCADE is not permitted when removing a table",+ StartPosition: &storepb.Position{+ Line: int32(ctx.GetStart().GetLine()),+ Column: int32(ctx.GetStart().GetColumn()),+ },+ })+ }+}++// EnterTruncatestmt handles TRUNCATE TABLE statements with CASCADE+func (c *statementDisallowRemoveTblCascadeChecker) EnterTruncatestmt(ctx *parser.TruncatestmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ // Check for CASCADE option+ if c.hasCascadeOption(ctx.Opt_drop_behavior()) {+ c.adviceList = append(c.adviceList, &storepb.Advice{+ Status: c.level,+ Code: advisor.StatementDisallowCascade.Int32(),+ Title: c.title,+ Content: "The use of CASCADE is not permitted when removing a table",+ StartPosition: &storepb.Position{+ Line: int32(ctx.GetStart().GetLine()),+ Column: int32(ctx.GetStart().GetColumn()),+ },+ })+ }+}++// hasCascadeOption checks if the drop behavior is CASCADE+func (*statementDisallowRemoveTblCascadeChecker) hasCascadeOption(ctx parser.IOpt_drop_behaviorContext) bool {+ if ctx == nil {+ return false+ }+ return ctx.CASCADE() != nil+}diff --git a/backend/plugin/advisor/pgantlr/advisor_statement_dml_dry_run.go b/backend/plugin/advisor/pgantlr/advisor_statement_dml_dry_run.gonew file mode 100644index 0000000000..9fd3a8ecc6--- /dev/null+++ b/backend/plugin/advisor/pgantlr/advisor_statement_dml_dry_run.go@@ -0,0 +1,146 @@+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 = (*StatementDMLDryRunAdvisor)(nil)+)++func init() {+ advisor.Register(storepb.Engine_POSTGRES, advisor.SchemaRuleStatementDMLDryRun, &StatementDMLDryRunAdvisor{})+}++// StatementDMLDryRunAdvisor is the advisor checking for DML dry run.+type StatementDMLDryRunAdvisor struct {+}++// Check checks for DML dry run.+func (*StatementDMLDryRunAdvisor) Check(ctx context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {+ tree, err := getANTLRTree(checkCtx)+ if err != nil {+ return nil, err+ }++ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)+ if err != nil {+ return nil, err+ }++ checker := &statementDMLDryRunChecker{+ BasePostgreSQLParserListener: &parser.BasePostgreSQLParserListener{},+ level: level,+ title: string(checkCtx.Rule.Type),+ ctx: ctx,+ driver: checkCtx.Driver,+ usePostgresDatabaseOwner: checkCtx.UsePostgresDatabaseOwner,+ statementsText: checkCtx.Statements,+ }++ // Only run EXPLAIN queries if we have a database connection+ if checker.driver != nil {+ antlr.ParseTreeWalkerDefault.Walk(checker, tree.Tree)+ }++ return checker.adviceList, nil+}++type statementDMLDryRunChecker struct {+ *parser.BasePostgreSQLParserListener++ adviceList []*storepb.Advice+ level storepb.Advice_Status+ title string+ driver *sql.DB+ ctx context.Context+ explainCount int+ setRoles []string+ usePostgresDatabaseOwner bool+ statementsText string+}++// EnterVariablesetstmt handles SET ROLE statements+func (c *statementDMLDryRunChecker) 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)+ }+ }+}++// EnterInsertstmt handles INSERT statements+func (c *statementDMLDryRunChecker) EnterInsertstmt(ctx *parser.InsertstmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ c.checkDMLDryRun(ctx)+}++// EnterUpdatestmt handles UPDATE statements+func (c *statementDMLDryRunChecker) EnterUpdatestmt(ctx *parser.UpdatestmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ c.checkDMLDryRun(ctx)+}++// EnterDeletestmt handles DELETE statements+func (c *statementDMLDryRunChecker) EnterDeletestmt(ctx *parser.DeletestmtContext) {+ if !isTopLevel(ctx.GetParent()) {+ return+ }++ c.checkDMLDryRun(ctx)+}++func (c *statementDMLDryRunChecker) checkDMLDryRun(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 perform dry run+ _, 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.StatementDMLDryRunFailed.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,+ },+ })+ }+}diff --git a/backend/plugin/advisor/pgantlr/pgantlr_test.go b/backend/plugin/advisor/pgantlr/pgantlr_test.goindex 31bcc15c7c..e06ebb844a 100644--- a/backend/plugin/advisor/pgantlr/pgantlr_test.go+++ b/backend/plugin/advisor/pgantlr/pgantlr_test.go@@ -22,37 +22,40 @@ func TestPostgreSQLANTLRRules(t *testing.T) {advisor.SchemaRuleColumnTypeDisallowList, // Migrated from legacyadvisor.SchemaRuleCommentLength, // Migrated from legacyadvisor.SchemaRuleCreateIndexConcurrently, // Migrated from legacy+ advisor.SchemaRuleFKNaming, // Migrated from legacy+ advisor.SchemaRuleFullyQualifiedObjectName, // Migrated from legacy+ advisor.SchemaRuleIDXNaming, // Migrated from legacyadvisor.SchemaRuleIndexKeyNumberLimit, // Migrated from legacyadvisor.SchemaRuleIndexNoDuplicateColumn, // Migrated from legacyadvisor.SchemaRuleIndexPrimaryKeyTypeAllowlist, // Migrated from legacyadvisor.SchemaRuleIndexTotalNumberLimit, // Migrated from legacy+ advisor.SchemaRulePKNaming, // Migrated from legacyadvisor.SchemaRuleRequiredColumn, // Migrated from legacyadvisor.SchemaRuleStatementInsertDisallowOrderByRand, // Migrated from legacyadvisor.SchemaRuleStatementInsertMustSpecifyColumn, // Migrated from legacyadvisor.SchemaRuleStatementInsertRowLimit, // Migrated from legacyadvisor.SchemaRuleColumnNaming, // Migrated from legacyadvisor.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 legacyadvisor.SchemaRuleStatementAddCheckNotValid, // Migrated from legacy+ advisor.SchemaRuleStatementAddFKNotValid, // Migrated from legacyadvisor.SchemaRuleStatementAffectedRowLimit, // Migrated from legacy+ advisor.SchemaRuleStatementCheckSetRoleVariable, // Migrated from legacy+ advisor.SchemaRuleStatementCreateSpecifySchema, // Migrated from legacyadvisor.SchemaRuleStatementDisallowAddColumnWithDefault, // Migrated from legacyadvisor.SchemaRuleStatementDisallowAddNotNull, // Migrated from legacy+ advisor.SchemaRuleStatementDisallowCommit, // Migrated from legacyadvisor.SchemaRuleStatementDisallowMixInDDL, // Migrated from legacy- // advisor.SchemaRuleTableRequirePK, // WIP - needs debugging- // Add real rules here as you migrate them from legacy pg/ folder- // Example:- // advisor.SchemaRuleStatementDisallowCommit,- // advisor.SchemaRuleStatementInsertMustSpecifyColumn,- // advisor.SchemaRuleTableNaming,- // etc.+ advisor.SchemaRuleStatementDisallowMixInDML, // Migrated from legacy+ advisor.SchemaRuleStatementDisallowOnDelCascade, // Migrated from legacy+ advisor.SchemaRuleStatementDisallowRemoveTblCascade, // Migrated from legacy+ advisor.SchemaRuleStatementDMLDryRun, // Migrated from legacy+ advisor.SchemaRuleStatementNonTransactional, // Migrated from legacy+ advisor.SchemaRuleTableCommentConvention, // Migrated from legacy+ advisor.SchemaRuleTableDisallowPartition, // Migrated from legacy+ advisor.SchemaRuleTableDropNamingConvention, // Migrated from legacy+ advisor.SchemaRuleTableNaming, // Migrated from legacy+ advisor.SchemaRuleTableNoFK, // Migrated from legacy+ advisor.SchemaRuleUKNaming, // Migrated from legacy}for _, rule := range antlrRules {@@ -63,10 +66,12 @@ func TestPostgreSQLANTLRRules(t *testing.T) {// Add SQL review type here if you need metadata for test.var advisorNeedMockData = map[advisor.SQLReviewRuleType]bool{- // advisor.SchemaRuleFullyQualifiedObjectName: true,- advisor.BuiltinRulePriorBackupCheck: true,- advisor.SchemaRuleColumnNotNull: true, // Needs metadata for PRIMARY KEY USING INDEX case- advisor.SchemaRuleIndexTotalNumberLimit: true, // Needs catalog to count indexes- advisor.SchemaRuleTableRequirePK: true, // Needs catalog for DROP CONSTRAINT/COLUMN checks- // Other advisors don't need mock data+ advisor.BuiltinRulePriorBackupCheck: true,+ advisor.SchemaRuleColumnNotNull: true, // Needs metadata for PRIMARY KEY USING INDEX case+ advisor.SchemaRuleFullyQualifiedObjectName: true, // Needs metadata for SELECT statement checks+ advisor.SchemaRuleIDXNaming: true, // Needs catalog for ALTER INDEX RENAME+ advisor.SchemaRuleIndexTotalNumberLimit: true, // Needs catalog to count indexes+ advisor.SchemaRulePKNaming: true, // Needs catalog for PRIMARY KEY USING INDEX+ advisor.SchemaRuleTableRequirePK: true, // Needs catalog for DROP CONSTRAINT/COLUMN checks+ advisor.SchemaRuleUKNaming: true, // Needs catalog for UNIQUE USING INDEX}diff --git a/backend/plugin/advisor/pgantlr/test/naming_fully_qualified.yaml b/backend/plugin/advisor/pgantlr/test/naming_fully_qualified.yamlnew file mode 100644index 0000000000..f09ac6c1b3--- /dev/null+++ b/backend/plugin/advisor/pgantlr/test/naming_fully_qualified.yaml@@ -0,0 +1,103 @@+- statement: |-+ CREATE TABLE public.pokesv1 (foo int, bar varchar);+ INSERT INTO public.pokesv1 VALUES (1, '1');+ CREATE TABLE public.pokes (foo int);+ CREATE TABLE pokesv2 (foo int, bar varchar);+ changeType: 1+ want:+ - status: 2+ code: 310+ title: naming.fully-qualified+ content: 'unqualified object name: ''pokesv2'''+ startposition:+ line: 4+ column: 0+ endposition: null+- statement: |-+ CREATE SEQUENCE public.seq;+ CREATE SEQUENCE seq;+ DROP SEQUENCE public.seq+ changeType: 1+ want:+ - status: 2+ code: 310+ title: naming.fully-qualified+ content: 'unqualified object name: ''seq'''+ startposition:+ line: 2+ column: 0+ endposition: null+- statement: |-+ CREATE TRIGGER test_trigger+ AFTER INSERT ON pokesv1+ FOR EACH ROW+ EXECUTE PROCEDURE trigger_function();+ INSERT INTO bbdev.public.pokesv1 VALUES (1, '1');+ changeType: 1+ want:+ - status: 2+ code: 310+ title: naming.fully-qualified+ content: 'unqualified object name: ''pokesv1'''+ startposition:+ line: 4+ column: 0+ endposition: null+- statement: DROP TRIGGER test_trigger ON public.pokes;+ changeType: 1+- statement: |-+ CREATE TABLE public.pokesv1 (foo int, bar varchar);+ ALTER TABLE pokesv1 RENAME TO pokesv2;+ changeType: 1+ want:+ - status: 2+ code: 310+ title: naming.fully-qualified+ content: 'unqualified object name: ''pokesv1'''+ startposition:+ line: 2+ column: 0+ endposition: null+- statement: |-+ CREATE TABLE public.pokesv1 (foo int);+ INSERT INTO pokesv1(foo) VALUES (1);+ INSERT INTO public.pokesv1 VALUES (2);+ changeType: 1+ want:+ - status: 2+ code: 310+ title: naming.fully-qualified+ content: 'unqualified object name: ''pokesv1'''+ startposition:+ line: 2+ column: 0+ endposition: null+- statement: |-+ CREATE TABLE public.pokesv1 (foo int);+ UPDATE public.pokesv1 SET foo = 1 WHERE 1=1;+ UPDATE public.pokesv1 SET foo = 2 WHERE foo=1;+ UPDATE pokesv1 SET foo = 1 WHERE 1=1;+ UPDATE public.pokesv1 SET foo = 1 WHERE 1 > 1;+ changeType: 1+ want:+ - status: 2+ code: 310+ title: naming.fully-qualified+ content: 'unqualified object name: ''pokesv1'''+ startposition:+ line: 4+ column: 0+ endposition: null+- statement: "CREATE TABLE public.pokes (foo int); \nSELECT * FROM (SELECT (id) FROM tech_book) AS foo;"+ changeType: 1+ want:+ - status: 2+ code: 310+ title: naming.fully-qualified+ content: 'unqualified object name: ''tech_book'''+ startposition:+ line: 2+ column: 0+ endposition: null+- statement: "CREATE TABLE public.pokes (foo int);\nWITH foo1 AS (SELECT * FROM public.tech_book) \nSELECT * FROM foo1;"+ changeType: 1diff --git a/backend/plugin/advisor/pgantlr/test/naming_index_fk.yaml b/backend/plugin/advisor/pgantlr/test/naming_index_fk.yamlnew file mode 100644index 0000000000..8ccacc5cb9--- /dev/null+++ b/backend/plugin/advisor/pgantlr/test/naming_index_fk.yaml@@ -0,0 +1,68 @@+- statement: ALTER TABLE tech_book ADD CONSTRAINT fk_tech_book_author_id_author_id FOREIGN KEY (author_id) REFERENCES author (id)+ changeType: 1+- statement: ALTER TABLE tech_book ADD CONSTRAINT fk_author_id FOREIGN KEY (author_id) REFERENCES author (id)+ changeType: 1+ want:+ - status: 2+ code: 305+ title: naming.index.fk+ content: Foreign key in table "tech_book" mismatches the naming convention, expect "^$|^fk_tech_book_author_id_author_id$" but found "fk_author_id"+ startposition:+ line: 1+ column: 0+ endposition: null+- statement: ALTER TABLE tech_book ADD CONSTRAINT wlwflloczhmazamdotbibvqrrzyhmvkslvyzpmlmxt FOREIGN KEY (author_id) REFERENCES author (id)+ changeType: 1+ want:+ - status: 2+ code: 305+ title: naming.index.fk+ content: Foreign key in table "tech_book" mismatches the naming convention, expect "^$|^fk_tech_book_author_id_author_id$" but found "wlwflloczhmazamdotbibvqrrzyhmvkslvyzpmlmxt"+ startposition:+ line: 1+ column: 0+ endposition: null+- statement: ALTER TABLE tech_book ADD COLUMN author_id INT CONSTRAINT fk_tech_book_author_id_author_id REFERENCES author (id)+ changeType: 1+- statement: ALTER TABLE tech_book ADD COLUMN author_id INT CONSTRAINT fk_author_id REFERENCES author (id)+ changeType: 1+ want:+ - status: 2+ code: 305+ title: naming.index.fk+ content: Foreign key in table "tech_book" mismatches the naming convention, expect "^$|^fk_tech_book_author_id_author_id$" but found "fk_author_id"+ startposition:+ line: 1+ column: 0+ endposition: null+- statement: CREATE TABLE book(id INT, author_id INT, CONSTRAINT fk_book_author_id_author_id FOREIGN KEY (author_id) REFERENCES author (id))+ changeType: 1+- statement: CREATE TABLE book(id INT, author_id INT, CONSTRAINT fk_book_author_id FOREIGN KEY (author_id) REFERENCES author (id))+ changeType: 1+ want:+ - status: 2+ code: 305+ title: naming.index.fk+ content: Foreign key in table "book" mismatches the naming convention, expect "^$|^fk_book_author_id_author_id$" but found "fk_book_author_id"+ startposition:+ line: 1+ column: 0+ endposition: null+- statement: CREATE TABLE book(id INT, author_id INT CONSTRAINT fk_book_author_id_author_id REFERENCES author (id))+ changeType: 1+- statement: |-+ -- this is the first line.+ CREATE TABLE book(+ id INT,+ author_id INT CONSTRAINT fk_book_author_id REFERENCES author (id)+ )+ changeType: 1+ want:+ - status: 2+ code: 305+ title: naming.index.fk+ content: Foreign key in table "book" mismatches the naming convention, expect "^$|^fk_book_author_id_author_id$" but found "fk_book_author_id"+ startposition:+ line: 4+ column: 0+ endposition: nulldiff --git a/backend/plugin/advisor/pgantlr/test/naming_index_idx.yaml b/backend/plugin/advisor/pgantlr/test/naming_index_idx.yamlnew file mode 100644index 0000000000..55040616e3--- /dev/null+++ b/backend/plugin/advisor/pgantlr/test/naming_index_idx.yaml@@ -0,0 +1,37 @@+- statement: CREATE INDEX idx_tech_book_id_name ON tech_book(id, name)+ changeType: 1+- statement: CREATE INDEX tech_book_id_name ON tech_book(id, name)+ changeType: 1+ want:+ - status: 2+ code: 303+ title: naming.index.idx+ content: Index in table "tech_book" mismatches the naming convention, expect "^$|^idx_tech_book_id_name$" but found "tech_book_id_name"+ startposition:+ line: 1+ column: 0+ endposition: null+- statement: CREATE INDEX wfdtqyetsyoovcvikjlyfukxyjxxxhifl ON tech_book(id, name)+ changeType: 1+ want:+ - status: 2+ code: 303+ title: naming.index.idx+ content: Index in table "tech_book" mismatches the naming convention, expect "^$|^idx_tech_book_id_name$" but found "wfdtqyetsyoovcvikjlyfukxyjxxxhifl"+ startposition:+ line: 1+ column: 0+ endposition: null+- statement: ALTER INDEX old_index RENAME TO idx_tech_book_id_name+ changeType: 1+- statement: ALTER INDEX old_index RENAME TO idx_tech_book+ changeType: 1+ want:+ - status: 2+ code: 303+ title: naming.index.idx+ content: Index in table "tech_book" mismatches the naming convention, expect "^$|^idx_tech_book_id_name$" but found "idx_tech_book"+ startposition:+ line: 1+ column: 0+ endposition: nulldiff --git a/backend/plugin/advisor/pgantlr/test/naming_index_pk.yaml b/backend/plugin/advisor/pgantlr/test/naming_index_pk.yamlnew file mode 100644index 0000000000..6e9faff391--- /dev/null+++ b/backend/plugin/advisor/pgantlr/test/naming_index_pk.yaml@@ -0,0 +1,86 @@+- statement: ALTER TABLE tech_book ADD CONSTRAINT pk_tech_book_id_name PRIMARY KEY (id, name)+ changeType: 1+- statement: ALTER TABLE tech_book ADD CONSTRAINT tech_book_id_name PRIMARY KEY (id, name)+ changeType: 1+ want:+ - status: 2+ code: 306+ title: naming.index.pk+ content: Primary key in table "tech_book" mismatches the naming convention, expect "^$|^pk_tech_book_id_name$" but found "tech_book_id_name"+ startposition:+ line: 1+ column: 0+ endposition: null+- statement: ALTER TABLE tech_book ADD CONSTRAINT udmhjtnsaablcmjhqcznfiwtnevcehcvw PRIMARY KEY (id, name)+ changeType: 1+ want:+ - status: 2+ code: 306+ title: naming.index.pk+ content: Primary key in table "tech_book" mismatches the naming convention, expect "^$|^pk_tech_book_id_name$" but found "udmhjtnsaablcmjhqcznfiwtnevcehcvw"+ startposition:+ line: 1+ column: 0+ endposition: null+- statement: CREATE TABLE book(id INT, name VARCHAR(20), CONSTRAINT pk_book_name PRIMARY KEY (name))+ changeType: 1+- statement: |-+ -- this is the first line.+ CREATE TABLE book(+ id INT,+ name VARCHAR(20),+ CONSTRAINT tech_book_name PRIMARY KEY (name)+ )+ changeType: 1+ want:+ - status: 2+ code: 306+ title: naming.index.pk+ content: Primary key in table "book" mismatches the naming convention, expect "^$|^pk_book_name$" but found "tech_book_name"+ startposition:+ line: 5+ column: 0+ endposition: null+- statement: CREATE TABLE book(id INT, name VARCHAR(20), PRIMARY KEY (name))+ changeType: 1+- statement: CREATE TABLE book(id INT, name VARCHAR(20) PRIMARY KEY)+ changeType: 1+- statement: ALTER TABLE tech_book ADD CONSTRAINT pk_tech_book_id_name PRIMARY KEY USING INDEX old_index+ changeType: 1+- statement: ALTER TABLE tech_book ADD CONSTRAINT pk_tech_book PRIMARY KEY USING INDEX old_index+ changeType: 1+ want:+ - status: 2+ code: 306+ title: naming.index.pk+ content: Primary key in table "tech_book" mismatches the naming convention, expect "^$|^pk_tech_book_id_name$" but found "pk_tech_book"+ startposition:+ line: 1+ column: 0+ endposition: null+- statement: ALTER TABLE tech_book RENAME CONSTRAINT old_pk TO pk_tech_book_id_name+ changeType: 1+- statement: ALTER TABLE tech_book RENAME CONSTRAINT old_pk TO pk_tech_book+ changeType: 1+ want:+ - status: 2+ code: 306+ title: naming.index.pk+ content: Primary key in table "tech_book" mismatches the naming convention, expect "^$|^pk_tech_book_id_name$" but found "pk_tech_book"+ startposition:+ line: 1+ column: 0+ endposition: null+- statement: ALTER INDEX old_pk RENAME TO pk_tech_book_id_name+ changeType: 1+- statement: ALTER INDEX old_pk RENAME TO pk_tech_book+ changeType: 1+ want:+ - status: 2+ code: 306+ title: naming.index.pk+ content: Primary key in table "tech_book" mismatches the naming convention, expect "^$|^pk_tech_book_id_name$" but found "pk_tech_book"+ startposition:+ line: 1+ column: 0+ endposition: nulldiff --git a/backend/plugin/advisor/pgantlr/test/naming_index_uk.yaml b/backend/plugin/advisor/pgantlr/test/naming_index_uk.yamlnew file mode 100644index 0000000000..247f5c6ac6--- /dev/null+++ b/backend/plugin/advisor/pgantlr/test/naming_index_uk.yaml@@ -0,0 +1,99 @@+- statement: CREATE UNIQUE INDEX uk_tech_book_id_name ON tech_book(id, name)+ changeType: 1+- statement: CREATE UNIQUE INDEX tech_book_id_name ON tech_book(id, name)+ changeType: 1+ want:+ - status: 2+ code: 304+ title: naming.index.uk+ content: Unique key in table "tech_book" mismatches the naming convention, expect "^$|^uk_tech_book_id_name$" but found "tech_book_id_name"+ startposition:+ line: 1+ column: 0+ endposition: null+- statement: CREATE UNIQUE INDEX dzfzqbhnkiiegdhvqjeqoevesfuwcmokrehxlapoqj ON tech_book(id, name)+ changeType: 1+ want:+ - status: 2+ code: 304+ title: naming.index.uk+ content: Unique key in table "tech_book" mismatches the naming convention, expect "^$|^uk_tech_book_id_name$" but found "dzfzqbhnkiiegdhvqjeqoevesfuwcmokrehxlapoqj"+ startposition:+ line: 1+ column: 0+ endposition: null+- statement: ALTER TABLE tech_book ADD CONSTRAINT uk_tech_book_id_name UNIQUE (id, name)+ changeType: 1+- statement: ALTER TABLE tech_book ADD CONSTRAINT tech_book_id_name UNIQUE (id, name)+ changeType: 1+ want:+ - status: 2+ code: 304+ title: naming.index.uk+ content: Unique key in table "tech_book" mismatches the naming convention, expect "^$|^uk_tech_book_id_name$" but found "tech_book_id_name"+ startposition:+ line: 1+ column: 0+ endposition: null+- statement: CREATE TABLE book(id INT PRIMARY KEY, name VARCHAR(20), CONSTRAINT uk_book_name UNIQUE (name))+ changeType: 1+- statement: |-+ -- this is the first line.+ CREATE TABLE book(+ id INT PRIMARY KEY,+ name VARCHAR(20),+ CONSTRAINT book_name UNIQUE (name)+ )+ changeType: 1+ want:+ - status: 2+ code: 304+ title: naming.index.uk+ content: Unique key in table "book" mismatches the naming convention, expect "^$|^uk_book_name$" but found "book_name"+ startposition:+ line: 5+ column: 0+ endposition: null+- statement: CREATE TABLE book(id INT PRIMARY KEY, name VARCHAR(20), UNIQUE (name))+ changeType: 1+- statement: CREATE TABLE book(id INT PRIMARY KEY, name VARCHAR(20) UNIQUE)+ changeType: 1+- statement: ALTER TABLE tech_book ADD CONSTRAINT uk_tech_book_id_name UNIQUE USING INDEX old_index+ changeType: 1+- statement: ALTER TABLE tech_book ADD CONSTRAINT uk_tech_book UNIQUE USING INDEX old_index+ changeType: 1+ want:+ - status: 2+ code: 304+ title: naming.index.uk+ content: Unique key in table "tech_book" mismatches the naming convention, expect "^$|^uk_tech_book_id_name$" but found "uk_tech_book"+ startposition:+ line: 1+ column: 0+ endposition: null+- statement: ALTER TABLE tech_book RENAME CONSTRAINT old_uk TO uk_tech_book_id_name+ changeType: 1+- statement: ALTER TABLE tech_book RENAME CONSTRAINT old_uk TO uk_tech_book+ changeType: 1+ want:+ - status: 2+ code: 304+ title: naming.index.uk+ content: Unique key in table "tech_book" mismatches the naming convention, expect "^$|^uk_tech_book_id_name$" but found "uk_tech_book"+ startposition:+ line: 1+ column: 0+ endposition: null+- statement: ALTER INDEX old_uk RENAME TO uk_tech_book_id_name+ changeType: 1+- statement: ALTER INDEX old_uk RENAME TO uk_tech_book+ changeType: 1+ want:+ - status: 2+ code: 304+ title: naming.index.uk+ content: Unique key in table "tech_book" mismatches the naming convention, expect "^$|^uk_tech_book_id_name$" but found "uk_tech_book"+ startposition:+ line: 1+ column: 0+ endposition: nulldiff --git a/backend/plugin/advisor/pgantlr/test/statement_check_set_role_variable.yaml b/backend/plugin/advisor/pgantlr/test/statement_check_set_role_variable.yamlnew file mode 100644index 0000000000..0e76beb7a9--- /dev/null+++ b/backend/plugin/advisor/pgantlr/test/statement_check_set_role_variable.yaml@@ -0,0 +1,11 @@+- statement: SET SESSION ROLE joe; SELECT * FROM t+ changeType: 1+- statement: INSERT INTO t (id) VALUES (1);+ changeType: 2+ want:+ - status: 2+ code: 217+ title: statement.check-set-role-variable+ content: No SET ROLE statement found.+ startposition: null+ endposition: nulldiff --git a/backend/plugin/advisor/pgantlr/test/statement_disallow_mix_in_dml.yaml b/backend/plugin/advisor/pgantlr/test/statement_disallow_mix_in_dml.yamlnew file mode 100644index 0000000000..3c10935ca0--- /dev/null+++ b/backend/plugin/advisor/pgantlr/test/statement_disallow_mix_in_dml.yaml@@ -0,0 +1,15 @@+- statement: DELETE FROM tech_book WHERE a > 1;+ changeType: 2+- statement: UPDATE tech_book SET id = 1;+ changeType: 2+- statement: ALTER TABLE tech_book ADD COLUMN author TEXT; UPDATE tech_book SET id = 1;DELETE FROM tech_book WHERE a > 1;+ changeType: 2+ want:+ - status: 2+ code: 227+ title: statement.disallow-mix-in-dml+ content: Data change can only run DML, "ALTER TABLE tech_book ADD COLUMN author TEXT;" is not DML+ startposition:+ line: 1+ column: 0+ endposition: nulldiff --git a/backend/plugin/advisor/pgantlr/test/statement_disallow_on_del_cascade.yaml b/backend/plugin/advisor/pgantlr/test/statement_disallow_on_del_cascade.yamlnew file mode 100644index 0000000000..c857849dd3--- /dev/null+++ b/backend/plugin/advisor/pgantlr/test/statement_disallow_on_del_cascade.yaml@@ -0,0 +1,44 @@+- statement: TRUNCATE TABLE issues CASCADE;+ changeType: 1+- statement: |-+ CREATE TABLE users (+ tenant_id integer REFERENCES tenants ON DELETE CASCADE,+ user_id integer NOT NULL,+ PRIMARY KEY (tenant_id, user_id)+ );+ changeType: 1+ want:+ - status: 2+ code: 213+ title: statement.disallow-on-del-cascade+ content: The CASCADE option is not permitted for ON DELETE clauses+ startposition:+ line: 1+ column: 1+ endposition: null+- statement: |-+ CREATE TABLE users (+ tenant_id integer,+ user_id integer NOT NULL,+ PRIMARY KEY (tenant_id, user_id)+ );+ COMMENT ON TABLE users IS 'CASCADE COMMENT';+ changeType: 1+- statement: |-+ TRUNCATE TABLE tech_book CASCADE;+ DROP TABLE tech_book CASCADE;+ CREATE TABLE users (+ tenant_id integer REFERENCES tenants ON DELETE CASCADE,+ user_id integer NOT NULL,+ PRIMARY KEY (tenant_id, user_id)+ );+ changeType: 1+ want:+ - status: 2+ code: 213+ title: statement.disallow-on-del-cascade+ content: The CASCADE option is not permitted for ON DELETE clauses+ startposition:+ line: 2+ column: 1+ endposition: nulldiff --git a/backend/plugin/advisor/pgantlr/test/statement_disallow_rm_tbl_cascade.yaml b/backend/plugin/advisor/pgantlr/test/statement_disallow_rm_tbl_cascade.yamlnew file mode 100644index 0000000000..7c4bd65518--- /dev/null+++ b/backend/plugin/advisor/pgantlr/test/statement_disallow_rm_tbl_cascade.yaml@@ -0,0 +1,52 @@+- statement: TRUNCATE TABLE issues CASCADE;+ changeType: 1+ want:+ - status: 2+ code: 213+ title: statement.disallow-rm-tbl-cascade+ content: The use of CASCADE is not permitted when removing a table+ startposition:+ line: 1+ column: 0+ endposition: null+- statement: |-+ CREATE TABLE users (+ tenant_id integer REFERENCES tenants ON DELETE CASCADE,+ user_id integer NOT NULL,+ PRIMARY KEY (tenant_id, user_id)+ );+ changeType: 1+- statement: |-+ CREATE TABLE users (+ tenant_id integer,+ user_id integer NOT NULL,+ PRIMARY KEY (tenant_id, user_id)+ );+ COMMENT ON TABLE users IS 'CASCADE COMMENT';+ changeType: 1+- statement: |-+ TRUNCATE TABLE tech_book CASCADE;+ DROP TABLE tech_book CASCADE;+ CREATE TABLE users (+ tenant_id integer REFERENCES tenants ON DELETE CASCADE,+ user_id integer NOT NULL,+ PRIMARY KEY (tenant_id, user_id)+ );+ changeType: 1+ want:+ - status: 2+ code: 213+ title: statement.disallow-rm-tbl-cascade+ content: The use of CASCADE is not permitted when removing a table+ startposition:+ line: 1+ column: 0+ endposition: null+ - status: 2+ code: 213+ title: statement.disallow-rm-tbl-cascade+ content: The use of CASCADE is not permitted when removing a table+ startposition:+ line: 2+ column: 0+ endposition: nulldiff --git a/backend/plugin/advisor/pgantlr/test/statement_dml_dry_run.yaml b/backend/plugin/advisor/pgantlr/test/statement_dml_dry_run.yamlnew file mode 100644index 0000000000..291d9d0089--- /dev/null+++ b/backend/plugin/advisor/pgantlr/test/statement_dml_dry_run.yaml@@ -0,0 +1,4 @@+- statement: INSERT INTO tech_book values(1, 'a')+ changeType: 1+- statement: DELETE FROM tech_book+ changeType: 1diff --git a/backend/plugin/advisor/pgantlr/utils.go b/backend/plugin/advisor/pgantlr/utils.goindex 1ad3db8da3..1bc5365a49 100644--- a/backend/plugin/advisor/pgantlr/utils.go+++ b/backend/plugin/advisor/pgantlr/utils.go@@ -1,6 +1,7 @@package pgantlrimport (+ "regexp""strconv""strings"@@ -118,3 +119,23 @@ func extractStatementText(statementsText string, startLine, endLine int) stringreturn strings.TrimSpace(strings.Join(stmtLines, " "))}++// getTemplateRegexp generates a regex pattern by replacing tokens in the template with actual values.+// Used by naming convention advisors to dynamically build patterns based on metadata.+func getTemplateRegexp(template string, templateList []string, tokens map[string]string) (*regexp.Regexp, error) {+ for _, key := range templateList {+ if token, ok := tokens[key]; ok {+ template = strings.ReplaceAll(template, key, token)+ }+ }++ return regexp.Compile(template)+}++// normalizeSchemaName normalizes empty schema names to "public" (PostgreSQL default schema).+func normalizeSchemaName(schemaName string) string {+ if schemaName == "" {+ return "public"+ }+ return schemaName+}