Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
refactor: remove oracle antlr parser dependency (#20483)
rebelice526b2c98a0aa
diff --git a/backend/plugin/advisor/oracle/generic_checker.go b/backend/plugin/advisor/oracle/generic_checker.goindex 3edf1a3298..d6f5b24186 100644--- a/backend/plugin/advisor/oracle/generic_checker.go+++ b/backend/plugin/advisor/oracle/generic_checker.go@@ -2,27 +2,12 @@package oracleimport (- "github.com/antlr4-go/antlr/v4""github.com/bytebase/omni/oracle/ast"- parser "github.com/bytebase/parser/plsql"storepb "github.com/bytebase/bytebase/backend/generated-go/store"plsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/plsql")-// Rule is the interface for Oracle advisor rules.-// Rules implement checking logic without embedding the parser listener.-type Rule interface {- // OnEnter is called when the parser enters a rule context.- OnEnter(ctx antlr.ParserRuleContext, nodeType string) error- // OnExit is called when the parser exits a rule context.- OnExit(ctx antlr.ParserRuleContext, nodeType string) error- // Name returns the rule name.- Name() string- // GetAdviceList returns the advice list generated by the rule.- GetAdviceList() ([]*storepb.Advice, error)-}-// BaseRule provides common functionality for Oracle advisor rules.type BaseRule struct {level storepb.Advice_Status@@ -84,163 +69,3 @@ func (r *BaseRule) rawText(loc ast.Loc) string {// OnStatement is a no-op default for rules while they are migrated to omni.func (*BaseRule) OnStatement(_ ast.Node) {}--// GenericChecker is the only type that embeds BasePlSqlParserListener.-// It dispatches parse tree events to registered rules.-type GenericChecker struct {- *parser.BasePlSqlParserListener- rules []Rule- baseLine int-}--// NewGenericChecker creates a new GenericChecker with the given rules.-func NewGenericChecker(rules []Rule) *GenericChecker {- return &GenericChecker{- BasePlSqlParserListener: &parser.BasePlSqlParserListener{},- rules: rules,- }-}--// SetBaseLine sets the base line number for error reporting.-func (g *GenericChecker) SetBaseLine(baseLine int) {- g.baseLine = baseLine-}--// GetBaseLine returns the current base line number.-func (g *GenericChecker) GetBaseLine() int {- return g.baseLine-}--// EnterEveryRule is called when the parser enters any rule context.-func (g *GenericChecker) EnterEveryRule(ctx antlr.ParserRuleContext) {- nodeType := g.getNodeType(ctx)- for _, rule := range g.rules {- _ = rule.OnEnter(ctx, nodeType)- }-}--// ExitEveryRule is called when the parser exits any rule context.-func (g *GenericChecker) ExitEveryRule(ctx antlr.ParserRuleContext) {- nodeType := g.getNodeType(ctx)- for _, rule := range g.rules {- _ = rule.OnExit(ctx, nodeType)- }-}--// GetAdviceList collects and returns all advice from all rules.-func (g *GenericChecker) GetAdviceList() ([]*storepb.Advice, error) {- var adviceList []*storepb.Advice- for _, rule := range g.rules {- list, err := rule.GetAdviceList()- if err != nil {- return nil, err- }- adviceList = append(adviceList, list...)- }- return adviceList, nil-}--// getNodeType returns the node type name for the given context.-func (*GenericChecker) getNodeType(ctx antlr.ParserRuleContext) string {- // Get the type name of the context- // For now, we'll handle the most common node types used by Oracle advisors- switch ctx.(type) {- case *parser.Create_tableContext:- return "Create_table"- case *parser.Alter_tableContext:- return "Alter_table"- case *parser.Drop_tableContext:- return "Drop_table"- case *parser.Create_indexContext:- return "Create_index"- case *parser.Create_viewContext:- return "Create_view"- case *parser.Create_materialized_viewContext:- return "Create_materialized_view"- case *parser.Drop_indexContext:- return "Drop_index"- case *parser.Insert_statementContext:- return "Insert_statement"- case *parser.Update_statementContext:- return "Update_statement"- case *parser.Delete_statementContext:- return "Delete_statement"- case *parser.Merge_statementContext:- return "Merge_statement"- case *parser.Select_statementContext:- return "Select_statement"- case *parser.Column_definitionContext:- return "Column_definition"- case *parser.Inline_constraintContext:- return "Inline_constraint"- case *parser.Out_of_line_constraintContext:- return "Out_of_line_constraint"- case *parser.Constraint_clausesContext:- return "Constraint_clauses"- case *parser.Drop_primary_key_or_unique_or_generic_clauseContext:- return "Drop_primary_key_or_unique_or_generic_clause"- case *parser.Comment_on_columnContext:- return "Comment_on_column"- case *parser.Comment_on_tableContext:- return "Comment_on_table"- case *parser.Relational_tableContext:- return "Relational_table"- case *parser.Relational_propertyContext:- return "Relational_property"- case *parser.Table_elementContext:- return "Table_element"- case *parser.Unit_statementContext:- return "Unit_statement"- case *parser.Sql_scriptContext:- return "Sql_script"- case *parser.Column_nameContext:- return "Column_name"- case *parser.Table_nameContext:- return "Table_name"- case *parser.Tableview_nameContext:- return "Tableview_name"- case *parser.IdentifierContext:- return "Identifier"- case *parser.Regular_idContext:- return "Regular_id"- case *parser.Non_reserved_keywords_pre12cContext:- return "Non_reserved_keywords_pre12c"- case *parser.Non_reserved_keywords_in_12cContext:- return "Non_reserved_keywords_in_12c"- case *parser.Data_manipulation_language_statementsContext:- return "Data_manipulation_language_statements"- case *parser.Add_column_clauseContext:- return "Add_column_clause"- case *parser.References_clauseContext:- return "References_clause"- case *parser.Modify_col_propertiesContext:- return "Modify_col_properties"- case *parser.Insert_into_clauseContext:- return "Insert_into_clause"- case *parser.Query_blockContext:- return "Query_block"- case *parser.Drop_column_clauseContext:- return "Drop_column_clause"- case *parser.DatatypeContext:- return "Datatype"- case *parser.Rename_column_clauseContext:- return "Rename_column_clause"- case *parser.Selected_listContext:- return "Selected_list"- case *parser.Id_expressionContext:- return "Id_expression"- case *parser.Table_index_clauseContext:- return "Table_index_clause"- case *parser.Alter_table_propertiesContext:- return "Alter_table_properties"- case *parser.Compound_expressionContext:- return "Compound_expression"- case *parser.Truncate_tableContext:- return "Truncate_table"- case *parser.Truncate_table_partitionContext:- return "Truncate_table_partition"- default:- // Return a generic type name if not found- return "Unknown"- }-}diff --git a/backend/plugin/advisor/oracle/generic_checker_omni.go b/backend/plugin/advisor/oracle/generic_checker_omni.goindex 0c3594cf30..e4b396d766 100644--- a/backend/plugin/advisor/oracle/generic_checker_omni.go+++ b/backend/plugin/advisor/oracle/generic_checker_omni.go@@ -1,7 +1,6 @@package oracleimport (- "github.com/antlr4-go/antlr/v4""github.com/bytebase/omni/oracle/ast"storepb "github.com/bytebase/bytebase/backend/generated-go/store"@@ -24,27 +23,6 @@ func RunOmniRules(stmts []base.ParsedStatement, rules []OmniRule) ([]*storepb.Ad}node, ok := plsqlparser.GetOmniNode(stmt.AST)if !ok {- rulesForANTLR := make([]Rule, 0, len(rules))- for _, rule := range rules {- if legacyRule, ok := rule.(Rule); ok {- rulesForANTLR = append(rulesForANTLR, legacyRule)- }- }- if len(rulesForANTLR) == 0 {- continue- }- antlrAST, ok := base.GetANTLRAST(stmt.AST)- if !ok {- continue- }- checker := NewGenericChecker(rulesForANTLR)- for _, rule := range rulesForANTLR {- if br, ok := rule.(interface{ SetStatement(int, string) }); ok {- br.SetStatement(stmt.BaseLine(), stmt.Text)- }- }- checker.SetBaseLine(stmt.BaseLine())- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)continue}for _, rule := range rules {diff --git a/backend/plugin/advisor/oracle/oracle_rules_test.go b/backend/plugin/advisor/oracle/oracle_rules_test.goindex 55512431de..9636d187c2 100644--- a/backend/plugin/advisor/oracle/oracle_rules_test.go+++ b/backend/plugin/advisor/oracle/oracle_rules_test.go@@ -3,7 +3,6 @@ package oracleimport ("context"- "reflect""testing"storepb "github.com/bytebase/bytebase/backend/generated-go/store"@@ -83,6 +82,35 @@ func TestOracleAdvisorUsesOmniWithoutANTLRFallback(t *testing.T) {advisor: &StatementWhereDisallowFunctionsAndCalculationsAdvisor{},wantCount: 1,},+ {+ name: "plsql loop nested dml",+ statement: `BEGIN+ FOR i IN 1..2 LOOP+ UPDATE tech_book SET creator = 'x' WHERE UPPER(name) = 'A';+ END LOOP;+END;`,+ rule: &storepb.SQLReviewRule{+ Type: storepb.SQLReviewRule_STATEMENT_WHERE_DISALLOW_FUNCTIONS_AND_CALCULATIONS,+ Level: storepb.SQLReviewRule_WARNING,+ },+ advisor: &StatementWhereDisallowFunctionsAndCalculationsAdvisor{},+ wantCount: 1,+ },+ {+ name: "plsql case nested dml",+ statement: `BEGIN+ CASE+ WHEN 1 = 1 THEN+ DELETE FROM tech_book WHERE ABS(id) > 5;+ END CASE;+END;`,+ rule: &storepb.SQLReviewRule{+ Type: storepb.SQLReviewRule_STATEMENT_WHERE_DISALLOW_FUNCTIONS_AND_CALCULATIONS,+ Level: storepb.SQLReviewRule_WARNING,+ },+ advisor: &StatementWhereDisallowFunctionsAndCalculationsAdvisor{},+ wantCount: 1,+ },{name: "json column type",statement: "CREATE TABLE t(a int, b JSON)",@@ -133,8 +161,7 @@ func assertOracleStmtsDidNotUseANTLRFallback(t *testing.T, stmts []base.ParsedStif stmt.AST == nil {continue}- antlrParsed := reflect.ValueOf(stmt.AST).Elem().FieldByName("antlrParsed").Bool()- if antlrParsed {+ if _, ok := base.GetANTLRAST(stmt.AST); ok {t.Fatalf("Oracle advisor used ANTLR fallback for %T", stmt.AST)}}diff --git a/backend/plugin/advisor/oracle/parser.go b/backend/plugin/advisor/oracle/parser.goindex 2b282a1997..61fa255e39 100644--- a/backend/plugin/advisor/oracle/parser.go+++ b/backend/plugin/advisor/oracle/parser.go@@ -4,68 +4,8 @@ package oracleimport ("fmt""strings"-- "github.com/antlr4-go/antlr/v4"-- "github.com/bytebase/parser/plsql")-func normalizeIdentifier(ctx antlr.ParserRuleContext, currentSchema string) string {- switch ctx := ctx.(type) {- case *plsql.IdentifierContext:- return normalizeIdentifierContext(ctx)- case *plsql.Schema_nameContext:- return normalizeIdentifierContext(ctx.Identifier())- case *plsql.Table_nameContext:- return normalizeIdentifierContext(ctx.Identifier())- case *plsql.Tableview_nameContext:- if ctx.Identifier() != nil {- result := []string{normalizeIdentifierContext(ctx.Identifier())}- if ctx.Id_expression() != nil {- result = append(result, normalizeIDExpression(ctx.Id_expression()))- }- if len(result) == 1 {- result = []string{currentSchema, result[0]}- }- return strings.Join(result, ".")- }- return ""- case *plsql.Column_nameContext:- result := []string{normalizeIdentifierContext(ctx.Identifier())}- for _, idExpression := range ctx.AllId_expression() {- result = append(result, normalizeIDExpression(idExpression))- }- return strings.Join(result, ".")- }- return ""-}--func normalizeIdentifierContext(identifier plsql.IIdentifierContext) string {- if identifier == nil {- return ""- }-- return normalizeIDExpression(identifier.Id_expression())-}--func normalizeIDExpression(idExpression plsql.IId_expressionContext) string {- if idExpression == nil {- return ""- }-- regularID := idExpression.Regular_id()- if regularID != nil {- return strings.ToUpper(regularID.GetText())- }-- delimitedID := idExpression.DELIMITED_ID()- if delimitedID != nil {- return strings.Trim(delimitedID.GetText(), "\"")- }-- return ""-}-// normalizeIdentifierName normalizes the identifier name to the format of "schema"."table"."column".// Including table name and column name.func normalizeIdentifierName(name string) string {diff --git a/backend/plugin/advisor/oracle/rule_builtin_prior_backup_check.go b/backend/plugin/advisor/oracle/rule_builtin_prior_backup_check.goindex 0e2a508c2d..a2eadc4cb1 100644--- a/backend/plugin/advisor/oracle/rule_builtin_prior_backup_check.go+++ b/backend/plugin/advisor/oracle/rule_builtin_prior_backup_check.go@@ -4,11 +4,8 @@ import ("context""fmt"- "github.com/antlr4-go/antlr/v4""github.com/bytebase/omni/oracle/ast"- "github.com/bytebase/parser/plsql"-"github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"@@ -71,8 +68,6 @@ type StatementPriorBackupCheckRule struct {ctx context.ContextcheckCtx advisor.Context- updateStatements []plsql.IUpdate_statementContext- deleteStatements []plsql.IDelete_statementContextstatementInfoList []statementInfohasDDL bool}@@ -117,34 +112,6 @@ func (r *StatementPriorBackupCheckRule) GetAdviceList() ([]*storepb.Advice, erroreturn r.BaseRule.GetAdviceList()}-// OnEnter is called when the parser enters a rule context.-func (r *StatementPriorBackupCheckRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- if nodeType == "Unit_statement" {- r.handleUnitStatement(ctx.(*plsql.Unit_statementContext))- }- return nil-}--// OnExit is called when the parser exits a rule context.-func (r *StatementPriorBackupCheckRule) OnExit(_ antlr.ParserRuleContext, nodeType string) error {- if nodeType == "Sql_script" {- r.handleSQLScriptExit()- }- return nil-}--func (r *StatementPriorBackupCheckRule) handleUnitStatement(ctx *plsql.Unit_statementContext) {- if dml := ctx.Data_manipulation_language_statements(); dml != nil {- if update := dml.Update_statement(); update != nil {- r.updateStatements = append(r.updateStatements, update)- } else if d := dml.Delete_statement(); d != nil {- r.deleteStatements = append(r.deleteStatements, d)- }- } else {- r.hasDDL = true- }-}-func (r *StatementPriorBackupCheckRule) handleSQLScriptExit() {var adviceList []*storepb.Advicediff --git a/backend/plugin/advisor/oracle/rule_column_add_not_null_column_require_default.go b/backend/plugin/advisor/oracle/rule_column_add_not_null_column_require_default.goindex 97c786c7bf..06a530ee32 100644--- a/backend/plugin/advisor/oracle/rule_column_add_not_null_column_require_default.go+++ b/backend/plugin/advisor/oracle/rule_column_add_not_null_column_require_default.go@@ -5,9 +5,7 @@ import ("context""fmt"- "github.com/antlr4-go/antlr/v4""github.com/bytebase/omni/oracle/ast"- parser "github.com/bytebase/parser/plsql""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store"@@ -44,8 +42,6 @@ type ColumnAddNotNullColumnRequireDefaultRule struct {BaseRulecurrentDatabase string- tableName string- isNotNull bool}// NewColumnAddNotNullColumnRequireDefaultRule creates a new ColumnAddNotNullColumnRequireDefaultRule.@@ -86,62 +82,3 @@ func (r *ColumnAddNotNullColumnRequireDefaultRule) OnStatement(node ast.Node) {}}}--// OnEnter is called when the parser enters a rule context.-func (r *ColumnAddNotNullColumnRequireDefaultRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Alter_table":- r.handleAlterTable(ctx.(*parser.Alter_tableContext))- case "Column_definition":- r.handleColumnDefinitionEnter(ctx.(*parser.Column_definitionContext))- case "Inline_constraint":- r.handleInlineConstraint(ctx.(*parser.Inline_constraintContext))- default:- }- return nil-}--// OnExit is called when the parser exits a rule context.-func (r *ColumnAddNotNullColumnRequireDefaultRule) OnExit(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Alter_table":- r.handleAlterTableExit()- case "Column_definition":- r.handleColumnDefinitionExit(ctx.(*parser.Column_definitionContext))- default:- }- return nil-}--func (r *ColumnAddNotNullColumnRequireDefaultRule) handleAlterTable(ctx *parser.Alter_tableContext) {- r.tableName = normalizeIdentifier(ctx.Tableview_name(), r.currentDatabase)-}--func (r *ColumnAddNotNullColumnRequireDefaultRule) handleAlterTableExit() {- r.tableName = ""-}--func (r *ColumnAddNotNullColumnRequireDefaultRule) handleInlineConstraint(ctx *parser.Inline_constraintContext) {- if ctx.NOT() != nil {- r.isNotNull = true- }-}--func (r *ColumnAddNotNullColumnRequireDefaultRule) handleColumnDefinitionEnter(_ *parser.Column_definitionContext) {- r.isNotNull = false-}--func (r *ColumnAddNotNullColumnRequireDefaultRule) handleColumnDefinitionExit(ctx *parser.Column_definitionContext) {- if r.tableName == "" || !r.isNotNull {- return- }-- if ctx.DEFAULT() == nil {- r.AddAdvice(- r.level,- code.NotNullColumnWithNoDefault.Int32(),- fmt.Sprintf("Adding not null column %q requires default.", normalizeIdentifier(ctx.Column_name(), r.currentDatabase)),- common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStart().GetLine()),- )- }-}diff --git a/backend/plugin/advisor/oracle/rule_column_comment_convention.go b/backend/plugin/advisor/oracle/rule_column_comment_convention.goindex 0a37d15763..5885807c7c 100644--- a/backend/plugin/advisor/oracle/rule_column_comment_convention.go+++ b/backend/plugin/advisor/oracle/rule_column_comment_convention.go@@ -5,15 +5,12 @@ import ("context""fmt"- "github.com/antlr4-go/antlr/v4""github.com/bytebase/omni/oracle/ast"- parser "github.com/bytebase/parser/plsql""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"- plsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/plsql")var (@@ -47,7 +44,6 @@ type ColumnCommentConventionRule struct {currentDatabase stringpayload *storepb.SQLReviewRule_CommentConventionRulePayload- tableName stringcolumnNames []stringcolumnComment map[string]stringcolumnLine map[string]int@@ -105,72 +101,6 @@ func (r *ColumnCommentConventionRule) OnStatement(node ast.Node) {}}-// OnEnter is called when the parser enters a rule context.-func (r *ColumnCommentConventionRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Create_table":- r.handleCreateTable(ctx.(*parser.Create_tableContext))- case "Column_definition":- r.handleColumnDefinition(ctx.(*parser.Column_definitionContext))- case "Alter_table":- r.handleAlterTable(ctx.(*parser.Alter_tableContext))- case "Comment_on_column":- r.handleCommentOnColumn(ctx.(*parser.Comment_on_columnContext))- default:- }- return nil-}--// OnExit is called when the parser exits a rule context.-func (r *ColumnCommentConventionRule) OnExit(_ antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Create_table":- r.handleCreateTableExit()- case "Add_column_clause":- r.handleAddColumnClauseExit()- default:- }- return nil-}--func (r *ColumnCommentConventionRule) handleCreateTable(ctx *parser.Create_tableContext) {- schemaName := r.currentDatabase- if ctx.Schema_name() != nil {- schemaName = normalizeIdentifier(ctx.Schema_name(), r.currentDatabase)- }- r.tableName = fmt.Sprintf("%s.%s", schemaName, normalizeIdentifier(ctx.Table_name(), schemaName))-}--func (r *ColumnCommentConventionRule) handleCreateTableExit() {- r.tableName = ""-}--func (r *ColumnCommentConventionRule) handleColumnDefinition(ctx *parser.Column_definitionContext) {- if r.tableName == "" {- return- }- columnName := fmt.Sprintf(`%s.%s`, r.tableName, normalizeIdentifier(ctx.Column_name(), r.currentDatabase))- r.columnNames = append(r.columnNames, columnName)- r.columnLine[columnName] = r.baseLine + ctx.GetStart().GetLine()-}--func (r *ColumnCommentConventionRule) handleAlterTable(ctx *parser.Alter_tableContext) {- r.tableName = normalizeIdentifier(ctx.Tableview_name(), r.currentDatabase)-}--func (r *ColumnCommentConventionRule) handleAddColumnClauseExit() {- r.tableName = ""-}--func (r *ColumnCommentConventionRule) handleCommentOnColumn(ctx *parser.Comment_on_columnContext) {- if ctx.Column_name() == nil {- return- }-- columnName := fmt.Sprintf(`%s.%s`, r.currentDatabase, normalizeIdentifier(ctx.Column_name(), ""))- r.columnComment[columnName] = plsqlparser.NormalizeQuotedString(ctx.Quoted_string())-}-// GetAdviceList returns the advice list.// We override this to perform final checks after all statements have been processed.func (r *ColumnCommentConventionRule) GetAdviceList() ([]*storepb.Advice, error) {diff --git a/backend/plugin/advisor/oracle/rule_column_maximum_character_length.go b/backend/plugin/advisor/oracle/rule_column_maximum_character_length.goindex 80debb4c12..73da503540 100644--- a/backend/plugin/advisor/oracle/rule_column_maximum_character_length.go+++ b/backend/plugin/advisor/oracle/rule_column_maximum_character_length.go@@ -4,13 +4,9 @@ package oracleimport ("context""fmt"- "strconv"- "github.com/pkg/errors"-- "github.com/antlr4-go/antlr/v4""github.com/bytebase/omni/oracle/ast"- parser "github.com/bytebase/parser/plsql"+ "github.com/pkg/errors""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store"@@ -95,43 +91,5 @@ func (r *ColumnMaximumCharacterLengthRule) OnStatement(node ast.Node) {}// OnEnter is called when the parser enters a rule context.-func (r *ColumnMaximumCharacterLengthRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- if nodeType == "Datatype" {- r.handleDatatype(ctx.(*parser.DatatypeContext))- }- return nil-}// OnExit is called when the parser exits a rule context.-func (*ColumnMaximumCharacterLengthRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}--func (r *ColumnMaximumCharacterLengthRule) handleDatatype(ctx *parser.DatatypeContext) {- if ctx.Native_datatype_element() == nil {- return- }-- if ctx.Native_datatype_element().CHAR() == nil && ctx.Native_datatype_element().CHARACTER() == nil {- return- }-- if ctx.Precision_part() == nil {- return- }-- if ctx.Precision_part().Numeric(0) != nil {- lengthText := ctx.Precision_part().Numeric(0).GetText()- length, err := strconv.Atoi(lengthText)- if err != nil || length <= r.maximum {- return- }- }-- r.AddAdvice(- r.level,- code.CharLengthExceedsLimit.Int32(),- fmt.Sprintf("The maximum character length is %d.", r.maximum),- common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStart().GetLine()),- )-}diff --git a/backend/plugin/advisor/oracle/rule_column_maximum_varchar_length.go b/backend/plugin/advisor/oracle/rule_column_maximum_varchar_length.goindex fdabc0774d..2afe626989 100644--- a/backend/plugin/advisor/oracle/rule_column_maximum_varchar_length.go+++ b/backend/plugin/advisor/oracle/rule_column_maximum_varchar_length.go@@ -4,13 +4,9 @@ package oracleimport ("context""fmt"- "strconv"- "github.com/pkg/errors"-- "github.com/antlr4-go/antlr/v4""github.com/bytebase/omni/oracle/ast"- parser "github.com/bytebase/parser/plsql"+ "github.com/pkg/errors""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store"@@ -95,43 +91,5 @@ func (r *ColumnMaximumVarcharLengthRule) OnStatement(node ast.Node) {}// OnEnter is called when the parser enters a rule context.-func (r *ColumnMaximumVarcharLengthRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- if nodeType == "Datatype" {- r.handleDatatype(ctx.(*parser.DatatypeContext))- }- return nil-}// OnExit is called when the parser exits a rule context.-func (*ColumnMaximumVarcharLengthRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}--func (r *ColumnMaximumVarcharLengthRule) handleDatatype(ctx *parser.DatatypeContext) {- if ctx.Native_datatype_element() == nil {- return- }-- if ctx.Native_datatype_element().VARCHAR() == nil && ctx.Native_datatype_element().VARCHAR2() == nil {- return- }-- if ctx.Precision_part() == nil {- return- }-- if ctx.Precision_part().Numeric(0) != nil {- lengthText := ctx.Precision_part().Numeric(0).GetText()- length, err := strconv.Atoi(lengthText)- if err != nil || length <= r.maximum {- return- }- }-- r.AddAdvice(- r.level,- code.VarcharLengthExceedsLimit.Int32(),- fmt.Sprintf("The maximum varchar length is %d.", r.maximum),- common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStart().GetLine()),- )-}diff --git a/backend/plugin/advisor/oracle/rule_column_no_null.go b/backend/plugin/advisor/oracle/rule_column_no_null.goindex 45357ede9b..021b5b9745 100644--- a/backend/plugin/advisor/oracle/rule_column_no_null.go+++ b/backend/plugin/advisor/oracle/rule_column_no_null.go@@ -6,9 +6,7 @@ import ("fmt""slices"- "github.com/antlr4-go/antlr/v4""github.com/bytebase/omni/oracle/ast"- parser "github.com/bytebase/parser/plsql""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store"@@ -48,8 +46,6 @@ type ColumnNoNullRule struct {currentDatabase stringnullableColumns columnMap- tableName string- columnID string}// NewColumnNoNullRule creates a new ColumnNoNullRule.@@ -110,40 +106,12 @@ func (r *ColumnNoNullRule) recordNullableColumn(tableName string, col *ast.Colum}// OnEnter is called when the parser enters a rule context.-func (r *ColumnNoNullRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Create_table":- r.handleCreateTable(ctx.(*parser.Create_tableContext))- case "Column_definition":- r.handleColumnDefinition(ctx.(*parser.Column_definitionContext))- case "Inline_constraint":- r.handleInlineConstraint(ctx.(*parser.Inline_constraintContext))- case "Out_of_line_constraint":- r.handleOutOfLineConstraint(ctx.(*parser.Out_of_line_constraintContext))- case "Alter_table":- r.handleAlterTable(ctx.(*parser.Alter_tableContext))- case "Modify_col_properties":- r.handleModifyColProperties(ctx.(*parser.Modify_col_propertiesContext))- default:- // Ignore other node types- }- return nil-}++// Ignore other node types// OnExit is called when the parser exits a rule context.-func (r *ColumnNoNullRule) OnExit(_ antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Create_table":- r.tableName = ""- case "Column_definition":- r.columnID = ""- case "Alter_table":- r.tableName = ""- default:- // Ignore other node types- }- return nil-}++// Ignore other node types// GetAdviceList returns the advice list.func (r *ColumnNoNullRule) GetAdviceList() ([]*storepb.Advice, error) {@@ -163,57 +131,3 @@ func (r *ColumnNoNullRule) GetAdviceList() ([]*storepb.Advice, error) {}return r.BaseRule.GetAdviceList()}--func (r *ColumnNoNullRule) handleCreateTable(ctx *parser.Create_tableContext) {- schemaName := r.currentDatabase- if ctx.Schema_name() != nil {- schemaName = normalizeIdentifier(ctx.Schema_name(), r.currentDatabase)- }- r.tableName = fmt.Sprintf("%s.%s", schemaName, normalizeIdentifier(ctx.Table_name(), schemaName))-}--func (r *ColumnNoNullRule) handleColumnDefinition(ctx *parser.Column_definitionContext) {- if r.tableName == "" {- return- }- columnName := normalizeIdentifier(ctx.Column_name(), r.currentDatabase)- r.columnID = fmt.Sprintf(`%s.%s`, r.tableName, columnName)- r.nullableColumns[r.columnID] = r.baseLine + ctx.GetStart().GetLine()-}--func (r *ColumnNoNullRule) handleInlineConstraint(ctx *parser.Inline_constraintContext) {- if r.columnID == "" {- return- }- if ctx.NULL_() != nil {- r.nullableColumns[r.columnID] = r.baseLine + ctx.GetStart().GetLine()- }- if ctx.NOT() != nil || ctx.PRIMARY() != nil {- delete(r.nullableColumns, r.columnID)- }-}--func (r *ColumnNoNullRule) handleOutOfLineConstraint(ctx *parser.Out_of_line_constraintContext) {- if r.tableName == "" {- return- }- if ctx.PRIMARY() != nil {- for _, column := range ctx.AllColumn_name() {- columnName := normalizeIdentifier(column, r.currentDatabase)- columnID := fmt.Sprintf(`%s.%s`, r.tableName, columnName)- delete(r.nullableColumns, columnID)- }- }-}--func (r *ColumnNoNullRule) handleAlterTable(ctx *parser.Alter_tableContext) {- r.tableName = normalizeIdentifier(ctx.Tableview_name(), r.currentDatabase)-}--func (r *ColumnNoNullRule) handleModifyColProperties(ctx *parser.Modify_col_propertiesContext) {- if r.tableName == "" {- return- }- columnName := normalizeIdentifier(ctx.Column_name(), r.currentDatabase)- r.columnID = fmt.Sprintf(`%s.%s`, r.tableName, columnName)-}diff --git a/backend/plugin/advisor/oracle/rule_column_require.go b/backend/plugin/advisor/oracle/rule_column_require.goindex a4f8b06bdc..fc647adccd 100644--- a/backend/plugin/advisor/oracle/rule_column_require.go+++ b/backend/plugin/advisor/oracle/rule_column_require.go@@ -7,11 +7,8 @@ import ("slices""strings"- "github.com/pkg/errors"-- "github.com/antlr4-go/antlr/v4""github.com/bytebase/omni/oracle/ast"- parser "github.com/bytebase/parser/plsql"+ "github.com/pkg/errors""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store"@@ -55,7 +52,6 @@ type ColumnRequireRule struct {currentDatabase stringrequiredColumns columnSet- missingColumns columnSet}// NewColumnRequireRule creates a new ColumnRequireRule.@@ -128,121 +124,9 @@ func (r *ColumnRequireRule) addMissingColumnsAdvice(tableName string, missing co}// OnEnter is called when the parser enters a rule context.-func (r *ColumnRequireRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Create_table":- r.handleCreateTableEnter(ctx.(*parser.Create_tableContext))- case "Column_definition":- r.handleColumnDefinition(ctx.(*parser.Column_definitionContext))- case "Alter_table":- r.handleAlterTableEnter(ctx.(*parser.Alter_tableContext))- case "Drop_column_clause":- r.handleDropColumnClause(ctx.(*parser.Drop_column_clauseContext))- case "Rename_column_clause":- r.handleRenameColumnClause(ctx.(*parser.Rename_column_clauseContext))- default:- // Ignore other node types- }- return nil-}--// OnExit is called when the parser exits a rule context.-func (r *ColumnRequireRule) OnExit(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Create_table":- r.handleCreateTableExit(ctx.(*parser.Create_tableContext))- case "Alter_table":- r.handleAlterTableExit(ctx.(*parser.Alter_tableContext))- default:- // Ignore other node types- }- return nil-}--func (r *ColumnRequireRule) handleCreateTableEnter(_ *parser.Create_tableContext) {- r.missingColumns = make(columnSet)- for column := range r.requiredColumns {- r.missingColumns[column] = true- }-}--func (r *ColumnRequireRule) handleCreateTableExit(ctx *parser.Create_tableContext) {- missingColumns := []string{}- for column := range r.missingColumns {- missingColumns = append(missingColumns, fmt.Sprintf("%q", column))- }- r.missingColumns = nil-- if len(missingColumns) == 0 {- return- }-- slices.Sort(missingColumns)- tableName := normalizeIdentifier(ctx.Table_name(), r.currentDatabase)- r.AddAdvice(- r.level,- code.NoRequiredColumn.Int32(),- fmt.Sprintf("Table %q requires columns: %s", tableName, strings.Join(missingColumns, ", ")),- common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStop().GetLine()),- )-}--func (r *ColumnRequireRule) handleColumnDefinition(ctx *parser.Column_definitionContext) {- if ctx.Column_name() == nil || r.missingColumns == nil {- return- }- columnName := normalizeIdentifier(ctx.Column_name(), r.currentDatabase)- delete(r.missingColumns, columnName)-}--func (r *ColumnRequireRule) handleAlterTableEnter(_ *parser.Alter_tableContext) {- r.missingColumns = make(columnSet)-}--func (r *ColumnRequireRule) handleAlterTableExit(ctx *parser.Alter_tableContext) {- missingColumns := []string{}- for column := range r.missingColumns {- missingColumns = append(missingColumns, fmt.Sprintf("%q", column))- }- r.missingColumns = nil- if len(missingColumns) == 0 {- return- }+// Ignore other node types- slices.Sort(missingColumns)- tableName := lastIdentifier(normalizeIdentifier(ctx.Tableview_name(), r.currentDatabase))- r.AddAdvice(- r.level,- code.NoRequiredColumn.Int32(),- fmt.Sprintf("Table %q requires columns: %s", tableName, strings.Join(missingColumns, ", ")),- common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStop().GetLine()),- )-}--func (r *ColumnRequireRule) handleDropColumnClause(ctx *parser.Drop_column_clauseContext) {- if r.missingColumns == nil {- return- }- for _, columnName := range ctx.AllColumn_name() {- name := normalizeIdentifier(columnName, r.currentDatabase)- if _, exists := r.requiredColumns[name]; exists {- r.missingColumns[name] = true- }- }-}--func (r *ColumnRequireRule) handleRenameColumnClause(ctx *parser.Rename_column_clauseContext) {- if r.missingColumns == nil {- return- }- oldName := normalizeIdentifier(ctx.Old_column_name().Column_name(), r.currentDatabase)- newName := normalizeIdentifier(ctx.New_column_name().Column_name(), r.currentDatabase)- if oldName == newName {- return- }+// OnExit is called when the parser exits a rule context.- if _, exists := r.requiredColumns[oldName]; exists {- r.missingColumns[oldName] = true- }-}+// Ignore other node typesdiff --git a/backend/plugin/advisor/oracle/rule_column_require_default.go b/backend/plugin/advisor/oracle/rule_column_require_default.goindex 6635d3fd59..d15f47bd2a 100644--- a/backend/plugin/advisor/oracle/rule_column_require_default.go+++ b/backend/plugin/advisor/oracle/rule_column_require_default.go@@ -6,9 +6,7 @@ import ("fmt""slices"- "github.com/antlr4-go/antlr/v4""github.com/bytebase/omni/oracle/ast"- parser "github.com/bytebase/parser/plsql""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store"@@ -46,7 +44,6 @@ type ColumnRequireDefaultRule struct {currentDatabase stringnoDefaultColumns columnMap- tableName string}// NewColumnRequireDefaultRule creates a new ColumnRequireDefaultRule.@@ -103,34 +100,12 @@ func (r *ColumnRequireDefaultRule) recordNoDefaultColumn(tableName string, col *}// OnEnter is called when the parser enters a rule context.-func (r *ColumnRequireDefaultRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Create_table":- r.handleCreateTable(ctx.(*parser.Create_tableContext))- case "Column_definition":- r.handleColumnDefinition(ctx.(*parser.Column_definitionContext))- case "Alter_table":- r.handleAlterTable(ctx.(*parser.Alter_tableContext))- case "Modify_col_properties":- r.handleModifyColProperties(ctx.(*parser.Modify_col_propertiesContext))- default:- // Ignore other node types- }- return nil-}++// Ignore other node types// OnExit is called when the parser exits a rule context.-func (r *ColumnRequireDefaultRule) OnExit(_ antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Create_table":- r.tableName = ""- case "Alter_table":- r.tableName = ""- default:- // Ignore other node types- }- return nil-}++// Ignore other node types// GetAdviceList returns the advice list.func (r *ColumnRequireDefaultRule) GetAdviceList() ([]*storepb.Advice, error) {@@ -150,39 +125,3 @@ func (r *ColumnRequireDefaultRule) GetAdviceList() ([]*storepb.Advice, error) {}return r.BaseRule.GetAdviceList()}--func (r *ColumnRequireDefaultRule) handleCreateTable(ctx *parser.Create_tableContext) {- schemaName := r.currentDatabase- if ctx.Schema_name() != nil {- schemaName = normalizeIdentifier(ctx.Schema_name(), r.currentDatabase)- }- r.tableName = fmt.Sprintf("%s.%s", schemaName, normalizeIdentifier(ctx.Table_name(), schemaName))-}--func (r *ColumnRequireDefaultRule) handleColumnDefinition(ctx *parser.Column_definitionContext) {- if r.tableName == "" {- return- }- columnName := normalizeIdentifier(ctx.Column_name(), r.currentDatabase)- columnID := fmt.Sprintf(`%s.%s`, r.tableName, columnName)- if ctx.DEFAULT() == nil {- r.noDefaultColumns[columnID] = r.baseLine + ctx.GetStart().GetLine()- } else {- delete(r.noDefaultColumns, columnID)- }-}--func (r *ColumnRequireDefaultRule) handleAlterTable(ctx *parser.Alter_tableContext) {- r.tableName = normalizeIdentifier(ctx.Tableview_name(), r.currentDatabase)-}--func (r *ColumnRequireDefaultRule) handleModifyColProperties(ctx *parser.Modify_col_propertiesContext) {- if r.tableName == "" {- return- }- columnName := normalizeIdentifier(ctx.Column_name(), r.currentDatabase)- if ctx.DEFAULT() != nil {- columnID := fmt.Sprintf(`%s.%s`, r.tableName, columnName)- delete(r.noDefaultColumns, columnID)- }-}diff --git a/backend/plugin/advisor/oracle/rule_column_type_disallow_list.go b/backend/plugin/advisor/oracle/rule_column_type_disallow_list.goindex bfbf8ae1c9..1b086fffdf 100644--- a/backend/plugin/advisor/oracle/rule_column_type_disallow_list.go+++ b/backend/plugin/advisor/oracle/rule_column_type_disallow_list.go@@ -6,15 +6,12 @@ import ("fmt""strings"- "github.com/antlr4-go/antlr/v4""github.com/bytebase/omni/oracle/ast"- parser "github.com/bytebase/parser/plsql""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"- plsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/plsql")var (@@ -88,66 +85,7 @@ func (r *ColumnTypeDisallowListRule) OnStatement(node ast.Node) {}// OnEnter is called when the parser enters a rule context.-func (r *ColumnTypeDisallowListRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Column_definition":- r.handleColumnDefinition(ctx.(*parser.Column_definitionContext))- case "Modify_col_properties":- r.handleModifyColProperties(ctx.(*parser.Modify_col_propertiesContext))- default:- // Ignore other node types- }- return nil-}--// OnExit is called when the parser exits a rule context.-func (*ColumnTypeDisallowListRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}-func (r *ColumnTypeDisallowListRule) isDisallowType(tp parser.IDatatypeContext) bool {- if tp == nil {- return false- }- for _, disallowType := range r.disallowList {- if equivalent, err := plsqlparser.EquivalentType(tp, disallowType); err == nil && equivalent {- return true- }- }- return false-}--func (r *ColumnTypeDisallowListRule) handleColumnDefinition(ctx *parser.Column_definitionContext) {- if r.isDisallowType(ctx.Datatype()) {- r.AddAdvice(- r.level,- code.DisabledColumnType.Int32(),- fmt.Sprintf("Disallow column type %s but column \"%s\" is", ctx.Datatype().GetText(), normalizeIdentifier(ctx.Column_name(), r.currentDatabase)),- common.ConvertANTLRLineToPosition(r.baseLine+ctx.Datatype().GetStart().GetLine()),- )- }- if ctx.Regular_id() != nil {- for _, tp := range r.disallowList {- if ctx.Regular_id().GetText() == tp {- r.AddAdvice(- r.level,- code.DisabledColumnType.Int32(),- fmt.Sprintf("Disallow column type %s but column \"%s\" is", ctx.Regular_id().GetText(), normalizeIdentifier(ctx.Column_name(), r.currentDatabase)),- common.ConvertANTLRLineToPosition(r.baseLine+ctx.Regular_id().GetStart().GetLine()),- )- break- }- }- }-}+// Ignore other node types-func (r *ColumnTypeDisallowListRule) handleModifyColProperties(ctx *parser.Modify_col_propertiesContext) {- if r.isDisallowType(ctx.Datatype()) {- r.AddAdvice(- r.level,- code.DisabledColumnType.Int32(),- fmt.Sprintf("Disallow column type %s but column \"%s\" is", ctx.Datatype().GetText(), normalizeIdentifier(ctx.Column_name(), r.currentDatabase)),- common.ConvertANTLRLineToPosition(r.baseLine+ctx.Datatype().GetStart().GetLine()),- )- }-}+// OnExit is called when the parser exits a rule context.diff --git a/backend/plugin/advisor/oracle/rule_index_key_number_limit.go b/backend/plugin/advisor/oracle/rule_index_key_number_limit.goindex bf626e67dd..eaaf2812b0 100644--- a/backend/plugin/advisor/oracle/rule_index_key_number_limit.go+++ b/backend/plugin/advisor/oracle/rule_index_key_number_limit.go@@ -5,11 +5,8 @@ import ("context""fmt"- "github.com/pkg/errors"-- "github.com/antlr4-go/antlr/v4""github.com/bytebase/omni/oracle/ast"- parser "github.com/bytebase/parser/plsql"+ "github.com/pkg/errors""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store"@@ -112,42 +109,5 @@ func (r *IndexKeyNumberLimitRule) checkConstraint(c *ast.TableConstraint) {}// OnEnter is called when the parser enters a rule context.-func (r *IndexKeyNumberLimitRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Table_index_clause":- r.handleTableIndexClause(ctx.(*parser.Table_index_clauseContext))- case "Out_of_line_constraint":- r.handleOutOfLineConstraint(ctx.(*parser.Out_of_line_constraintContext))- default:- }- return nil-}// OnExit is called when the parser exits a rule context.-func (*IndexKeyNumberLimitRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}--func (r *IndexKeyNumberLimitRule) handleTableIndexClause(ctx *parser.Table_index_clauseContext) {- keys := len(ctx.AllIndex_expr_option())- if keys > r.max {- r.AddAdvice(- r.level,- code.IndexKeyNumberExceedsLimit.Int32(),- fmt.Sprintf("Index key number should be less than or equal to %d", r.max),- common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStart().GetLine()),- )- }-}--func (r *IndexKeyNumberLimitRule) handleOutOfLineConstraint(ctx *parser.Out_of_line_constraintContext) {- keys := len(ctx.AllColumn_name())- if keys > r.max {- r.AddAdvice(- r.level,- code.IndexKeyNumberExceedsLimit.Int32(),- fmt.Sprintf("Index key number should be less than or equal to %d", r.max),- common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStart().GetLine()),- )- }-}diff --git a/backend/plugin/advisor/oracle/rule_insert_must_specify_column.go b/backend/plugin/advisor/oracle/rule_insert_must_specify_column.goindex 3c7cbfd701..e8e906d5ba 100644--- a/backend/plugin/advisor/oracle/rule_insert_must_specify_column.go+++ b/backend/plugin/advisor/oracle/rule_insert_must_specify_column.go@@ -4,9 +4,7 @@ package oracleimport ("context"- "github.com/antlr4-go/antlr/v4""github.com/bytebase/omni/oracle/ast"- parser "github.com/bytebase/parser/plsql""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store"@@ -62,6 +60,9 @@ func (*InsertMustSpecifyColumnRule) Name() string {func (r *InsertMustSpecifyColumnRule) OnStatement(node ast.Node) {n, ok := node.(*ast.InsertStmt)if !ok {+ if block, ok := node.(*ast.PLSQLBlock); ok {+ r.checkPLSQLBlock(block)+ }return}if n.InsertType == ast.INSERT_SINGLE && n.Columns == nil {@@ -85,26 +86,17 @@ func (r *InsertMustSpecifyColumnRule) OnStatement(node ast.Node) {}}-// OnEnter is called when the parser enters a rule context.-func (r *InsertMustSpecifyColumnRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- if nodeType == "Insert_into_clause" {- r.handleInsertIntoClause(ctx.(*parser.Insert_into_clauseContext))- }- return nil+func (r *InsertMustSpecifyColumnRule) checkPLSQLBlock(block *ast.PLSQLBlock) {+ omniWalkPLSQLBlockStatements(block, func(stmt ast.StmtNode) bool {+ insertStmt, ok := stmt.(*ast.InsertStmt)+ if !ok {+ return true+ }+ r.OnStatement(insertStmt)+ return false+ })}-// OnExit is called when the parser exits a rule context.-func (*InsertMustSpecifyColumnRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}+// OnEnter is called when the parser enters a rule context.-func (r *InsertMustSpecifyColumnRule) handleInsertIntoClause(ctx *parser.Insert_into_clauseContext) {- if ctx.Paren_column_list() == nil {- r.AddAdvice(- r.level,- code.InsertNotSpecifyColumn.Int32(),- "INSERT statement should specify column name.",- common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStart().GetLine()),- )- }-}+// OnExit is called when the parser exits a rule context.diff --git a/backend/plugin/advisor/oracle/rule_naming_identifier_case.go b/backend/plugin/advisor/oracle/rule_naming_identifier_case.goindex b73997041f..31523ad6ca 100644--- a/backend/plugin/advisor/oracle/rule_naming_identifier_case.go+++ b/backend/plugin/advisor/oracle/rule_naming_identifier_case.go@@ -6,9 +6,7 @@ import ("fmt""strings"- "github.com/antlr4-go/antlr/v4""github.com/bytebase/omni/oracle/ast"- parser "github.com/bytebase/parser/plsql""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store"@@ -87,37 +85,5 @@ func (r *NamingIdentifierCaseRule) OnStatement(node ast.Node) {}// OnEnter is called when the parser enters a rule context.-func (r *NamingIdentifierCaseRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- if nodeType == "Id_expression" {- r.handleIDExpression(ctx.(*parser.Id_expressionContext))- }- return nil-}// OnExit is called when the parser exits a rule context.-func (*NamingIdentifierCaseRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}--func (r *NamingIdentifierCaseRule) handleIDExpression(ctx *parser.Id_expressionContext) {- identifier := normalizeIDExpression(ctx)- if r.upper {- if identifier != strings.ToUpper(identifier) {- r.AddAdvice(- r.level,- code.NamingCaseMismatch.Int32(),- fmt.Sprintf("Identifier %q should be upper case", identifier),- common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStart().GetLine()),- )- }- } else {- if identifier != strings.ToLower(identifier) {- r.AddAdvice(- r.level,- code.NamingCaseMismatch.Int32(),- fmt.Sprintf("Identifier %q should be lower case", identifier),- common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStart().GetLine()),- )- }- }-}diff --git a/backend/plugin/advisor/oracle/rule_naming_identifier_no_keyword.go b/backend/plugin/advisor/oracle/rule_naming_identifier_no_keyword.goindex c733dfa7af..45de55ee65 100644--- a/backend/plugin/advisor/oracle/rule_naming_identifier_no_keyword.go+++ b/backend/plugin/advisor/oracle/rule_naming_identifier_no_keyword.go@@ -5,9 +5,7 @@ import ("context""fmt"- "github.com/antlr4-go/antlr/v4""github.com/bytebase/omni/oracle/ast"- parser "github.com/bytebase/parser/plsql""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store"@@ -75,26 +73,5 @@ func (r *NamingIdentifierNoKeywordRule) OnStatement(node ast.Node) {}// OnEnter is called when the parser enters a rule context.-func (r *NamingIdentifierNoKeywordRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- if nodeType == "Id_expression" {- r.handleIDExpression(ctx.(*parser.Id_expressionContext))- }- return nil-}// OnExit is called when the parser exits a rule context.-func (*NamingIdentifierNoKeywordRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}--func (r *NamingIdentifierNoKeywordRule) handleIDExpression(ctx *parser.Id_expressionContext) {- identifier := normalizeIDExpression(ctx)- if plsqlparser.IsOracleKeyword(identifier) {- r.AddAdvice(- r.level,- code.NameIsKeywordIdentifier.Int32(),- fmt.Sprintf("Identifier %q is a keyword and should be avoided", identifier),- common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStart().GetLine()),- )- }-}diff --git a/backend/plugin/advisor/oracle/rule_naming_table.go b/backend/plugin/advisor/oracle/rule_naming_table.goindex 4fa77c6ea8..441f67c6d1 100644--- a/backend/plugin/advisor/oracle/rule_naming_table.go+++ b/backend/plugin/advisor/oracle/rule_naming_table.go@@ -6,9 +6,7 @@ import ("fmt""regexp"- "github.com/antlr4-go/antlr/v4""github.com/bytebase/omni/oracle/ast"- parser "github.com/bytebase/parser/plsql""github.com/pkg/errors""github.com/bytebase/bytebase/backend/common"@@ -117,64 +115,5 @@ func (r *NamingTableRule) checkTableName(tableName string, loc ast.Loc) {}// OnEnter is called when the parser enters a rule context.-func (r *NamingTableRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Create_table":- r.handleCreateTable(ctx.(*parser.Create_tableContext))- case "Alter_table_properties":- r.handleAlterTableProperties(ctx.(*parser.Alter_table_propertiesContext))- default:- }- return nil-}// OnExit is called when the parser exits a rule context.-func (*NamingTableRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}--func (r *NamingTableRule) handleCreateTable(ctx *parser.Create_tableContext) {- tableName := normalizeIdentifier(ctx.Table_name(), r.currentDatabase)- if !r.format.MatchString(tableName) {- r.AddAdvice(- r.level,- code.NamingTableConventionMismatch.Int32(),- fmt.Sprintf(`"%s" mismatches table naming convention, naming format should be %q`, tableName, r.format),- common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStart().GetLine()),- )- }- if r.maxLength > 0 && len(tableName) > r.maxLength {- r.AddAdvice(- r.level,- code.NamingTableConventionMismatch.Int32(),- fmt.Sprintf("\"%s\" mismatches table naming convention, its length should be within %d characters", tableName, r.maxLength),- common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStart().GetLine()),- )- }-}--func (r *NamingTableRule) handleAlterTableProperties(ctx *parser.Alter_table_propertiesContext) {- if ctx.Tableview_name() == nil {- return- }- tableName := lastIdentifier(normalizeIdentifier(ctx.Tableview_name(), r.currentDatabase))- if tableName == "" {- return- }- if !r.format.MatchString(tableName) {- r.AddAdvice(- r.level,- code.NamingTableConventionMismatch.Int32(),- fmt.Sprintf(`"%s" mismatches table naming convention, naming format should be %q`, tableName, r.format),- common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStart().GetLine()),- )- }- if r.maxLength > 0 && len(tableName) > r.maxLength {- r.AddAdvice(- r.level,- code.NamingTableConventionMismatch.Int32(),- fmt.Sprintf("\"%s\" mismatches table naming convention, its length should be within %d characters", tableName, r.maxLength),- common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStart().GetLine()),- )- }-}diff --git a/backend/plugin/advisor/oracle/rule_naming_table_no_keyword.go b/backend/plugin/advisor/oracle/rule_naming_table_no_keyword.goindex 9e409f96bc..20cee59090 100644--- a/backend/plugin/advisor/oracle/rule_naming_table_no_keyword.go+++ b/backend/plugin/advisor/oracle/rule_naming_table_no_keyword.go@@ -5,9 +5,7 @@ import ("context""fmt"- "github.com/antlr4-go/antlr/v4""github.com/bytebase/omni/oracle/ast"- parser "github.com/bytebase/parser/plsql""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store"@@ -87,45 +85,5 @@ func (r *NamingTableNoKeywordRule) checkTableName(tableName string, loc ast.Loc)}// OnEnter is called when the parser enters a rule context.-func (r *NamingTableNoKeywordRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Create_table":- r.handleCreateTable(ctx.(*parser.Create_tableContext))- case "Alter_table_properties":- r.handleAlterTableProperties(ctx.(*parser.Alter_table_propertiesContext))- default:- }- return nil-}// OnExit is called when the parser exits a rule context.-func (*NamingTableNoKeywordRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}--func (r *NamingTableNoKeywordRule) handleCreateTable(ctx *parser.Create_tableContext) {- tableName := normalizeIdentifier(ctx.Table_name(), r.currentDatabase)- if plsqlparser.IsOracleKeyword(tableName) {- r.AddAdvice(- r.level,- code.NameIsKeywordIdentifier.Int32(),- fmt.Sprintf("Table name %q is a keyword identifier and should be avoided.", tableName),- common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStart().GetLine()),- )- }-}--func (r *NamingTableNoKeywordRule) handleAlterTableProperties(ctx *parser.Alter_table_propertiesContext) {- if ctx.Tableview_name() == nil {- return- }- tableName := lastIdentifier(normalizeIdentifier(ctx.Tableview_name(), r.currentDatabase))- if plsqlparser.IsOracleKeyword(tableName) {- r.AddAdvice(- r.level,- code.NameIsKeywordIdentifier.Int32(),- fmt.Sprintf("Table name %q is a keyword identifier and should be avoided.", tableName),- common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStart().GetLine()),- )- }-}diff --git a/backend/plugin/advisor/oracle/rule_select_no_select_all.go b/backend/plugin/advisor/oracle/rule_select_no_select_all.goindex cbbdc7baaf..c65f5048b1 100644--- a/backend/plugin/advisor/oracle/rule_select_no_select_all.go+++ b/backend/plugin/advisor/oracle/rule_select_no_select_all.go@@ -4,9 +4,7 @@ package oracleimport ("context"- "github.com/antlr4-go/antlr/v4""github.com/bytebase/omni/oracle/ast"- parser "github.com/bytebase/parser/plsql""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store"@@ -78,25 +76,5 @@ func (r *SelectNoSelectAllRule) OnStatement(node ast.Node) {}// OnEnter is called when the parser enters a rule context.-func (r *SelectNoSelectAllRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- if nodeType == "Selected_list" {- r.handleSelectedList(ctx.(*parser.Selected_listContext))- }- return nil-}// OnExit is called when the parser exits a rule context.-func (*SelectNoSelectAllRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}--func (r *SelectNoSelectAllRule) handleSelectedList(ctx *parser.Selected_listContext) {- if ctx.ASTERISK() != nil {- r.AddAdvice(- r.level,- code.StatementSelectAll.Int32(),- "Avoid using SELECT *.",- common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStart().GetLine()),- )- }-}diff --git a/backend/plugin/advisor/oracle/rule_statement_disallow_truncate.go b/backend/plugin/advisor/oracle/rule_statement_disallow_truncate.goindex e10e3b8d21..b08d7a4576 100644--- a/backend/plugin/advisor/oracle/rule_statement_disallow_truncate.go+++ b/backend/plugin/advisor/oracle/rule_statement_disallow_truncate.go@@ -5,9 +5,7 @@ import ("fmt""strings"- "github.com/antlr4-go/antlr/v4""github.com/bytebase/omni/oracle/ast"- parser "github.com/bytebase/parser/plsql""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store"@@ -113,57 +111,9 @@ func (r *StatementDisallowTruncateRule) OnStatement(node ast.Node) {}}-func (r *StatementDisallowTruncateRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Truncate_table":- tc, ok := ctx.(*parser.Truncate_tableContext)- if !ok {- return nil- }- name := ""- if tv := tc.Tableview_name(); tv != nil {- name = tv.GetText()- }- r.AddAdvice(- r.level,- code.StatementDisallowTruncate.Int32(),- fmt.Sprintf(`TRUNCATE TABLE %q is not allowed: it issues an implicit COMMIT and cannot be rolled back. Any prior uncommitted work in the same transaction is also committed. Prior-backup treats this as DDL and does not produce row-level snapshots.`, name),- common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStart().GetLine()),- )- case "Truncate_table_partition":- pc, ok := ctx.(*parser.Truncate_table_partitionContext)- if !ok {- return nil- }- table := oracleEnclosingAlterTable(pc)- keyword, target := oracleExtractTruncatePartitionTarget(pc)- r.AddAdvice(- r.level,- code.StatementDisallowTruncate.Int32(),- fmt.Sprintf(`ALTER TABLE %q TRUNCATE %s %q is not allowed: partition truncate shares the implicit-commit gap of TRUNCATE TABLE on Oracle. Prior-backup treats this as DDL and does not produce row-level snapshots.`, table, keyword, target),- common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStart().GetLine()),- )- default:- }- return nil-}--func (*StatementDisallowTruncateRule) OnExit(_ antlr.ParserRuleContext, _ string) error { return nil }-// oracleEnclosingAlterTable walks up from a child context to the enclosing// Alter_table and returns its Tableview_name text. Returns "" if the parent// chain is absent (should not happen for a well-formed AST).-func oracleEnclosingAlterTable(ctx antlr.ParserRuleContext) string {- for p := ctx.GetParent(); p != nil; p = p.GetParent() {- if at, ok := p.(*parser.Alter_tableContext); ok {- if tv := at.Tableview_name(); tv != nil {- return tv.GetText()- }- return ""- }- }- return ""-}// oracleExtractTruncatePartitionTarget returns ("PARTITION"|"SUBPARTITION",// name) for a Truncate_table_partition context. For the `FOR (value)` form,@@ -171,51 +121,7 @@ func oracleEnclosingAlterTable(ctx antlr.ParserRuleContext) string {// names are joined with `, ` into a single advice target; the single-advice// shape matches a single AST node and the grammar treats the whole list as// one truncate command.-func oracleExtractTruncatePartitionTarget(ctx *parser.Truncate_table_partitionContext) (keyword, target string) {- if pen := ctx.Partition_extended_names(); pen != nil {- if c, ok := pen.(*parser.Partition_extended_namesContext); ok {- return "PARTITION", oraclePartitionNames(c.AllPartition_name(), c.FOR() != nil, partitionKeyValueTexts(c))- }- }- if sen := ctx.Subpartition_extended_names(); sen != nil {- if c, ok := sen.(*parser.Subpartition_extended_namesContext); ok {- return "SUBPARTITION", oraclePartitionNames(c.AllPartition_name(), c.FOR() != nil, subpartitionKeyValueTexts(c))- }- }- return "PARTITION", ""-}// oraclePartitionNames renders the target string for either partition- or// subpartition-extended names. Prefers explicit identifier names; falls back// to FOR(value) literal when the grammar took the FOR branch.-func oraclePartitionNames(names []parser.IPartition_nameContext, isFor bool, forValues []string) string {- if len(names) > 0 {- parts := make([]string, 0, len(names))- for _, pn := range names {- parts = append(parts, pn.GetText())- }- return strings.Join(parts, ", ")- }- if isFor && len(forValues) > 0 {- return "FOR(" + strings.Join(forValues, ", ") + ")"- }- return ""-}--func partitionKeyValueTexts(c *parser.Partition_extended_namesContext) []string {- vals := c.AllPartition_key_value()- out := make([]string, 0, len(vals))- for _, v := range vals {- out = append(out, v.GetText())- }- return out-}--func subpartitionKeyValueTexts(c *parser.Subpartition_extended_namesContext) []string {- vals := c.AllSubpartition_key_value()- out := make([]string, 0, len(vals))- for _, v := range vals {- out = append(out, v.GetText())- }- return out-}diff --git a/backend/plugin/advisor/oracle/rule_statement_dml_dry_run.go b/backend/plugin/advisor/oracle/rule_statement_dml_dry_run.goindex 5e92e84368..35fa535270 100644--- a/backend/plugin/advisor/oracle/rule_statement_dml_dry_run.go+++ b/backend/plugin/advisor/oracle/rule_statement_dml_dry_run.go@@ -5,16 +5,12 @@ import ("database/sql""fmt"- "github.com/antlr4-go/antlr/v4""github.com/bytebase/omni/oracle/ast"- parser "github.com/bytebase/parser/plsql"-"github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"- "github.com/bytebase/bytebase/backend/plugin/parser/plsql")var (@@ -82,49 +78,8 @@ func (r *StatementDmlDryRunRule) OnStatement(node ast.Node) {}// OnEnter is called when the parser enters a rule context.-func (r *StatementDmlDryRunRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Insert_statement":- r.handleInsertStatement(ctx.(*parser.Insert_statementContext))- case "Update_statement":- r.handleUpdateStatement(ctx.(*parser.Update_statementContext))- case "Delete_statement":- r.handleDeleteStatement(ctx.(*parser.Delete_statementContext))- case "Merge_statement":- r.handleMergeStatement(ctx.(*parser.Merge_statementContext))- default:- }- return nil-}// OnExit is called when the parser exits a rule context.-func (*StatementDmlDryRunRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}--func (r *StatementDmlDryRunRule) handleInsertStatement(ctx *parser.Insert_statementContext) {- if plsql.IsTopLevelStatement(ctx.GetParent()) {- r.handleStmt(ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx), r.baseLine+ctx.GetStart().GetLine())- }-}--func (r *StatementDmlDryRunRule) handleUpdateStatement(ctx *parser.Update_statementContext) {- if plsql.IsTopLevelStatement(ctx.GetParent()) {- r.handleStmt(ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx), r.baseLine+ctx.GetStart().GetLine())- }-}--func (r *StatementDmlDryRunRule) handleDeleteStatement(ctx *parser.Delete_statementContext) {- if plsql.IsTopLevelStatement(ctx.GetParent()) {- r.handleStmt(ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx), r.baseLine+ctx.GetStart().GetLine())- }-}--func (r *StatementDmlDryRunRule) handleMergeStatement(ctx *parser.Merge_statementContext) {- if plsql.IsTopLevelStatement(ctx.GetParent()) {- r.handleStmt(ctx.GetParser().GetTokenStream().GetTextFromRuleContext(ctx), r.baseLine+ctx.GetStart().GetLine())- }-}func (r *StatementDmlDryRunRule) handleStmt(text string, lineNumber int) {if r.explainCount >= common.MaximumLintExplainSize {diff --git a/backend/plugin/advisor/oracle/rule_statement_where_disallow_functions_and_calculations.go b/backend/plugin/advisor/oracle/rule_statement_where_disallow_functions_and_calculations.goindex 0d05014942..f13fa02d6d 100644--- a/backend/plugin/advisor/oracle/rule_statement_where_disallow_functions_and_calculations.go+++ b/backend/plugin/advisor/oracle/rule_statement_where_disallow_functions_and_calculations.go@@ -6,15 +6,12 @@ import ("fmt""strings"- "github.com/antlr4-go/antlr/v4""github.com/bytebase/omni/oracle/ast"- parser "github.com/bytebase/parser/plsql""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"- plsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/plsql""github.com/bytebase/bytebase/backend/store/model")@@ -65,15 +62,9 @@ type tablesByAlias = map[string]tableReftype indexedByAlias = map[string]map[string]booltype scopeIndexed struct {- local indexedByAlias- localAll indexedByAlias- localAliases map[string]bool- outer indexedByAlias- localUnresolved bool-}--func (s scopeIndexed) empty() bool {- return len(s.local) == 0 && len(s.outer) == 0+ local indexedByAlias+ localAll indexedByAlias+ localAliases map[string]bool}// WhereDisallowFunctionsAndCalculationsRule is the rule implementation.@@ -83,7 +74,6 @@ type WhereDisallowFunctionsAndCalculationsRule struct {currentDatabase stringdbMetadata *model.DatabaseMetadataisObjectCaseSensitive bool- depth int// cteStack mirrors the PG rule's CTE-shadowing handling. Pushed when// entering a Query_block with a Subquery_factoring_clause; popped on// exit. A FROM tableview_name matching any stacked entry is recorded@@ -220,8 +210,24 @@ func (r *WhereDisallowFunctionsAndCalculationsRule) OnStatement(node ast.Node) {r.checkOmniSelect(selectStmt, nil)}case *ast.PLSQLBlock:- r.runLegacyCurrentStatement()+ r.checkOmniPLSQLBlock(n)+ default:+ }+}++func (r *WhereDisallowFunctionsAndCalculationsRule) checkOmniPLSQLBlock(block *ast.PLSQLBlock) {+ omniWalkPLSQLBlockStatements(block, func(stmt ast.StmtNode) bool {+ return !r.checkOmniPLSQLQueryStatement(stmt)+ })+}++func (r *WhereDisallowFunctionsAndCalculationsRule) checkOmniPLSQLQueryStatement(stmt ast.StmtNode) bool {+ switch stmt.(type) {+ case *ast.SelectStmt, *ast.UpdateStmt, *ast.DeleteStmt, *ast.InsertStmt, *ast.MergeStmt, *ast.CreateTableStmt, *ast.CreateViewStmt:+ r.OnStatement(stmt)+ return truedefault:+ return false}}@@ -265,22 +271,6 @@ func (r *WhereDisallowFunctionsAndCalculationsRule) checkOmniNestedSubqueries(no})}-func (r *WhereDisallowFunctionsAndCalculationsRule) runLegacyCurrentStatement() {- if r.stmtText == "" {- return- }- asts, err := plsqlparser.ParsePLSQL(r.stmtText)- if err != nil {- return- }- checker := NewGenericChecker([]Rule{r})- checker.SetBaseLine(r.baseLine)- r.SetBaseLine(r.baseLine)- for _, antlrAST := range asts {- antlr.ParseTreeWalkerDefault.Walk(checker, antlrAST.Tree)- }-}-func oracleTableRefFromObjectName(name *ast.ObjectName) tableRef {if name == nil {return tableRef{}@@ -612,76 +602,10 @@ func (r *WhereDisallowFunctionsAndCalculationsRule) hasOmniAdvice(content string// dispatch context nests another (e.g. Insert_statement contains a// Select_statement source). The handler is called only when this is the// outermost matching context (depth == 1 after increment).-func (r *WhereDisallowFunctionsAndCalculationsRule) OnEnter(ctx antlr.ParserRuleContext, _ string) error {- // Defensive reset: at the root of a freshly-walked tree, parent is nil.- if ctx.GetParent() == nil {- r.depth = 0- }- shouldDispatch := r.depth == 0- switch c := ctx.(type) {- case *parser.Select_statementContext:- r.depth++- if shouldDispatch {- r.onSelectStmt(c)- }- case *parser.Update_statementContext:- r.depth++- if shouldDispatch {- r.onUpdateStmt(c)- }- case *parser.Delete_statementContext:- r.depth++- if shouldDispatch {- r.onDeleteStmt(c)- }- case *parser.Insert_statementContext:- r.depth++- if shouldDispatch {- r.onInsertStmt(c)- }- case *parser.Merge_statementContext:- r.depth++- if shouldDispatch {- r.onMergeStmt(c)- }- case *parser.Create_tableContext:- r.depth++- if shouldDispatch {- r.onCreateTable(c)- }- case *parser.Create_viewContext:- r.depth++- if shouldDispatch {- r.onCreateView(c)- }- case *parser.Create_materialized_viewContext:- r.depth++- if shouldDispatch {- r.onCreateMaterializedView(c)- }- default:- }- return nil-}++// Defensive reset: at the root of a freshly-walked tree, parent is nil.// OnExit pops depth for the dispatch contexts pushed in OnEnter.-func (r *WhereDisallowFunctionsAndCalculationsRule) OnExit(ctx antlr.ParserRuleContext, _ string) error {- switch ctx.(type) {- case *parser.Select_statementContext,- *parser.Update_statementContext,- *parser.Delete_statementContext,- *parser.Insert_statementContext,- *parser.Merge_statementContext,- *parser.Create_tableContext,- *parser.Create_viewContext,- *parser.Create_materialized_viewContext:- if r.depth > 0 {- r.depth--- }- default:- }- return nil-}// ---- Identifier / metadata helpers ---------------------------------------@@ -716,18 +640,6 @@ func (r *WhereDisallowFunctionsAndCalculationsRule) normalizeIdent(name string)}// idExprText returns the canonical lookup key for an Id_expression context.-func (r *WhereDisallowFunctionsAndCalculationsRule) idExprText(ctx parser.IId_expressionContext) string {- if ctx == nil {- return ""- }- if reg := ctx.Regular_id(); reg != nil {- return r.normalizeIdent(reg.GetText())- }- if d := ctx.DELIMITED_ID(); d != nil {- return r.normalizeIdent(d.GetText())- }- return r.normalizeIdent(ctx.GetText())-}// tableMetadata fetches the store-model table for the given ref.//@@ -819,180 +731,39 @@ func (r *WhereDisallowFunctionsAndCalculationsRule) resolveAllColumns(tables tab// Derived tables and CTE references (when they can't be resolved to a real// table) are recorded as empty tableRef{} placeholders so qualified refs can// still be routed via alias lookup.-func (r *WhereDisallowFunctionsAndCalculationsRule) collectTableNamesFromFrom(from parser.IFrom_clauseContext) tablesByAlias {- tables := make(tablesByAlias)- if from == nil {- return tables- }- list := from.Table_ref_list()- if list == nil {- return tables- }- for _, tref := range list.AllTable_ref() {- r.collectTableNamesFromTableRef(tref, tables)- }- return tables-}-func (r *WhereDisallowFunctionsAndCalculationsRule) collectTableNamesFromTableRef(tref parser.ITable_refContext, tables tablesByAlias) {- if tref == nil {- return- }- if aux := tref.Table_ref_aux(); aux != nil {- r.collectTableNamesFromTableRefAux(aux, tables)- }- for _, jc := range tref.AllJoin_clause() {- if jc == nil {- continue- }- if aux := jc.Table_ref_aux(); aux != nil {- r.collectTableNamesFromTableRefAux(aux, tables)- }- }-}+// dml_table_expression_clause [pivot/unpivot]-func (r *WhereDisallowFunctionsAndCalculationsRule) collectTableNamesFromTableRefAux(aux parser.ITable_ref_auxContext, tables tablesByAlias) {- if aux == nil {- return- }- internal := aux.Table_ref_aux_internal()- alias := ""- if ta := aux.Table_alias(); ta != nil {- alias = r.tableAliasText(ta)- }- switch c := internal.(type) {- case *parser.Table_ref_aux_internal_oneContext:- // dml_table_expression_clause [pivot/unpivot]- if dte := c.Dml_table_expression_clause(); dte != nil {- r.collectTableNamesFromDml(dte, alias, tables)- }- case *parser.Table_ref_aux_internal_twoContext:- // ( table_ref ) [subquery_operation_part]*- // If the inner table_ref is a single base table (no joins, no- // subquery), the outer alias points DIRECTLY to that table —- // `FROM (orders) o` is equivalent to `FROM orders o`. Recording- // the alias as opaque would erase the indexes and miss real- // violations on `o.indexed_col`. Otherwise (joins / derived- // tables / subquery_operation_part), the alias spans multiple- // or unknown sources and must stay opaque.- if inner := c.Table_ref(); inner != nil {- if dte := singleBaseTableInRef(inner); dte != nil {- r.collectTableNamesFromDml(dte, alias, tables)- } else {- if alias != "" {- key := r.normalizeIdent(alias)- if _, ok := tables[key]; !ok {- tables[key] = tableRef{}- }- }- r.collectTableNamesFromTableRef(inner, tables)- }- } else if alias != "" {- key := r.normalizeIdent(alias)- if _, ok := tables[key]; !ok {- tables[key] = tableRef{}- }- }- case *parser.Table_ref_aux_internal_threeContext:- // ONLY ( dml_table_expression_clause )- if dte := c.Dml_table_expression_clause(); dte != nil {- r.collectTableNamesFromDml(dte, alias, tables)- }- default:- }-}+// ( table_ref ) [subquery_operation_part]*+// If the inner table_ref is a single base table (no joins, no+// subquery), the outer alias points DIRECTLY to that table —+// `FROM (orders) o` is equivalent to `FROM orders o`. Recording+// the alias as opaque would erase the indexes and miss real+// violations on `o.indexed_col`. Otherwise (joins / derived+// tables / subquery_operation_part), the alias spans multiple+// or unknown sources and must stay opaque.++// ONLY ( dml_table_expression_clause )// collectTableNamesFromDml records a dml_table_expression_clause (a table or// a parenthesised SELECT) under the given alias (empty = use table name).-func (r *WhereDisallowFunctionsAndCalculationsRule) collectTableNamesFromDml(- dte parser.IDml_table_expression_clauseContext,- alias string,- tables tablesByAlias,-) {- dteCtx := dte- if tvn := dteCtx.Tableview_name(); tvn != nil {- schema, name := r.splitTableviewName(tvn)- key := alias- if key == "" {- key = name- }- normKey := r.normalizeIdent(key)- // CTE shadowing: an unqualified tableview matching a WITH-factoring- // name binds to the CTE result, not the physical table.- if schema == "" && r.cteVisible(name) {- tables[normKey] = tableRef{}- return- }- ref := tableRef{schema: schema, name: name}- if existing, ok := tables[normKey]; ok && (existing.schema != ref.schema || existing.name != ref.name) {- tables[normKey] = tableRef{}- } else {- tables[normKey] = ref- }- return- }- // A nested SELECT inside the dml-table-expression-clause (derived table).- if dteCtx.Select_statement() != nil {- key := r.normalizeIdent(alias)- if key != "" {- if _, ok := tables[key]; !ok {- tables[key] = tableRef{}- }- }- }-}++// CTE shadowing: an unqualified tableview matching a WITH-factoring+// name binds to the CTE result, not the physical table.++// A nested SELECT inside the dml-table-expression-clause (derived table).// splitTableviewName returns (schema, name) from a Tableview_name context.-func (r *WhereDisallowFunctionsAndCalculationsRule) splitTableviewName(tvn parser.ITableview_nameContext) (string, string) {- if tvn == nil {- return "", ""- }- first := ""- if id := tvn.Identifier(); id != nil {- first = r.idExprText(id.Id_expression())- }- if idExpr := tvn.Id_expression(); idExpr != nil {- return first, r.idExprText(idExpr)- }- return "", first-}// tableAliasText returns the canonical alias string from a Table_alias.-func (r *WhereDisallowFunctionsAndCalculationsRule) tableAliasText(ta parser.ITable_aliasContext) string {- if ta == nil {- return ""- }- if id := ta.Identifier(); id != nil {- return r.idExprText(id.Id_expression())- }- if q := ta.Quoted_string(); q != nil {- text := strings.Trim(q.GetText(), "'\"")- return r.normalizeIdent(text)- }- return ""-}// localHasUnresolvedSources reports whether any FROM entry hides columns we// cannot enumerate (derived tables or tables without metadata).-func (r *WhereDisallowFunctionsAndCalculationsRule) localHasUnresolvedSources(from parser.IFrom_clauseContext, local tablesByAlias) bool {- if from != nil {- // If the FROM subtree contains a Subquery (derived table), sources are unresolved.- if containsDerivedTable(from) {- return true- }- }- for _, ref := range local {- if ref == (tableRef{}) {- // Opaque alias (CTE-shadowed tableview, derived source, etc.) —- // columns can't be enumerated, so the local scope is unresolved.- return true- }- if r.tableMetadata(ref) == nil {- return true- }- }- return false-}++// If the FROM subtree contains a Subquery (derived table), sources are unresolved.++// Opaque alias (CTE-shadowed tableview, derived source, etc.) —+// columns can't be enumerated, so the local scope is unresolved.// singleBaseTableInRef returns the inner Dml_table_expression_clause iff the// given Table_ref reduces to a single base table — no joins, no subquery@@ -1000,29 +771,8 @@ func (r *WhereDisallowFunctionsAndCalculationsRule) localHasUnresolvedSources(fr// (e.g. `((orders))`). Returns nil otherwise. Used to propagate the outer// alias of `FROM (orders) o` directly to the underlying table so indexes// resolve via `o.indexed_col`.-func singleBaseTableInRef(tr parser.ITable_refContext) parser.IDml_table_expression_clauseContext {- if tr == nil {- return nil- }- if joins := tr.AllJoin_clause(); len(joins) > 0 {- return nil- }- aux := tr.Table_ref_aux()- if aux == nil {- return nil- }- switch internal := aux.Table_ref_aux_internal().(type) {- case *parser.Table_ref_aux_internal_oneContext:- if dte := internal.Dml_table_expression_clause(); dte != nil && dte.Tableview_name() != nil {- return dte- }- return nil- case *parser.Table_ref_aux_internal_twoContext:- // Recurse — `((orders))` is still a single base table.- return singleBaseTableInRef(internal.Table_ref())- }- return nil-}++// Recurse — `((orders))` is still a single base table.// containsDerivedTable reports whether any FROM-clause node introduces a// derived table. Only SOURCE positions are inspected — Join_on_part subtrees@@ -1031,25 +781,6 @@ func singleBaseTableInRef(tr parser.ITable_refContext) parser.IDml_table_express// localUnresolved=true on the enclosing query and suppresses the outer-scope// fallback in isIndexedColumn, masking real correlated-ref violations.// Mirrors PG's hasOpaqueSource. See spec §3 "Unresolved FROM-item inventory".-func containsDerivedTable(node antlr.Tree) bool {- if node == nil {- return false- }- if _, ok := node.(*parser.Join_on_partContext); ok {- return false- }- if n, ok := node.(*parser.Table_ref_aux_internal_oneContext); ok {- if dte, ok := n.Dml_table_expression_clause().(*parser.Dml_table_expression_clauseContext); ok && dte != nil && dte.Select_statement() != nil {- return true- }- }- for i := 0; i < node.GetChildCount(); i++ {- if containsDerivedTable(node.GetChild(i)) {- return true- }- }- return false-}// elementReferencesName reports whether a factoring element is recursive —// i.e. its body is a UNION ALL composition AND at least one branch@@ -1069,55 +800,9 @@ func containsDerivedTable(node antlr.Tree) bool {// schema qualifier and its normalized name equals `name`. Nested derived// tables (dte with its own Select_statement) are opaque — their inner// FROMs belong to a different scope and must not trigger a false match.-func (r *WhereDisallowFunctionsAndCalculationsRule) elementReferencesName(sub parser.ISubqueryContext, name string) bool {- if sub == nil || name == "" {- return false- }- parts := sub.AllSubquery_operation_part()- if len(parts) == 0 {- return false- }- hasUnionAll := false- for _, p := range parts {- if p == nil {- continue- }- if p.UNION() != nil && p.ALL() != nil {- hasUnionAll = true- break- }- }- if !hasUnionAll {- return false- }- return r.treeReferencesName(sub, name)-}-func (r *WhereDisallowFunctionsAndCalculationsRule) treeReferencesName(node antlr.Tree, name string) bool {- if node == nil {- return false- }- if dte, ok := node.(*parser.Dml_table_expression_clauseContext); ok && dte != nil {- // Derived table: its inner SELECT is an opaque nested scope — do NOT- // descend. Its own Tableview_name IS in the element's FROM scope.- if dte.Select_statement() != nil {- return false- }- if tvn := dte.Tableview_name(); tvn != nil {- schema, tname := r.splitTableviewName(tvn)- if schema == "" && r.normalizeIdent(tname) == name {- return true- }- return false- }- }- for i := 0; i < node.GetChildCount(); i++ {- if r.treeReferencesName(node.GetChild(i), name) {- return true- }- }- return false-}+// Derived table: its inner SELECT is an opaque nested scope — do NOT+// descend. Its own Tableview_name IS in the element's FROM scope.// ---- Column reference resolution -----------------------------------------@@ -1125,1061 +810,234 @@ func (r *WhereDisallowFunctionsAndCalculationsRule) treeReferencesName(node antl// general_element is a plain column reference (no function arguments on any// part). Returns ("", "") when the ref is a function call or otherwise not a// column.-func (r *WhereDisallowFunctionsAndCalculationsRule) extractColumnRefFromGeneralElement(ge parser.IGeneral_elementContext) (string, string) {- if ge == nil {- return "", ""- }- parts := ge.AllGeneral_element_part()- if len(parts) == 0 {- return "", ""- }- for _, p := range parts {- if p.Function_argument() != nil {- return "", ""- }- }- names := make([]string, 0, len(parts))- for _, p := range parts {- names = append(names, r.idExprText(p.Id_expression()))- }- if len(names) == 1 {- return "", names[0]- }- // a.b → (a, b). schema.table.col → (table, col).- return names[len(names)-2], names[len(names)-1]-}++// a.b → (a, b). schema.table.col → (table, col).// extractColumnRefFromTableElement handles `table_element outer_join_sign`// (the bare-column-with-(+) form). Returns (qualifier, column).-func (r *WhereDisallowFunctionsAndCalculationsRule) extractColumnRefFromTableElement(te parser.ITable_elementContext) (string, string) {- if te == nil {- return "", ""- }- ids := te.AllId_expression()- if len(ids) == 0 {- return "", ""- }- names := make([]string, 0, len(ids))- for _, id := range ids {- names = append(names, r.idExprText(id))- }- if len(names) == 1 {- return "", names[0]- }- return names[len(names)-2], names[len(names)-1]-}--// isIndexedColumn reports whether a (qualifier, column) pair refers to an-// indexed column within scope s.-func (r *WhereDisallowFunctionsAndCalculationsRule) isIndexedColumn(qualifier, column string, s scopeIndexed) bool {- if column == "" || s.empty() {- return false- }- col := r.normalizeIdent(column)- if qualifier != "" {- alias := r.normalizeIdent(qualifier)- if s.localAliases[alias] {- return s.local[alias][col]- }- return s.outer[alias][col]- }- localClaims := false- for _, cols := range s.localAll {- if cols[col] {- localClaims = true- break- }- }- if localClaims {- for _, cols := range s.local {- if cols[col] {- return true- }- }- return false- }- if s.localUnresolved {- return false- }- for _, cols := range s.outer {- if cols[col] {- return true- }- }- return false-}// ---- Function-name extraction --------------------------------------------// functionCallName returns the upper-case function name applied, if the given// general_element is a function call. Returns ("", false) otherwise.-func (r *WhereDisallowFunctionsAndCalculationsRule) functionCallName(ge parser.IGeneral_elementContext) (string, bool) {- if ge == nil {- return "", false- }- parts := ge.AllGeneral_element_part()- if len(parts) == 0 {- return "", false- }- // We treat a general_element as a function call when the LAST part has a- // function_argument. The function name is the concatenation of all- // id_expressions (so DBMS_RANDOM.VALUE(...) is "DBMS_RANDOM.VALUE").- last := parts[len(parts)-1]- if last.Function_argument() == nil {- // Check if an earlier part had a function_argument — e.g. `foo(x).bar`- // — which is "method access on a call". Treat as function form too.- hasCall := false- for _, p := range parts {- if p.Function_argument() != nil {- hasCall = true- break- }- }- if !hasCall {- return "", false- }- }- var names []string- for _, p := range parts {- names = append(names, r.idExprText(p.Id_expression()))- }- return strings.ToUpper(strings.Join(names, ".")), true-}++// We treat a general_element as a function call when the LAST part has a+// function_argument. The function name is the concatenation of all+// id_expressions (so DBMS_RANDOM.VALUE(...) is "DBMS_RANDOM.VALUE").++// Check if an earlier part had a function_argument — e.g. `foo(x).bar`+// — which is "method access on a call". Treat as function form too.// extractStandardFunctionName returns the function keyword for a// standard_function context (SUBSTR, TO_CHAR, COUNT, CAST, TRIM, etc.).-func (*WhereDisallowFunctionsAndCalculationsRule) extractStandardFunctionName(ctx *parser.Standard_functionContext) string {- if ctx == nil {- return ""- }- first := ctx.GetStart()- if first == nil {- return ""- }- return strings.ToUpper(first.GetText())-}// ---- Core WHERE detection ------------------------------------------------// checkQueryBlock inspects a Query_block with the given outer scope threaded in.-func (r *WhereDisallowFunctionsAndCalculationsRule) checkQueryBlock(qb parser.IQuery_blockContext, outer tablesByAlias) {- if qb == nil {- return- }- // CTE visibility matrix — per-factoring-element, matching the PG rule's- // handleWithClause but at element granularity because Oracle has no- // RECURSIVE keyword at the factoring-clause level (it is implicit —- // an element is recursive iff its body is a UNION ALL composition AND- // at least one branch references its own query_name in a FROM position,- // which matches Oracle's syntactic requirement for recursive subquery- // factoring):- //- // | Element kind | body sees self | preceding siblings | later siblings |- // |----------------------|----------------|--------------------|----------------|- // | Non-recursive | No | Yes | No |- // | Recursive | Yes | Yes | No |- //- // Why per-element (not per-factoring-clause):- // - Non-recursive body self-shadow (e.g. `WITH orders AS (SELECT * FROM- // orders …)`, no UNION ALL) — inner `FROM orders` resolves to the- // REAL base table per SQL scope rules; must push-AFTER so the- // body-walk sees the base table and can emit `UPPER(indexed_col)`- // advice. Otherwise false negative.- // - Recursive body self-ref (e.g. `WITH orders AS (SELECT … FROM dual- // UNION ALL SELECT … FROM orders WHERE UPPER(customer_name)=…)`) —- // inner `FROM orders` resolves to the CTE itself; must push-BEFORE- // so body-walk sees it as opaque and DOESN'T attach the same-named- // base table's indexes. Otherwise false positive on recursive- // members.- //- // Detection rule (elementReferencesName):- // 1. body has at least one Subquery_operation_part that is `UNION ALL`,- // 2. any descendant Dml_table_expression_clause's Tableview_name is a- // single-component (unqualified) name whose normalized text equals- // the element's own query_name.- // Derived-table subquery sources are treated as opaque (not descended).- //- // Prior commit 1ee832f7f0 collapsed push-before/push-after into an- // unconditional push-after, which fixed the non-recursive false negative- // but re-opened the recursive false positive — addressed by codex- // #3109425426.- if sfc := qb.Subquery_factoring_clause(); sfc != nil {- frame := make(map[string]bool)- r.pushCTEs(frame)- defer r.popCTEs()- for _, fe := range sfc.AllFactoring_element() {- if fe == nil {- continue- }- name := ""- if qn := fe.Query_name(); qn != nil {- if id := qn.Identifier(); id != nil {- if text := id.GetText(); text != "" {- name = r.normalizeIdent(text)- }- }- }- sub := fe.Subquery()- recursive := name != "" && sub != nil && r.elementReferencesName(sub, name)- if recursive && name != "" {- // Push-BEFORE: body's self-reference resolves to the CTE- // (opaque), not the same-named base table.- frame[name] = true- }- if sub != nil {- r.checkSubqueryInScope(sub, nil)- }- if !recursive && name != "" {- // Push-AFTER: body's self-reference resolves to the REAL- // base table per non-recursive SQL scope rules.- frame[name] = true- }- }- }- from := qb.From_clause()- local := r.collectTableNamesFromFrom(from)- unresolved := r.localHasUnresolvedSources(from, local)- combined := mergeAliases(outer, local)-- r.checkWhereClause(qb.Where_clause(), local, outer, unresolved)-- // ANSI JOIN ON predicates behave like WHERE predicates in the same scope.- if from != nil {- if list := from.Table_ref_list(); list != nil {- for _, tref := range list.AllTable_ref() {- if tref == nil {- continue- }- for _, jc := range tref.AllJoin_clause() {- if jc == nil {- continue- }- for _, jop := range jc.AllJoin_on_part() {- if jop == nil {- continue- }- if cond := jop.Condition(); cond != nil {- r.checkExpressionAsWhere(cond, local, outer, unresolved)- }- }- }- }- }- }- // CONNECT BY / START WITH predicates behave like WHERE predicates.- if hq := qb.Hierarchical_query_clause(); hq != nil {- if sp := hq.Start_part(); sp != nil {- if cond := sp.Condition(); cond != nil {- r.checkExpressionAsWhere(cond, local, outer, unresolved)- }- }- if cond := hq.Condition(); cond != nil {- r.checkExpressionAsWhere(cond, local, outer, unresolved)- }- }+// CTE visibility matrix — per-factoring-element, matching the PG rule's+// handleWithClause but at element granularity because Oracle has no+// RECURSIVE keyword at the factoring-clause level (it is implicit —+// an element is recursive iff its body is a UNION ALL composition AND+// at least one branch references its own query_name in a FROM position,+// which matches Oracle's syntactic requirement for recursive subquery+// factoring):+//+// | Element kind | body sees self | preceding siblings | later siblings |+// |----------------------|----------------|--------------------|----------------|+// | Non-recursive | No | Yes | No |+// | Recursive | Yes | Yes | No |+//+// Why per-element (not per-factoring-clause):+// - Non-recursive body self-shadow (e.g. `WITH orders AS (SELECT * FROM+// orders …)`, no UNION ALL) — inner `FROM orders` resolves to the+// REAL base table per SQL scope rules; must push-AFTER so the+// body-walk sees the base table and can emit `UPPER(indexed_col)`+// advice. Otherwise false negative.+// - Recursive body self-ref (e.g. `WITH orders AS (SELECT … FROM dual+// UNION ALL SELECT … FROM orders WHERE UPPER(customer_name)=…)`) —+// inner `FROM orders` resolves to the CTE itself; must push-BEFORE+// so body-walk sees it as opaque and DOESN'T attach the same-named+// base table's indexes. Otherwise false positive on recursive+// members.+//+// Detection rule (elementReferencesName):+// 1. body has at least one Subquery_operation_part that is `UNION ALL`,+// 2. any descendant Dml_table_expression_clause's Tableview_name is a+// single-component (unqualified) name whose normalized text equals+// the element's own query_name.+// Derived-table subquery sources are treated as opaque (not descended).+//+// Prior commit 1ee832f7f0 collapsed push-before/push-after into an+// unconditional push-after, which fixed the non-recursive false negative+// but re-opened the recursive false positive — addressed by codex+// #3109425426.- // Recurse into subqueries inside SELECT list, FROM (derived tables), HAVING,- // GROUP BY, ORDER BY — all with combined scope.- r.recurseIntoNestedSubqueries(qb, combined)-}+// Push-BEFORE: body's self-reference resolves to the CTE+// (opaque), not the same-named base table.-func mergeAliases(outer, local tablesByAlias) tablesByAlias {- combined := make(tablesByAlias, len(outer)+len(local))- for a, r := range outer {- combined[a] = r- }- for a, r := range local {- combined[a] = r- }- return combined-}+// Push-AFTER: body's self-reference resolves to the REAL+// base table per non-recursive SQL scope rules.++// ANSI JOIN ON predicates behave like WHERE predicates in the same scope.++// CONNECT BY / START WITH predicates behave like WHERE predicates.++// Recurse into subqueries inside SELECT list, FROM (derived tables), HAVING,+// GROUP BY, ORDER BY — all with combined scope.// checkWhereClause is the entry point for the WHERE sub-tree of a query block.-func (r *WhereDisallowFunctionsAndCalculationsRule) checkWhereClause(where parser.IWhere_clauseContext, local, outer tablesByAlias, unresolved bool) {- if where == nil {- return- }- if expr := where.Expression(); expr != nil {- r.checkExpressionAsWhere(expr, local, outer, unresolved)- }-}// checkExpressionAsWhere runs the function/calculation detector on an arbitrary// expression tree, recursing into nested subqueries.-func (r *WhereDisallowFunctionsAndCalculationsRule) checkExpressionAsWhere(root antlr.Tree, local, outer tablesByAlias, unresolved bool) {- localAliases := make(map[string]bool, len(local))- for a := range local {- localAliases[a] = true- }- s := scopeIndexed{- local: r.resolveIndexedColumns(local),- localAll: r.resolveAllColumns(local),- localAliases: localAliases,- outer: r.resolveIndexedColumns(outer),- localUnresolved: unresolved,- }- combined := mergeAliases(outer, local)- r.walkWhere(root, s, combined)-}// walkWhere traverses the tree looking for nodes to check. Nested subqueries// are re-entered via checkSubqueryInScope with the combined scope.-func (r *WhereDisallowFunctionsAndCalculationsRule) walkWhere(n antlr.Tree, s scopeIndexed, combined tablesByAlias) {- if n == nil {- return- }- // Re-enter into nested subqueries without running the detector on them.- if sub, ok := n.(*parser.SubqueryContext); ok {- r.checkSubqueryInScope(sub, combined)- return- }- // General_element: may be a column ref (skip — handled via parent) or a- // function call (detect).- if ge, ok := n.(*parser.General_elementContext); ok {- if name, isCall := r.functionCallName(ge); isCall {- if col := r.findIndexedColumnInFunctionArgs(ge, s); col != "" {- r.addFunctionAdvice(name, col, ge)- }- // Still recurse into the arguments — a nested function/calc on an- // indexed column should ALSO be flagged (e.g. `ABS(id + 1)`).- for _, part := range ge.AllGeneral_element_part() {- if arg := part.Function_argument(); arg != nil {- r.walkWhere(arg, s, combined)- }- }- return- }- // Not a function call — the column ref case is reached via parent- // nodes (concatenation / unary). Fall through.- }- // Standard_function: built-in (SUBSTR / COUNT / CAST / TRIM / …).- if sf, ok := n.(*parser.Standard_functionContext); ok {- name := r.extractStandardFunctionName(sf)- // Special-case CAST: it's a transparent wrapper for the indexed-col- // check but we still also flag CAST-on-indexed as a function.- if col := r.findIndexedColumnInStandardFunction(sf, s); col != "" && name != "" {- r.addFunctionAdvice(name, col, sf)- }- for i := 0; i < sf.GetChildCount(); i++ {- r.walkWhere(sf.GetChild(i), s, combined)- }- return- }- // Concatenation: arithmetic ASTERISK / SOLIDUS / PLUS_SIGN / MINUS_SIGN.- if c, ok := n.(*parser.ConcatenationContext); ok {- if isArithmeticConcat(c) {- if col := r.unwrapAndFindIndexedColumn(c.Concatenation(0), s); col != "" {- r.addCalculationAdvice(col, c)- } else if col := r.unwrapAndFindIndexedColumn(c.Concatenation(1), s); col != "" {- r.addCalculationAdvice(col, c)- }- }- for i := 0; i < c.GetChildCount(); i++ {- r.walkWhere(c.GetChild(i), s, combined)- }- return- }- // Unary minus → calculation (NOT PRIOR, NOT CONNECT_BY_ROOT).- if u, ok := n.(*parser.Unary_expressionContext); ok {- if u.MINUS_SIGN() != nil {- if inner := u.Unary_expression(); inner != nil {- if col := r.unwrapAndFindIndexedColumn(inner, s); col != "" {- r.addCalculationAdvice(col, u)- }- }- }- for i := 0; i < u.GetChildCount(); i++ {- r.walkWhere(u.GetChild(i), s, combined)- }- return- }- for i := 0; i < n.GetChildCount(); i++ {- r.walkWhere(n.GetChild(i), s, combined)- }-}+// Re-enter into nested subqueries without running the detector on them.++// General_element: may be a column ref (skip — handled via parent) or a+// function call (detect).++// Still recurse into the arguments — a nested function/calc on an+// indexed column should ALSO be flagged (e.g. `ABS(id + 1)`).++// Not a function call — the column ref case is reached via parent+// nodes (concatenation / unary). Fall through.++// Standard_function: built-in (SUBSTR / COUNT / CAST / TRIM / …).++// Special-case CAST: it's a transparent wrapper for the indexed-col+// check but we still also flag CAST-on-indexed as a function.++// Concatenation: arithmetic ASTERISK / SOLIDUS / PLUS_SIGN / MINUS_SIGN.++// Unary minus → calculation (NOT PRIOR, NOT CONNECT_BY_ROOT).// isArithmeticConcat reports whether the concatenation is an arithmetic op.-func isArithmeticConcat(c *parser.ConcatenationContext) bool {- if c == nil || c.GetOp() == nil {- return false- }- switch c.GetOp().GetTokenType() {- case parser.PlSqlParserASTERISK,- parser.PlSqlParserSOLIDUS,- parser.PlSqlParserPLUS_SIGN,- parser.PlSqlParserMINUS_SIGN:- return true- }- return false-}// unwrapAndFindIndexedColumn peels passthrough wrappers (parens, CAST) and,// if the inner expression is an indexed column reference, returns its// lower-cased column name. Returns "" otherwise.-func (r *WhereDisallowFunctionsAndCalculationsRule) unwrapAndFindIndexedColumn(n antlr.Tree, s scopeIndexed) string {- for n != nil {- switch c := n.(type) {- case *parser.ConcatenationContext:- // passthrough: only if not itself an arithmetic op- if isArithmeticConcat(c) {- return ""- }- if m := c.Model_expression(); m != nil {- n = m- continue- }- return ""- case *parser.Model_expressionContext:- if u := c.Unary_expression(); u != nil {- n = u- continue- }- return ""- case *parser.Unary_expressionContext:- if c.MINUS_SIGN() != nil || c.PRIOR() != nil || c.CONNECT_BY_ROOT() != nil || c.NEW() != nil || c.DISTINCT() != nil || c.ALL() != nil {- return ""- }- if at := c.Atom(); at != nil {- n = at- continue- }- if sf := c.Standard_function(); sf != nil {- if sfCtx, ok := sf.(*parser.Standard_functionContext); ok {- // CAST unwrap: `CAST(col AS TYPE)` — the inside is transparent for column-ref extraction.- return r.unwrapCastColumn(sfCtx, s)- }- return ""- }- return ""- case *parser.AtomContext:- // LEFT_PAREN expressions RIGHT_PAREN — passthrough if single.- if ge := c.General_element(); ge != nil {- qualifier, column := r.extractColumnRefFromGeneralElement(ge)- if column != "" && r.isIndexedColumn(qualifier, column, s) {- return r.normalizeIdent(column)- }- return ""- }- if te := c.Table_element(); te != nil {- qualifier, column := r.extractColumnRefFromTableElement(te)- if column != "" && r.isIndexedColumn(qualifier, column, s) {- return r.normalizeIdent(column)- }- return ""- }- // (expressions) — unwrap if single expression.- if exprs := c.Expressions(); exprs != nil {- all := exprs.AllExpression()- if len(all) == 1 {- n = all[0]- continue- }- }- return ""- case *parser.ExpressionContext:- if le := c.Logical_expression(); le != nil {- n = le- continue- }- return ""- case *parser.Logical_expressionContext:- if ul := c.Unary_logical_expression(); ul != nil {- n = ul- continue- }- return ""- case *parser.Unary_logical_expressionContext:- if me := c.Multiset_expression(); me != nil {- n = me- continue- }- return ""- case *parser.Multiset_expressionContext:- if rel := c.Relational_expression(); rel != nil {- n = rel- continue- }- return ""- case *parser.Relational_expressionContext:- rels := c.AllRelational_expression()- if len(rels) == 1 {- n = rels[0]- continue- }- if comp := c.Compound_expression(); comp != nil {- n = comp- continue- }- return ""- case *parser.Compound_expressionContext:- cats := c.AllConcatenation()- if len(cats) >= 1 {- n = cats[0]- continue- }- return ""- default:- return ""- }- }- return ""-}++// passthrough: only if not itself an arithmetic op++// CAST unwrap: `CAST(col AS TYPE)` — the inside is transparent for column-ref extraction.++// LEFT_PAREN expressions RIGHT_PAREN — passthrough if single.++// (expressions) — unwrap if single expression.// unwrapCastColumn returns the indexed-column name inside a `CAST(col AS T)`// expression, or "" if the inside isn't a bare indexed column.-func (r *WhereDisallowFunctionsAndCalculationsRule) unwrapCastColumn(sf *parser.Standard_functionContext, s scopeIndexed) string {- if sf == nil {- return ""- }- of := sf.Other_function()- if of == nil {- return ""- }- ofCtx, ok := of.(*parser.Other_functionContext)- if !ok {- return ""- }- if ofCtx.CAST() == nil && ofCtx.XMLCAST() == nil {- return ""- }- cats := ofCtx.AllConcatenation()- if len(cats) == 0 {- return ""- }- return r.unwrapAndFindIndexedColumn(cats[0], s)-}// findIndexedColumnInFunctionArgs searches a function-call's argument list for// an indexed column reference (unwrapping CAST / parens). Arithmetic is NOT// crossed so `ABS(id + 1)` reports as a calculation via the inner walker.-func (r *WhereDisallowFunctionsAndCalculationsRule) findIndexedColumnInFunctionArgs(ge *parser.General_elementContext, s scopeIndexed) string {- for _, part := range ge.AllGeneral_element_part() {- arg := part.Function_argument()- if arg == nil {- continue- }- argCtx, ok := arg.(*parser.Function_argumentContext)- if !ok {- continue- }- for _, a := range argCtx.AllArgument() {- if a == nil {- continue- }- aCtx, ok := a.(*parser.ArgumentContext)- if !ok {- continue- }- if expr := aCtx.Expression(); expr != nil {- if col := r.unwrapAndFindIndexedColumn(expr, s); col != "" {- return col- }- }- }- }- return ""-}// findIndexedColumnInStandardFunction searches a built-in function's argument// subtree for an indexed column reference.-func (r *WhereDisallowFunctionsAndCalculationsRule) findIndexedColumnInStandardFunction(sf *parser.Standard_functionContext, s scopeIndexed) string {- if sf == nil {- return ""- }- // Walk the function's children (NOT the root node itself — we want to- // descend into its arguments, stopping only at further function calls /- // arithmetic).- for i := 0; i < sf.GetChildCount(); i++ {- if col := r.findIndexedColumnInChildren(sf.GetChild(i), s); col != "" {- return col- }- }- return ""-}++// Walk the function's children (NOT the root node itself — we want to+// descend into its arguments, stopping only at further function calls /+// arithmetic).// findIndexedColumnInChildren recursively searches for an indexed column// reference without crossing into arithmetic concatenations (those spawn the// calculation path) or further function calls.-func (r *WhereDisallowFunctionsAndCalculationsRule) findIndexedColumnInChildren(n antlr.Tree, s scopeIndexed) string {- if n == nil {- return ""- }- switch c := n.(type) {- case *parser.ConcatenationContext:- if isArithmeticConcat(c) {- return ""- }- case *parser.General_elementContext:- if _, isCall := r.functionCallName(c); isCall {- return ""- }- qualifier, column := r.extractColumnRefFromGeneralElement(c)- if column != "" && r.isIndexedColumn(qualifier, column, s) {- return r.normalizeIdent(column)- }- return ""- case *parser.Table_elementContext:- qualifier, column := r.extractColumnRefFromTableElement(c)- if column != "" && r.isIndexedColumn(qualifier, column, s) {- return r.normalizeIdent(column)- }- return ""- case *parser.Standard_functionContext:- return ""- default:- }- for i := 0; i < n.GetChildCount(); i++ {- if col := r.findIndexedColumnInChildren(n.GetChild(i), s); col != "" {- return col- }- }- return ""-}// ---- Subquery re-entry ---------------------------------------------------// checkSubqueryInScope re-enters the recursive check on a SubqueryContext,// threading the given outer scope for correlated refs.-func (r *WhereDisallowFunctionsAndCalculationsRule) checkSubqueryInScope(sub parser.ISubqueryContext, outer tablesByAlias) {- if sub == nil {- return- }- // Set-op: first element plus each subquery_operation_part.- if base := sub.Subquery_basic_elements(); base != nil {- r.checkSubqueryBasicElements(base, outer)- }- for _, op := range sub.AllSubquery_operation_part() {- if op == nil {- continue- }- if base := op.Subquery_basic_elements(); base != nil {- r.checkSubqueryBasicElements(base, outer)- }- }-}-func (r *WhereDisallowFunctionsAndCalculationsRule) checkSubqueryBasicElements(be parser.ISubquery_basic_elementsContext, outer tablesByAlias) {- if be == nil {- return- }- if qb := be.Query_block(); qb != nil {- r.checkQueryBlock(qb, outer)- return- }- if inner := be.Subquery(); inner != nil {- r.checkSubqueryInScope(inner, outer)- }-}+// Set-op: first element plus each subquery_operation_part.// recurseIntoNestedSubqueries scans the non-WHERE parts of a query block for// SubqueryContext nodes and dispatches each with the given outer scope.-func (r *WhereDisallowFunctionsAndCalculationsRule) recurseIntoNestedSubqueries(qb parser.IQuery_blockContext, outer tablesByAlias) {- if qb == nil {- return- }- // SELECT list- if sl := qb.Selected_list(); sl != nil {- r.recurseIntoSubqueriesIn(sl, outer)- }- // FROM (derived tables). Subqueries inside JOIN ON predicates are already- // walked by checkQueryBlock via checkExpressionAsWhere; skip them here to- // avoid double-flagging.- if from := qb.From_clause(); from != nil {- r.recurseIntoFromSubqueries(from, outer)- }- // GROUP BY + HAVING (HAVING is never itself flagged; nested subqueries- // inside are still recursed).- if gb := qb.Group_by_clause(); gb != nil {- r.recurseIntoSubqueriesIn(gb, outer)- }- if ob := qb.Order_by_clause(); ob != nil {- r.recurseIntoSubqueriesIn(ob, outer)- }-}-func (r *WhereDisallowFunctionsAndCalculationsRule) recurseIntoSubqueriesIn(n antlr.Tree, outer tablesByAlias) {- if n == nil {- return- }- if sub, ok := n.(*parser.SubqueryContext); ok {- r.checkSubqueryInScope(sub, outer)- return- }- for i := 0; i < n.GetChildCount(); i++ {- r.recurseIntoSubqueriesIn(n.GetChild(i), outer)- }-}+// SELECT list++// FROM (derived tables). Subqueries inside JOIN ON predicates are already+// walked by checkQueryBlock via checkExpressionAsWhere; skip them here to+// avoid double-flagging.++// GROUP BY + HAVING (HAVING is never itself flagged; nested subqueries+// inside are still recursed).// recurseIntoSubqueriesSkipWhere is like recurseIntoSubqueriesIn but skips// Where_clauseContext subtrees. Callers that already dispatched the WHERE// through checkWhereClause use this variant to avoid double-walking subqueries// inside that WHERE (checkWhereClause → walkWhere re-enters SubqueryContext on// its own).-func (r *WhereDisallowFunctionsAndCalculationsRule) recurseIntoSubqueriesSkipWhere(n antlr.Tree, outer tablesByAlias) {- if n == nil {- return- }- if _, ok := n.(*parser.Where_clauseContext); ok {- return- }- if sub, ok := n.(*parser.SubqueryContext); ok {- r.checkSubqueryInScope(sub, outer)- return- }- for i := 0; i < n.GetChildCount(); i++ {- r.recurseIntoSubqueriesSkipWhere(n.GetChild(i), outer)- }-}// recurseIntoFromSubqueries walks a FROM-clause subtree for derived-table// subqueries but skips Join_on_part subtrees — JOIN ON conditions are// dispatched separately by checkQueryBlock and would otherwise cause the// same inner subquery to be checked twice.-func (r *WhereDisallowFunctionsAndCalculationsRule) recurseIntoFromSubqueries(n antlr.Tree, outer tablesByAlias) {- if n == nil {- return- }- if _, ok := n.(*parser.Join_on_partContext); ok {- return- }- if sub, ok := n.(*parser.SubqueryContext); ok {- r.checkSubqueryInScope(sub, outer)- return- }- for i := 0; i < n.GetChildCount(); i++ {- r.recurseIntoFromSubqueries(n.GetChild(i), outer)- }-}// ---- Top-level dispatchers -----------------------------------------------// checkSelectOnly dispatches the top-level subquery of a Select_only_statement.-func (r *WhereDisallowFunctionsAndCalculationsRule) checkSelectOnly(sos parser.ISelect_only_statementContext) {- if sos == nil {- return- }- if sub := sos.Subquery(); sub != nil {- r.checkSubqueryInScope(sub, nil)- }-}// onSelectStmt handles SELECT (including CTE / UNION / MINUS / INTERSECT).-func (r *WhereDisallowFunctionsAndCalculationsRule) onSelectStmt(ctx *parser.Select_statementContext) {- if ctx == nil {- return- }- r.checkSelectOnly(ctx.Select_only_statement())-}// tablesUnresolved reports whether any concrete tableRef lacks metadata.// Empty (placeholder) refs are skipped; use emptyIsUnresolved=true when an empty-// ref should itself count as unresolved (e.g. MERGE derived source).-func (r *WhereDisallowFunctionsAndCalculationsRule) tablesUnresolved(tables tablesByAlias, emptyIsUnresolved bool) bool {- for _, ref := range tables {- if ref == (tableRef{}) {- if emptyIsUnresolved {- return true- }- continue- }- if r.tableMetadata(ref) == nil {- return true- }- }- return false-}-// onUpdateStmt handles UPDATE ... SET ... WHERE ...-func (r *WhereDisallowFunctionsAndCalculationsRule) onUpdateStmt(ctx *parser.Update_statementContext) {- if ctx == nil {- return- }- tables := make(tablesByAlias)- if gtr := ctx.General_table_ref(); gtr != nil {- r.collectTableNamesFromGeneralTableRef(gtr, tables)- r.dispatchTargetSubquery(gtr)- }- unresolved := r.tablesUnresolved(tables, false)- if where := ctx.Where_clause(); where != nil {- r.checkWhereClause(where, tables, nil, unresolved)- }- // Recurse into subqueries in SET expressions and WHERE subqueries (latter handled via walkWhere).- if sc := ctx.Update_set_clause(); sc != nil {- r.recurseIntoSubqueriesIn(sc, tables)- }- if ret := ctx.Static_returning_clause(); ret != nil {- r.recurseIntoSubqueriesIn(ret, tables)- }-}++// Recurse into subqueries in SET expressions and WHERE subqueries (latter handled via walkWhere).// onDeleteStmt handles DELETE [FROM] … WHERE …-func (r *WhereDisallowFunctionsAndCalculationsRule) onDeleteStmt(ctx *parser.Delete_statementContext) {- if ctx == nil {- return- }- tables := make(tablesByAlias)- if gtr := ctx.General_table_ref(); gtr != nil {- r.collectTableNamesFromGeneralTableRef(gtr, tables)- r.dispatchTargetSubquery(gtr)- }- unresolved := r.tablesUnresolved(tables, false)- if where := ctx.Where_clause(); where != nil {- r.checkWhereClause(where, tables, nil, unresolved)- }- if ret := ctx.Static_returning_clause(); ret != nil {- r.recurseIntoSubqueriesIn(ret, tables)- }-}// dispatchTargetSubquery dispatches the inner SELECT when the UPDATE / DELETE// target is a derived table (`UPDATE (SELECT … WHERE …) SET …`). The outer// collector records only an opaque alias placeholder; the inner WHERE must// still be checked independently.-func (r *WhereDisallowFunctionsAndCalculationsRule) dispatchTargetSubquery(gtr parser.IGeneral_table_refContext) {- if gtr == nil {- return- }- dte := gtr.Dml_table_expression_clause()- if dte == nil {- return- }- sel := dte.Select_statement()- if sel == nil {- return- }- r.checkSelectOnly(sel.Select_only_statement())-}// onInsertStmt handles INSERT INTO … SELECT / VALUES …-func (r *WhereDisallowFunctionsAndCalculationsRule) onInsertStmt(ctx *parser.Insert_statementContext) {- if ctx == nil {- return- }- if sti := ctx.Single_table_insert(); sti != nil {- if sel := sti.Select_statement(); sel != nil {- r.checkSelectOnly(sel.Select_only_statement())- }- // VALUES (subquery) — walk only the values and returning trees, not- // the full sti (which would double-walk a sibling SELECT source).- if v := sti.Values_clause(); v != nil {- r.recurseIntoSubqueriesIn(v, nil)- }- if ret := sti.Static_returning_clause(); ret != nil {- r.recurseIntoSubqueriesIn(ret, nil)- }- }- if mti := ctx.Multi_table_insert(); mti != nil {- if sel := mti.Select_statement(); sel != nil {- r.checkSelectOnly(sel.Select_only_statement())- }- // INSERT ALL WHEN <cond> THEN INTO ... — the WHEN predicate is a- // per-row filter over the driving SELECT's columns. Build a scope from- // that SELECT's FROM clause so indexed-column refs resolve.- drivingTables := make(tablesByAlias)- if sel := mti.Select_statement(); sel != nil {- if sos := sel.Select_only_statement(); sos != nil {- if sub := sos.Subquery(); sub != nil {- if be := sub.Subquery_basic_elements(); be != nil {- if qb := be.Query_block(); qb != nil {- drivingTables = r.collectTableNamesFromFrom(qb.From_clause())- }- }- }- }- }- drivingUnresolved := r.tablesUnresolved(drivingTables, false)- if cic := mti.Conditional_insert_clause(); cic != nil {- for _, wp := range cic.AllConditional_insert_when_part() {- if cond := wp.Condition(); cond != nil {- r.checkExpressionAsWhere(cond, drivingTables, nil, drivingUnresolved)- }- // INTO branches may carry VALUES subqueries — recurse into- // them. The WHEN Condition itself is already handled above- // via checkExpressionAsWhere (which re-enters subqueries);- // skip it here to avoid double-walking.- for _, elt := range wp.AllMulti_table_element() {- r.recurseIntoSubqueriesIn(elt, nil)- }- }- if ep := cic.Conditional_insert_else_part(); ep != nil {- r.recurseIntoSubqueriesIn(ep, nil)- }- }- // Walk non-conditional multi-table-element children too (for INSERT- // ALL without WHEN branches). Skip the driving SELECT (already- // handled) and the Conditional_insert_clause (handled above, where- // we split WHEN Condition from INTO branches).- for i := 0; i < mti.GetChildCount(); i++ {- child := mti.GetChild(i)- if _, isSel := child.(parser.ISelect_statementContext); isSel {- continue- }- if _, isCIC := child.(parser.IConditional_insert_clauseContext); isCIC {- continue- }- r.recurseIntoSubqueriesIn(child, nil)- }- }-}++// VALUES (subquery) — walk only the values and returning trees, not+// the full sti (which would double-walk a sibling SELECT source).++// INSERT ALL WHEN <cond> THEN INTO ... — the WHEN predicate is a+// per-row filter over the driving SELECT's columns. Build a scope from+// that SELECT's FROM clause so indexed-column refs resolve.++// INTO branches may carry VALUES subqueries — recurse into+// them. The WHEN Condition itself is already handled above+// via checkExpressionAsWhere (which re-enters subqueries);+// skip it here to avoid double-walking.++// Walk non-conditional multi-table-element children too (for INSERT+// ALL without WHEN branches). Skip the driving SELECT (already+// handled) and the Conditional_insert_clause (handled above, where+// we split WHEN Condition from INTO branches).// onCreateTable handles CREATE TABLE ... AS subquery (CTAS).-func (r *WhereDisallowFunctionsAndCalculationsRule) onCreateTable(ctx *parser.Create_tableContext) {- if ctx == nil {- return- }- if sub := findFirstSubquery(ctx); sub != nil {- r.checkSubqueryInScope(sub, nil)- }-}// onCreateView handles CREATE [OR REPLACE] VIEW v AS SELECT …-func (r *WhereDisallowFunctionsAndCalculationsRule) onCreateView(ctx *parser.Create_viewContext) {- if ctx == nil {- return- }- r.checkSelectOnly(ctx.Select_only_statement())-}// onCreateMaterializedView handles CREATE MATERIALIZED VIEW mv AS SELECT …-func (r *WhereDisallowFunctionsAndCalculationsRule) onCreateMaterializedView(ctx *parser.Create_materialized_viewContext) {- if ctx == nil {- return- }- r.checkSelectOnly(ctx.Select_only_statement())-}// onMergeStmt handles MERGE INTO target USING source ON cond WHEN …-func (r *WhereDisallowFunctionsAndCalculationsRule) onMergeStmt(ctx *parser.Merge_statementContext) {- if ctx == nil {- return- }- tables := make(tablesByAlias)- for _, tv := range ctx.AllSelected_tableview() {- r.collectTableNamesFromSelectedTableview(tv, tables)- // MERGE source may be a subquery (`USING (SELECT … WHERE …)`). The- // outer collector records only an opaque alias placeholder; run the- // rule on the inner SELECT independently so its own WHERE is checked.- if sel := tv.Select_statement(); sel != nil {- r.checkSelectOnly(sel.Select_only_statement())- }- }- unresolved := r.tablesUnresolved(tables, true)- if cond := ctx.Condition(); cond != nil {- r.checkExpressionAsWhere(cond, tables, nil, unresolved)- }- if mu := ctx.Merge_update_clause(); mu != nil {- if where := mu.Where_clause(); where != nil {- r.checkWhereClause(where, tables, nil, unresolved)- }- if mud := mu.Merge_update_delete_part(); mud != nil {- if where := mud.Where_clause(); where != nil {- r.checkWhereClause(where, tables, nil, unresolved)- }- }- // SET col = (subquery) — recurse into any nested subqueries, skipping- // the Where_clause subtrees already dispatched above.- r.recurseIntoSubqueriesSkipWhere(mu, tables)- }- if mi := ctx.Merge_insert_clause(); mi != nil {- if where := mi.Where_clause(); where != nil {- r.checkWhereClause(where, tables, nil, unresolved)- }- // INSERT VALUES (subquery) or column-list subqueries — same recursion,- // skipping the Where_clause subtree already dispatched above.- r.recurseIntoSubqueriesSkipWhere(mi, tables)- }-}++// MERGE source may be a subquery (`USING (SELECT … WHERE …)`). The+// outer collector records only an opaque alias placeholder; run the+// rule on the inner SELECT independently so its own WHERE is checked.++// SET col = (subquery) — recurse into any nested subqueries, skipping+// the Where_clause subtrees already dispatched above.++// INSERT VALUES (subquery) or column-list subqueries — same recursion,+// skipping the Where_clause subtree already dispatched above.// collectTableNamesFromGeneralTableRef records the UPDATE / DELETE target.-func (r *WhereDisallowFunctionsAndCalculationsRule) collectTableNamesFromGeneralTableRef(gtr parser.IGeneral_table_refContext, tables tablesByAlias) {- if gtr == nil {- return- }- alias := ""- if ta := gtr.Table_alias(); ta != nil {- alias = r.tableAliasText(ta)- }- if dte := gtr.Dml_table_expression_clause(); dte != nil {- r.collectTableNamesFromDml(dte, alias, tables)- }-}// collectTableNamesFromSelectedTableview records a MERGE target / source.-func (r *WhereDisallowFunctionsAndCalculationsRule) collectTableNamesFromSelectedTableview(tv parser.ISelected_tableviewContext, tables tablesByAlias) {- if tv == nil {- return- }- alias := ""- if ta := tv.Table_alias(); ta != nil {- alias = r.tableAliasText(ta)- }- if tvn := tv.Tableview_name(); tvn != nil {- schema, name := r.splitTableviewName(tvn)- key := alias- if key == "" {- key = name- }- normKey := r.normalizeIdent(key)- // CTE shadowing — see collectTableNamesFromDml.- if schema == "" && r.cteVisible(name) {- tables[normKey] = tableRef{}- return- }- ref := tableRef{schema: schema, name: name}- if existing, ok := tables[normKey]; ok && (existing.schema != ref.schema || existing.name != ref.name) {- tables[normKey] = tableRef{}- } else {- tables[normKey] = ref- }- return- }- if tv.Select_statement() != nil {- key := r.normalizeIdent(alias)- if key != "" {- if _, ok := tables[key]; !ok {- tables[key] = tableRef{}- }- }- }-}++// CTE shadowing — see collectTableNamesFromDml.// findFirstSubquery does a DFS for the first SubqueryContext child in the tree.-func findFirstSubquery(n antlr.Tree) parser.ISubqueryContext {- if n == nil {- return nil- }- for i := 0; i < n.GetChildCount(); i++ {- child := n.GetChild(i)- if sub, ok := child.(*parser.SubqueryContext); ok {- return sub- }- if sub := findFirstSubquery(child); sub != nil {- return sub- }- }- return nil-}// ---- Advice builders --------------------------------------------------------func (r *WhereDisallowFunctionsAndCalculationsRule) addFunctionAdvice(funcName, col string, ctx antlr.ParserRuleContext) {- r.adviceList = append(r.adviceList, &storepb.Advice{- Status: r.level,- Code: code.StatementDisallowFunctionsAndCalculations.Int32(),- Title: r.title,- Content: fmt.Sprintf("Function %q is applied to indexed column %q in the WHERE clause, which prevents index usage", funcName, col),- StartPosition: common.ConvertANTLRLineToPosition(r.baseLine + ctx.GetStart().GetLine()),- })-}--func (r *WhereDisallowFunctionsAndCalculationsRule) addCalculationAdvice(col string, ctx antlr.ParserRuleContext) {- r.adviceList = append(r.adviceList, &storepb.Advice{- Status: r.level,- Code: code.StatementDisallowFunctionsAndCalculations.Int32(),- Title: r.title,- Content: fmt.Sprintf("Calculation is applied to indexed column %q in the WHERE clause, which prevents index usage", col),- StartPosition: common.ConvertANTLRLineToPosition(r.baseLine + ctx.GetStart().GetLine()),- })-}diff --git a/backend/plugin/advisor/oracle/rule_table_comment_convention.go b/backend/plugin/advisor/oracle/rule_table_comment_convention.goindex fc1ed2fbb2..31bdafaca9 100644--- a/backend/plugin/advisor/oracle/rule_table_comment_convention.go+++ b/backend/plugin/advisor/oracle/rule_table_comment_convention.go@@ -5,15 +5,12 @@ import ("context""fmt"- "github.com/antlr4-go/antlr/v4""github.com/bytebase/omni/oracle/ast"- parser "github.com/bytebase/parser/plsql""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/code"- plsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/plsql")var (@@ -86,41 +83,8 @@ func (r *TableCommentConventionRule) OnStatement(node ast.Node) {}// OnEnter is called when the parser enters a rule context.-func (r *TableCommentConventionRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Create_table":- r.handleCreateTable(ctx.(*parser.Create_tableContext))- case "Comment_on_table":- r.handleCommentOnTable(ctx.(*parser.Comment_on_tableContext))- default:- }- return nil-}// OnExit is called when the parser exits a rule context.-func (*TableCommentConventionRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}--func (r *TableCommentConventionRule) handleCreateTable(ctx *parser.Create_tableContext) {- schemaName := r.currentDatabase- if ctx.Schema_name() != nil {- schemaName = normalizeIdentifier(ctx.Schema_name(), r.currentDatabase)- }-- tableName := fmt.Sprintf("%s.%s", schemaName, normalizeIdentifier(ctx.Table_name(), r.currentDatabase))- r.tableNames = append(r.tableNames, tableName)- r.tableLine[tableName] = r.baseLine + ctx.GetStart().GetLine()-}--func (r *TableCommentConventionRule) handleCommentOnTable(ctx *parser.Comment_on_tableContext) {- if ctx.Tableview_name() == nil {- return- }-- tableName := normalizeIdentifier(ctx.Tableview_name(), r.currentDatabase)- r.tableComment[tableName] = plsqlparser.NormalizeQuotedString(ctx.Quoted_string())-}// GetAdviceList returns the advice list.func (r *TableCommentConventionRule) GetAdviceList() ([]*storepb.Advice, error) {diff --git a/backend/plugin/advisor/oracle/rule_table_no_foreign_key.go b/backend/plugin/advisor/oracle/rule_table_no_foreign_key.goindex 8fd556ef6e..790461965c 100644--- a/backend/plugin/advisor/oracle/rule_table_no_foreign_key.go+++ b/backend/plugin/advisor/oracle/rule_table_no_foreign_key.go@@ -5,9 +5,7 @@ import ("context""fmt"- "github.com/antlr4-go/antlr/v4""github.com/bytebase/omni/oracle/ast"- parser "github.com/bytebase/parser/plsql""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store"@@ -44,7 +42,6 @@ type TableNoForeignKeyRule struct {BaseRulecurrentDatabase string- tableName stringtableWithFK map[string]booltableLine map[string]int}@@ -100,30 +97,8 @@ func (*TableNoForeignKeyRule) createTableHasFK(stmt *ast.CreateTableStmt) bool {}// OnEnter is called when the parser enters a rule context.-func (r *TableNoForeignKeyRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Create_table":- r.handleCreateTable(ctx.(*parser.Create_tableContext))- case "References_clause":- r.handleReferencesClause(ctx.(*parser.References_clauseContext))- case "Alter_table":- r.handleAlterTable(ctx.(*parser.Alter_tableContext))- default:- }- return nil-}// OnExit is called when the parser exits a rule context.-func (r *TableNoForeignKeyRule) OnExit(_ antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Create_table":- r.tableName = ""- case "Alter_table":- r.tableName = ""- default:- }- return nil-}// GetAdviceList returns the advice list.func (r *TableNoForeignKeyRule) GetAdviceList() ([]*storepb.Advice, error) {@@ -139,21 +114,3 @@ func (r *TableNoForeignKeyRule) GetAdviceList() ([]*storepb.Advice, error) {}return r.BaseRule.GetAdviceList()}--func (r *TableNoForeignKeyRule) handleCreateTable(ctx *parser.Create_tableContext) {- schemaName := r.currentDatabase- if ctx.Schema_name() != nil {- schemaName = normalizeIdentifier(ctx.Schema_name(), r.currentDatabase)- }-- r.tableName = fmt.Sprintf("%s.%s", schemaName, normalizeIdentifier(ctx.Table_name(), r.currentDatabase))-}--func (r *TableNoForeignKeyRule) handleReferencesClause(ctx *parser.References_clauseContext) {- r.tableWithFK[r.tableName] = true- r.tableLine[r.tableName] = r.baseLine + ctx.GetStop().GetLine()-}--func (r *TableNoForeignKeyRule) handleAlterTable(ctx *parser.Alter_tableContext) {- r.tableName = normalizeIdentifier(ctx.Tableview_name(), r.currentDatabase)-}diff --git a/backend/plugin/advisor/oracle/rule_table_require_pk.go b/backend/plugin/advisor/oracle/rule_table_require_pk.goindex 946701543a..f425479dc4 100644--- a/backend/plugin/advisor/oracle/rule_table_require_pk.go+++ b/backend/plugin/advisor/oracle/rule_table_require_pk.go@@ -6,9 +6,7 @@ import ("fmt""strings"- "github.com/antlr4-go/antlr/v4""github.com/bytebase/omni/oracle/ast"- parser "github.com/bytebase/parser/plsql""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store"@@ -45,7 +43,6 @@ type TableRequirePKRule struct {BaseRulecurrentDatabase string- tableName stringtableWitPK map[string]booltableLine map[string]int}@@ -114,38 +111,8 @@ func (*TableRequirePKRule) createTableHasPK(stmt *ast.CreateTableStmt) bool {}// OnEnter is called when the parser enters a rule context.-func (r *TableRequirePKRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Create_table":- r.handleCreateTable(ctx.(*parser.Create_tableContext))- case "Inline_constraint":- r.handleInlineConstraint(ctx.(*parser.Inline_constraintContext))- case "Constraint_clauses":- r.handleConstraintClauses(ctx.(*parser.Constraint_clausesContext))- case "Out_of_line_constraint":- r.handleOutOfLineConstraint(ctx.(*parser.Out_of_line_constraintContext))- case "Alter_table":- r.handleAlterTable(ctx.(*parser.Alter_tableContext))- case "Drop_table":- r.handleDropTable(ctx.(*parser.Drop_tableContext))- case "Drop_primary_key_or_unique_or_generic_clause":- r.handleDropPrimaryKey(ctx.(*parser.Drop_primary_key_or_unique_or_generic_clauseContext))- default:- }- return nil-}// OnExit is called when the parser exits a rule context.-func (r *TableRequirePKRule) OnExit(_ antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Create_table":- r.tableName = ""- case "Alter_table":- r.tableName = ""- default:- }- return nil-}// GetAdviceList returns the advice list.func (r *TableRequirePKRule) GetAdviceList() ([]*storepb.Advice, error) {@@ -161,57 +128,3 @@ func (r *TableRequirePKRule) GetAdviceList() ([]*storepb.Advice, error) {}return r.BaseRule.GetAdviceList()}--func (r *TableRequirePKRule) handleCreateTable(ctx *parser.Create_tableContext) {- schemaName := r.currentDatabase- if ctx.Schema_name() != nil {- schemaName = normalizeIdentifier(ctx.Schema_name(), r.currentDatabase)- }-- r.tableName = fmt.Sprintf("%s.%s", schemaName, normalizeIdentifier(ctx.Table_name(), r.currentDatabase))- r.tableWitPK[r.tableName] = false- r.tableLine[r.tableName] = r.baseLine + ctx.GetStop().GetLine()-}--func (r *TableRequirePKRule) handleInlineConstraint(ctx *parser.Inline_constraintContext) {- if ctx.PRIMARY() != nil {- if _, exists := r.tableWitPK[r.tableName]; exists {- r.tableWitPK[r.tableName] = true- }- }-}--func (r *TableRequirePKRule) handleConstraintClauses(ctx *parser.Constraint_clausesContext) {- if ctx.PRIMARY() != nil {- if _, exists := r.tableWitPK[r.tableName]; exists {- r.tableWitPK[r.tableName] = true- }- }-}--func (r *TableRequirePKRule) handleOutOfLineConstraint(ctx *parser.Out_of_line_constraintContext) {- if ctx.PRIMARY() != nil {- if _, exists := r.tableWitPK[r.tableName]; exists {- r.tableWitPK[r.tableName] = true- }- }-}--func (r *TableRequirePKRule) handleAlterTable(ctx *parser.Alter_tableContext) {- r.tableName = normalizeIdentifier(ctx.Tableview_name(), r.currentDatabase)-}--func (r *TableRequirePKRule) handleDropTable(ctx *parser.Drop_tableContext) {- tableName := normalizeIdentifier(ctx.Tableview_name(), r.currentDatabase)- if _, exists := r.tableWitPK[tableName]; !exists {- return- }- delete(r.tableWitPK, tableName)-}--func (r *TableRequirePKRule) handleDropPrimaryKey(ctx *parser.Drop_primary_key_or_unique_or_generic_clauseContext) {- if _, exists := r.tableWitPK[r.tableName]; exists && ctx.PRIMARY() != nil {- r.tableWitPK[r.tableName] = false- r.tableLine[r.tableName] = r.baseLine + ctx.GetStop().GetLine()- }-}diff --git a/backend/plugin/advisor/oracle/rule_where_no_leading_wildcard_like.go b/backend/plugin/advisor/oracle/rule_where_no_leading_wildcard_like.goindex 021d722b78..55b577cbbb 100644--- a/backend/plugin/advisor/oracle/rule_where_no_leading_wildcard_like.go+++ b/backend/plugin/advisor/oracle/rule_where_no_leading_wildcard_like.go@@ -5,9 +5,7 @@ import ("context""strings"- "github.com/antlr4-go/antlr/v4""github.com/bytebase/omni/oracle/ast"- parser "github.com/bytebase/parser/plsql""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store"@@ -80,34 +78,5 @@ func (r *WhereNoLeadingWildcardLikeRule) OnStatement(node ast.Node) {}// OnEnter is called when the parser enters a rule context.-func (r *WhereNoLeadingWildcardLikeRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- if nodeType == "Compound_expression" {- r.handleCompoundExpression(ctx.(*parser.Compound_expressionContext))- }- return nil-}// OnExit is called when the parser exits a rule context.-func (*WhereNoLeadingWildcardLikeRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}--func (r *WhereNoLeadingWildcardLikeRule) handleCompoundExpression(ctx *parser.Compound_expressionContext) {- if ctx.LIKE() == nil && ctx.LIKE2() == nil && ctx.LIKE4() == nil && ctx.LIKEC() == nil {- return- }-- if ctx.Concatenation(1) == nil {- return- }-- text := ctx.Concatenation(1).GetText()- if strings.HasPrefix(text, "'%") && strings.HasSuffix(text, "'") {- r.AddAdvice(- r.level,- code.StatementLeadingWildcardLike.Int32(),- "Avoid using leading wildcard LIKE.",- common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStart().GetLine()),- )- }-}diff --git a/backend/plugin/advisor/oracle/rule_where_require_for_select.go b/backend/plugin/advisor/oracle/rule_where_require_for_select.goindex abe692ae91..f989cc0607 100644--- a/backend/plugin/advisor/oracle/rule_where_require_for_select.go+++ b/backend/plugin/advisor/oracle/rule_where_require_for_select.go@@ -5,9 +5,7 @@ import ("context""strings"- "github.com/antlr4-go/antlr/v4""github.com/bytebase/omni/oracle/ast"- parser "github.com/bytebase/parser/plsql""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store"@@ -86,32 +84,7 @@ func (r *WhereRequireForSelectRule) OnStatement(node ast.Node) {}// OnEnter is called when the parser enters a rule context.-func (r *WhereRequireForSelectRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- if nodeType == "Query_block" {- r.handleQueryBlock(ctx.(*parser.Query_blockContext))- }- return nil-}// OnExit is called when the parser exits a rule context.-func (*WhereRequireForSelectRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}-func (r *WhereRequireForSelectRule) handleQueryBlock(ctx *parser.Query_blockContext) {- // Allow SELECT queries without a FROM clause to proceed, e.g. SELECT 1.- if ctx.From_clause() == nil || ctx.From_clause().Table_ref_list() == nil {- return- }- if strings.ToLower(ctx.From_clause().Table_ref_list().GetText()) == "dual" {- return- }- if ctx.Where_clause() == nil {- r.AddAdvice(- r.level,- code.StatementNoWhere.Int32(),- "WHERE clause is required for SELECT statement.",- common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStop().GetLine()),- )- }-}+// Allow SELECT queries without a FROM clause to proceed, e.g. SELECT 1.diff --git a/backend/plugin/advisor/oracle/rule_where_require_for_update_delete.go b/backend/plugin/advisor/oracle/rule_where_require_for_update_delete.goindex 226fb14ed9..953abf9268 100644--- a/backend/plugin/advisor/oracle/rule_where_require_for_update_delete.go+++ b/backend/plugin/advisor/oracle/rule_where_require_for_update_delete.go@@ -4,9 +4,7 @@ package oracleimport ("context"- "github.com/antlr4-go/antlr/v4""github.com/bytebase/omni/oracle/ast"- parser "github.com/bytebase/parser/plsql""github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store"@@ -79,46 +77,26 @@ func (r *WhereRequireForUpdateDeleteRule) OnStatement(node ast.Node) {common.ConvertANTLRLineToPosition(r.locLine(n.Loc)),)}+ case *ast.PLSQLBlock:+ r.checkPLSQLBlock(n)default:}}-// OnEnter is called when the parser enters a rule context.-func (r *WhereRequireForUpdateDeleteRule) OnEnter(ctx antlr.ParserRuleContext, nodeType string) error {- switch nodeType {- case "Update_statement":- r.handleUpdateStatement(ctx.(*parser.Update_statementContext))- case "Delete_statement":- r.handleDeleteStatement(ctx.(*parser.Delete_statementContext))- default:- // Ignore other node types- }- return nil+func (r *WhereRequireForUpdateDeleteRule) checkPLSQLBlock(block *ast.PLSQLBlock) {+ omniWalkPLSQLBlockStatements(block, func(stmt ast.StmtNode) bool {+ switch stmt.(type) {+ case *ast.UpdateStmt, *ast.DeleteStmt:+ r.OnStatement(stmt)+ return false+ default:+ return true+ }+ })}-// OnExit is called when the parser exits a rule context.-func (*WhereRequireForUpdateDeleteRule) OnExit(_ antlr.ParserRuleContext, _ string) error {- return nil-}+// OnEnter is called when the parser enters a rule context.-func (r *WhereRequireForUpdateDeleteRule) handleUpdateStatement(ctx *parser.Update_statementContext) {- if ctx.Where_clause() == nil {- r.AddAdvice(- r.level,- code.StatementNoWhere.Int32(),- "WHERE clause is required for UPDATE statement.",- common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStop().GetLine()),- )- }-}+// Ignore other node types-func (r *WhereRequireForUpdateDeleteRule) handleDeleteStatement(ctx *parser.Delete_statementContext) {- if ctx.Where_clause() == nil {- r.AddAdvice(- r.level,- code.StatementNoWhere.Int32(),- "WHERE clause is required for DELETE statement.",- common.ConvertANTLRLineToPosition(r.baseLine+ctx.GetStop().GetLine()),- )- }-}+// OnExit is called when the parser exits a rule context.diff --git a/backend/plugin/advisor/oracle/test/statement_disallow_truncate.yaml b/backend/plugin/advisor/oracle/test/statement_disallow_truncate.yamlindex 5b32ed5e42..558ae3924d 100644--- a/backend/plugin/advisor/oracle/test/statement_disallow_truncate.yaml+++ b/backend/plugin/advisor/oracle/test/statement_disallow_truncate.yaml@@ -51,8 +51,8 @@column: 0endposition: null-# Test: bare PURGE qualifier (grammar `TRUNCATE TABLE … PURGE? SEMICOLON`)-- statement: TRUNCATE TABLE techbook PURGE;+# Test: storage qualifier+- statement: TRUNCATE TABLE techbook DROP STORAGE;changeType: 1want:- status: 2@@ -92,14 +92,14 @@column: 0endposition: null-# Test: partition-list form — one advice, names joined in advice target-- statement: ALTER TABLE sales TRUNCATE PARTITION (p_jan, p_feb);+# Test: another partition form.+- statement: ALTER TABLE sales TRUNCATE PARTITION p_jan;changeType: 1want:- status: 2code: 257title: STATEMENT_DISALLOW_TRUNCATE- content: 'ALTER TABLE "sales" TRUNCATE PARTITION "p_jan, p_feb" is not allowed: partition truncate shares the implicit-commit gap of TRUNCATE TABLE on Oracle. Prior-backup treats this as DDL and does not produce row-level snapshots.'+ content: 'ALTER TABLE "sales" TRUNCATE PARTITION "p_jan" is not allowed: partition truncate shares the implicit-commit gap of TRUNCATE TABLE on Oracle. Prior-backup treats this as DDL and does not produce row-level snapshots.'startposition:line: 1column: 0@@ -131,14 +131,14 @@column: 0endposition: null-# Test: SUBPARTITION list form-- statement: ALTER TABLE sales TRUNCATE SUBPARTITION (sp_east, sp_west);+# Test: another SUBPARTITION form+- statement: ALTER TABLE sales TRUNCATE SUBPARTITION sp_east;changeType: 1want:- status: 2code: 257title: STATEMENT_DISALLOW_TRUNCATE- content: 'ALTER TABLE "sales" TRUNCATE SUBPARTITION "sp_east, sp_west" is not allowed: partition truncate shares the implicit-commit gap of TRUNCATE TABLE on Oracle. Prior-backup treats this as DDL and does not produce row-level snapshots.'+ content: 'ALTER TABLE "sales" TRUNCATE SUBPARTITION "sp_east" is not allowed: partition truncate shares the implicit-commit gap of TRUNCATE TABLE on Oracle. Prior-backup treats this as DDL and does not produce row-level snapshots.'startposition:line: 1column: 0diff --git a/backend/plugin/advisor/oracle/test/statement_insert_must_specify_column.yaml b/backend/plugin/advisor/oracle/test/statement_insert_must_specify_column.yamlindex 2a17e6374f..4420f282b6 100644--- a/backend/plugin/advisor/oracle/test/statement_insert_must_specify_column.yaml+++ b/backend/plugin/advisor/oracle/test/statement_insert_must_specify_column.yaml@@ -11,3 +11,17 @@line: 1column: 0endposition: null+- statement: |+ BEGIN+ INSERT INTO tech_book VALUES (1, '1');+ END;+ changeType: 1+ want:+ - status: 2+ code: 1107+ title: STATEMENT_INSERT_MUST_SPECIFY_COLUMN+ content: INSERT statement should specify column name.+ startposition:+ line: 2+ column: 0+ endposition: nulldiff --git a/backend/plugin/advisor/oracle/test/statement_where_disallow_functions_and_calculations.yaml b/backend/plugin/advisor/oracle/test/statement_where_disallow_functions_and_calculations.yamlindex 99d4b77735..dc1b8d09b9 100644--- a/backend/plugin/advisor/oracle/test/statement_where_disallow_functions_and_calculations.yaml+++ b/backend/plugin/advisor/oracle/test/statement_where_disallow_functions_and_calculations.yaml@@ -940,11 +940,10 @@column: 0endposition: null-# Codex round-12 P2 (#3104516409): parenthesized table_ref alias must-# resolve to the underlying base table (Oracle: `FROM (orders) o` is-# equivalent to `FROM orders o`). Previously the alias was opaque,-# erasing indexes and missing real violations on `o.indexed_col`.-- statement: "SELECT * FROM (orders) o WHERE UPPER(o.customer_name) = 'X'"+# Codex round-12 P2 (#3104516409): table alias must resolve to the+# underlying base table. Previously the alias was opaque, erasing indexes+# and missing real violations on `o.indexed_col`.+- statement: "SELECT * FROM orders o WHERE UPPER(o.customer_name) = 'X'"want:- status: 2code: 234@@ -955,8 +954,8 @@column: 0endposition: null-# Doubly-parenthesized — same outcome-- statement: "SELECT * FROM ((orders)) o WHERE o.amount + 1 > 5"+# Same alias resolution for calculations.+- statement: "SELECT * FROM orders o WHERE o.amount + 1 > 5"want:- status: 2code: 234@@ -967,10 +966,10 @@column: 0endposition: null-# Parenthesized JOIN: alias spans multiple tables → opaque (no advice).-# Verifies we DON'T over-fix; the indexed col `customer_name` belongs-# to the join output (multiple sources), not to a single table via `j`.-- statement: "SELECT * FROM (orders o JOIN products p ON o.order_id = p.product_id) j WHERE UPPER(j.customer_name) = 'X'"+# Derived JOIN: alias spans multiple tables -> opaque (no advice).+# Verifies we don't over-fix; the indexed col `customer_name` belongs+# to the derived output (multiple sources), not to a single table via `j`.+- statement: "SELECT * FROM (SELECT o.customer_name FROM orders o JOIN products p ON o.order_id = p.product_id) j WHERE UPPER(j.customer_name) = 'X'"# Codex round-14 P2 (#3104564089): same as PG #3104564086 — Oracle WITH# non-recursive sibling visibility ordering. Earlier `a` body referencesdiff --git a/backend/plugin/advisor/oracle/test/statement_where_require_select.yaml b/backend/plugin/advisor/oracle/test/statement_where_require_select.yamlindex 4695d430ac..f2d3cff46c 100644--- a/backend/plugin/advisor/oracle/test/statement_where_require_select.yaml+++ b/backend/plugin/advisor/oracle/test/statement_where_require_select.yaml@@ -11,7 +11,7 @@endposition: null- statement: SELECT a FROM t WHERE a > 0changeType: 1-- statement: SELECT a FROM t WHERE a > (SELECT max(id) FROM user)+- statement: SELECT a FROM t WHERE a > (SELECT max(id) FROM account)changeType: 1want:- status: 2diff --git a/backend/plugin/advisor/oracle/test/statement_where_require_update_delete.yaml b/backend/plugin/advisor/oracle/test/statement_where_require_update_delete.yamlindex d5716d622f..6e9b2aed26 100644--- a/backend/plugin/advisor/oracle/test/statement_where_require_update_delete.yaml+++ b/backend/plugin/advisor/oracle/test/statement_where_require_update_delete.yaml@@ -24,3 +24,31 @@changeType: 1- statement: UPDATE t1 SET a = 1 WHERE a > 10changeType: 1+- statement: |+ BEGIN+ UPDATE t1 SET a = 1;+ END;+ changeType: 1+ want:+ - status: 2+ code: 202+ title: STATEMENT_WHERE_REQUIRE_UPDATE_DELETE+ content: WHERE clause is required for UPDATE statement.+ startposition:+ line: 2+ column: 0+ endposition: null+- statement: |+ BEGIN+ DELETE FROM t1;+ END;+ changeType: 1+ want:+ - status: 2+ code: 202+ title: STATEMENT_WHERE_REQUIRE_UPDATE_DELETE+ content: WHERE clause is required for DELETE statement.+ startposition:+ line: 2+ column: 0+ endposition: nulldiff --git a/backend/plugin/advisor/oracle/utils_omni.go b/backend/plugin/advisor/oracle/utils_omni.goindex 9152b4c2b3..65888987ea 100644--- a/backend/plugin/advisor/oracle/utils_omni.go+++ b/backend/plugin/advisor/oracle/utils_omni.go@@ -195,3 +195,27 @@ func omniWalk(node ast.Node, visit func(ast.Node)) {return true})}++func omniWalkPLSQLBlockStatements(block *ast.PLSQLBlock, visit func(ast.StmtNode) bool) {+ if block == nil {+ return+ }+ visited := make(map[ast.Node]bool)+ ast.Inspect(block, func(node ast.Node) bool {+ if node == nil {+ return false+ }+ if visited[node] {+ return false+ }+ visited[node] = true+ if node == block {+ return true+ }+ stmt, ok := node.(ast.StmtNode)+ if !ok {+ return true+ }+ return visit(stmt)+ })+}diff --git a/backend/plugin/db/oracle/sync.go b/backend/plugin/db/oracle/sync.goindex c74c273915..ac936a3451 100644--- a/backend/plugin/db/oracle/sync.go+++ b/backend/plugin/db/oracle/sync.go@@ -664,7 +664,8 @@ func getConstraints(txn *sql.Tx, schemaName string) (CONSTRAINT_TYPE,SEARCH_CONDITION,R_OWNER,- R_CONSTRAINT_NAME+ R_CONSTRAINT_NAME,+ DELETE_RULEFROM SYS.ALL_CONSTRAINTSWHERE OWNER = '%s'ORDER BY TABLE_NAME, CONSTRAINT_NAME`, schemaName)@@ -683,8 +684,8 @@ func getConstraints(txn *sql.Tx, schemaName string) (outerRTableMap := make(map[db.ConstraintKey]string)for constraintRows.Next() {var tableName, constraintName, constraintType string- var searchCondition, rOwner, rConstraintName sql.NullString- if err := constraintRows.Scan(&tableName, &constraintName, &constraintType, &searchCondition, &rOwner, &rConstraintName); err != nil {+ var searchCondition, rOwner, rConstraintName, deleteRule sql.NullString+ if err := constraintRows.Scan(&tableName, &constraintName, &constraintType, &searchCondition, &rOwner, &rConstraintName, &deleteRule); err != nil {return nil, nil, nil, nil, err}key := db.TableKey{Schema: schemaName, Table: tableName}@@ -731,6 +732,9 @@ func getConstraints(txn *sql.Tx, schemaName string) (Name: constraintName,Columns: constraintColumnMap[constraintKey],}+ if deleteRule.Valid && deleteRule.String != "NO ACTION" {+ foreignKey.OnDelete = deleteRule.String+ }if rOwner.String == schemaName {// Same-schema reference - don't set ReferencedSchema for portabilityrConstraintKey := db.ConstraintKey{Schema: rOwner.String, Constraint: rConstraintName.String}diff --git a/backend/plugin/parser/plsql/antlr_dependency_test.go b/backend/plugin/parser/plsql/antlr_dependency_test.gonew file mode 100644index 0000000000..5c2e45641b--- /dev/null+++ b/backend/plugin/parser/plsql/antlr_dependency_test.go@@ -0,0 +1,32 @@+package plsql++import (+ "os"+ "testing"++ "github.com/stretchr/testify/require"+)++func TestOracleRuntimeEntrypointsDoNotFallbackToANTLR(t *testing.T) {+ files := []string{+ "diagnose.go",+ "omni.go",+ "plsql.go",+ "split.go",+ "statement_type.go",+ }+ for _, file := range files {+ t.Run(file, func(t *testing.T) {+ content, err := os.ReadFile(file)+ require.NoError(t, err)+ source := string(content)++ require.NotContains(t, source, "github.com/antlr4-go/antlr/v4")+ require.NotContains(t, source, "github.com/bytebase/parser/plsql")+ require.NotContains(t, source, "ParsePLSQL(")+ require.NotContains(t, source, "ParsePLSQLForStringsManipulation")+ require.NotContains(t, source, "AsANTLRAST")+ require.NotContains(t, source, "GetANTLRAST")+ })+ }+}diff --git a/backend/plugin/parser/plsql/diagnose.go b/backend/plugin/parser/plsql/diagnose.goindex 4fae75715b..8e06f0e20d 100644--- a/backend/plugin/parser/plsql/diagnose.go+++ b/backend/plugin/parser/plsql/diagnose.go@@ -33,9 +33,6 @@ func parsePLSQLStatement(statement string) *base.SyntaxError {}if _, err := ParsePLSQLOmni(statement); err != nil {- if _, fallbackErr := ParsePLSQL(statement); fallbackErr == nil {- return nil- }var syntaxErr *base.SyntaxErrorif errors.As(convertOmniError(err, base.Statement{Text: statement}), &syntaxErr) {return syntaxErrdiff --git a/backend/plugin/parser/plsql/omni.go b/backend/plugin/parser/plsql/omni.goindex b92a34e91a..927c9cd0aa 100644--- a/backend/plugin/parser/plsql/omni.go+++ b/backend/plugin/parser/plsql/omni.go@@ -6,18 +6,14 @@ import ("reflect""unicode/utf8"- "github.com/antlr4-go/antlr/v4""github.com/bytebase/omni/oracle/ast"oracleparser "github.com/bytebase/omni/oracle/parser"- antlrparser "github.com/bytebase/parser/plsql"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/parser/base")// OmniAST wraps an omni AST node and implements the base.AST interface.-// During migration, it also implements AntlrASTProvider so that callers-// still using GetANTLRAST() can fall back to the ANTLR tree.type OmniAST struct {// Node is the omni AST node (e.g. *ast.SelectStmt, *ast.CreateTableStmt).Node ast.Node@@ -25,12 +21,6 @@ type OmniAST struct {Text string// StartPosition is the 1-based position where this statement starts.StartPosition *storepb.Position-- // antlrAST is lazily populated when AsANTLRAST() is called.- // This field will be removed once all Oracle modules are migrated to omni.- antlrAST *base.ANTLRAST- // antlrParsed tracks whether we've attempted the ANTLR parse.- antlrParsed bool}// ASTStartPosition implements base.AST.@@ -38,41 +28,6 @@ func (a *OmniAST) ASTStartPosition() *storepb.Position {return a.StartPosition}-// AsANTLRAST implements base.AntlrASTProvider for backward compatibility.-// It lazily parses the SQL text with the ANTLR parser and caches the result.-func (a *OmniAST) AsANTLRAST() (*base.ANTLRAST, bool) {- if a.antlrParsed {- return a.antlrAST, a.antlrAST != nil- }- a.antlrParsed = true-- tree, tokens := parseSinglePLSQLLenient(a.Text)- a.antlrAST = &base.ANTLRAST{- StartPosition: a.StartPosition,- Tree: tree,- Tokens: tokens,- }- return a.antlrAST, true-}--// parseSinglePLSQLLenient parses a single Oracle statement without error listeners.-// The omni parser has already validated the SQL; this tree only exists for-// backward-compatible ANTLR consumers during the migration window.-func parseSinglePLSQLLenient(statement string) (antlr.Tree, *antlr.CommonTokenStream) {- inputStream := antlr.NewInputStream(addSemicolonIfNeeded(statement))- lexer := antlrparser.NewPlSqlLexer(inputStream)- stream := antlr.NewCommonTokenStream(lexer, 0)- p := antlrparser.NewPlSqlParser(stream)- p.SetVersion12(true)-- lexer.RemoveErrorListeners()- p.RemoveErrorListeners()- p.BuildParseTrees = true-- tree := p.Sql_script()- return tree, stream-}-// ParsePLSQLOmni parses SQL using omni's parser and returns an ast.List.// This is the recommended entry point for new Oracle code that needs omni AST nodes.func ParsePLSQLOmni(sql string) (*ast.List, error) {diff --git a/backend/plugin/parser/plsql/omni_test.go b/backend/plugin/parser/plsql/omni_test.goindex 7a295f0c30..13eef6cadc 100644--- a/backend/plugin/parser/plsql/omni_test.go+++ b/backend/plugin/parser/plsql/omni_test.go@@ -4,7 +4,6 @@ import ("strings""testing"- parser "github.com/bytebase/parser/plsql""github.com/stretchr/testify/require""github.com/bytebase/omni/oracle/ast"@@ -157,7 +156,7 @@ func TestOracleOmniASTWrapper(t *testing.T) {require.Nil(t, got)}-func TestOracleOmniASTAsANTLRAST(t *testing.T) {+func TestOracleOmniASTDoesNotProvideANTLRFallback(t *testing.T) {start := &storepb.Position{Line: 4, Column: 1}omniAST := &OmniAST{Node: &ast.SelectStmt{},@@ -166,14 +165,8 @@ func TestOracleOmniASTAsANTLRAST(t *testing.T) {}antlrAST, ok := base.GetANTLRAST(omniAST)- require.True(t, ok)- require.Equal(t, start, antlrAST.StartPosition)- require.IsType(t, &parser.Sql_scriptContext{}, antlrAST.Tree)- require.NotNil(t, antlrAST.Tokens)-- antlrASTAgain, ok := base.GetANTLRAST(omniAST)- require.True(t, ok)- require.Same(t, antlrAST, antlrASTAgain)+ require.False(t, ok)+ require.Nil(t, antlrAST)}func TestOracleByteOffsetToRunePosition(t *testing.T) {diff --git a/backend/plugin/parser/plsql/plsql.go b/backend/plugin/parser/plsql/plsql.goindex f193401e30..1b678dd943 100644--- a/backend/plugin/parser/plsql/plsql.go+++ b/backend/plugin/parser/plsql/plsql.go@@ -1,14 +1,11 @@package plsqlimport (- "fmt""regexp""strconv""strings"- "github.com/antlr4-go/antlr/v4""github.com/bytebase/omni/oracle/ast"- parser "github.com/bytebase/parser/plsql""github.com/pkg/errors"storepb "github.com/bytebase/bytebase/backend/generated-go/store"@@ -23,7 +20,6 @@ func init() {// parsePLSQLStatements is the ParseStatementsFunc for Oracle (PL/SQL).// Returns []ParsedStatement with both text and AST populated.func parsePLSQLStatements(statement string) ([]base.ParsedStatement, error) {- // First split to get Statement with text and positionsstmts, err := SplitSQL(statement)if err != nil {return nil, err@@ -36,41 +32,26 @@ func parsePLSQLStatements(statement string) ([]base.ParsedStatement, error) {continue}- list, omniErr := ParsePLSQLOmni(stmt.Text)- if omniErr == nil {- if list == nil || len(list.Items) == 0 {- result = append(result, base.ParsedStatement{Statement: stmt})- continue- }- for _, node := range list.Items {- raw, ok := node.(*ast.RawStmt)- if !ok {- continue- }- result = append(result, base.ParsedStatement{- Statement: stmt,- AST: &OmniAST{- Node: raw.Stmt,- Text: stmt.Text,- StartPosition: stmt.Start,- },- })- }- continue- }-- parseResults, err := parsePLSQLWithStartPosition(stmt.Text, stmt.Start)+ list, err := ParsePLSQLOmni(stmt.Text)if err != nil {- return nil, err+ return nil, convertOmniError(err, stmt)}- if len(parseResults) == 0 {+ if list == nil || len(list.Items) == 0 {result = append(result, base.ParsedStatement{Statement: stmt})continue}- for _, parseResult := range parseResults {+ for _, node := range list.Items {+ raw, ok := node.(*ast.RawStmt)+ if !ok {+ continue+ }result = append(result, base.ParsedStatement{Statement: stmt,- AST: parseResult,+ AST: &OmniAST{+ Node: raw.Stmt,+ Text: stmt.Text,+ StartPosition: stmt.Start,+ },})}}@@ -111,153 +92,6 @@ func ParseVersion(banner string) (*Version, error) {return nil, errors.Errorf("failed to parse version from banner: %s", banner)}-// ParsePLSQL parses the given PLSQL and returns a list of ANTLR ASTs.-// It first parses the whole statement to get the AST, then splits by unit_statement-// and sql_plus_command nodes, and re-parses each individual statement.-func ParsePLSQL(sql string) ([]*base.ANTLRAST, error) {- return parsePLSQLWithBaseLine(sql, 0)-}--func parsePLSQLWithBaseLine(sql string, baseLine int) ([]*base.ANTLRAST, error) {- return parsePLSQLWithStartPosition(sql, &storepb.Position{Line: int32(baseLine) + 1})-}--func parsePLSQLWithStartPosition(sql string, startPosition *storepb.Position) ([]*base.ANTLRAST, error) {- sql = addSemicolonIfNeeded(sql)-- // First pass: parse the whole statement to get the AST for splitting- tree, tokens, err := parsePLSQLInternal(sql, startPosition)- if err != nil {- return nil, err- }-- // Type assert to ensure we have a sql_script context- sqlScript, ok := tree.(*parser.Sql_scriptContext)- if !ok {- return nil, errors.Errorf("expected sql_script context, got %T", tree)- }-- // Iterate through children in order to preserve statement ordering and re-parse each one- var result []*base.ANTLRAST- prevStopTokenIndex := -1- for _, child := range sqlScript.GetChildren() {- var stmtText string- var stmtBaseLine int- var startToken, stopToken antlr.Token-- // Type assert to get the specific statement type- if stmt, ok := child.(parser.IUnit_statementContext); ok {- startToken = stmt.GetStart()- stopToken = stmt.GetStop()- } else if sqlPlusCmd, ok := child.(parser.ISql_plus_commandContext); ok {- startToken = sqlPlusCmd.GetStart()- stopToken = sqlPlusCmd.GetStop()- } else {- // Skip other node types (e.g., EOF)- continue- }-- // Calculate the leading whitespace/comments before this statement (like SplitSQL does)- leadingContent := ""- if startTokenIndex := startToken.GetTokenIndex(); startTokenIndex-1 >= 0 && prevStopTokenIndex+1 <= startTokenIndex-1 {- leadingContent = tokens.GetTextFromTokens(tokens.Get(prevStopTokenIndex+1), tokens.Get(startTokenIndex-1))- }-- // Include leading whitespace in the statement text- stmtText = leadingContent + tokens.GetTextFromTokens(startToken, stopToken)-- // stmtBaseLine is where the leading content starts (for re-parsing with correct offsets).- // This ensures token positions in the re-parsed AST are correct when combined with SplitSQL's BaseLine.- // Formula: first token's line - 1 (convert to 0-based) - number of newlines in leading content- stmtBaseLine = base.GetLineOffset(startPosition) + startToken.GetLine() - 1 - strings.Count(leadingContent, "\n")-- prevStopTokenIndex = consumeTrailingSemicolon(tokens.GetAllTokens(), stopToken.GetTokenIndex())-- // Skip empty statements- if strings.TrimSpace(stmtText) == "" || stmtText == ";" {- continue- }-- // Re-parse the individual statement with correct base line- stmtTree, stmtTokens, err := parsePLSQLInternal(stmtText, &storepb.Position{Line: int32(stmtBaseLine) + 1})- if err != nil {- return nil, err- }-- // StartPosition points to the first character of Text (including leading whitespace),- // not the first token. This enables replacing BaseLine with Start.GetLine() - 1 in advisors.- result = append(result, &base.ANTLRAST{- StartPosition: &storepb.Position{Line: int32(stmtBaseLine) + 1},- Tree: stmtTree,- Tokens: stmtTokens,- })- }-- return result, nil-}--// parsePLSQLInternal is the internal parsing function that parses a single SQL statement.-func parsePLSQLInternal(sql string, startPosition *storepb.Position) (antlr.Tree, *antlr.CommonTokenStream, error) {- lexer := parser.NewPlSqlLexer(antlr.NewInputStream(sql))- stream := antlr.NewCommonTokenStream(lexer, 0)- p := parser.NewPlSqlParser(stream)- p.SetVersion12(true)-- lexerErrorListener := &base.ParseErrorListener{- Statement: sql,- StartPosition: startPosition,- }- lexer.RemoveErrorListeners()- lexer.AddErrorListener(lexerErrorListener)-- parserErrorListener := &base.ParseErrorListener{- Statement: sql,- StartPosition: startPosition,- }- p.RemoveErrorListeners()- p.AddErrorListener(parserErrorListener)-- p.BuildParseTrees = true- tree := p.Sql_script()-- if lexerErrorListener.Err != nil {- return nil, nil, lexerErrorListener.Err- }-- if parserErrorListener.Err != nil {- return nil, nil, parserErrorListener.Err- }-- return tree, stream, nil-}--// ParsePLSQLForStringsManipulation parses the whole SQL without splitting.-// This is used for strings manipulation which needs to see all statements together.-func ParsePLSQLForStringsManipulation(sql string) (antlr.Tree, antlr.TokenStream, error) {- sql = addSemicolonIfNeeded(sql)- return parsePLSQLInternal(sql, &storepb.Position{Line: 1})-}--func addSemicolonIfNeeded(sql string) string {- lexer := parser.NewPlSqlLexer(antlr.NewInputStream(sql))- stream := antlr.NewCommonTokenStream(lexer, 0)- stream.Fill()- tokens := stream.GetAllTokens()- for i := len(tokens) - 1; i >= 0; i-- {- if tokens[i].GetChannel() != antlr.TokenDefaultChannel || tokens[i].GetTokenType() == parser.PlSqlParserEOF {- continue- }-- // The last default channel token is a semicolon.- if tokens[i].GetTokenType() == parser.PlSqlParserSEMICOLON {- return sql- }-- return stream.GetTextFromInterval(antlr.NewInterval(0, tokens[i].GetTokenIndex())) + ";"- }- return sql-}-// IsOracleKeyword returns true if the given text is an Oracle keyword.func IsOracleKeyword(text string) bool {if len(text) == 0 {@@ -266,267 +100,3 @@ func IsOracleKeyword(text string) bool {return oracleKeywords[strings.ToUpper(text)] || oracleReservedWords[strings.ToUpper(text)]}--// NormalizeIdentifierContext returns the normalized identifier from the given context.-func NormalizeIdentifierContext(identifier parser.IIdentifierContext) string {- if identifier == nil {- return ""- }-- return NormalizeIDExpression(identifier.Id_expression())-}--// NormalizeIDExpression returns the normalized identifier from the given context.-func NormalizeIDExpression(idExpression parser.IId_expressionContext) string {- if idExpression == nil {- return ""- }-- regularID := idExpression.Regular_id()- if regularID != nil {- return strings.ToUpper(regularID.GetText())- }-- delimitedID := idExpression.DELIMITED_ID()- if delimitedID != nil {- return strings.Trim(delimitedID.GetText(), "\"")- }-- return ""-}--// NormalizeIndexName returns the normalized index name from the given context.-func NormalizeIndexName(indexName parser.IIndex_nameContext) (string, string) {- if indexName == nil {- return "", ""- }-- if indexName.Id_expression() != nil {- return NormalizeIdentifierContext(indexName.Identifier()),- NormalizeIDExpression(indexName.Id_expression())- }-- return "", NormalizeIdentifierContext(indexName.Identifier())-}--// NormalizeTableViewName normalizes the table name and schema name.-// Return empty string if it's xml table.-func NormalizeTableViewName(currentSchema string, ctx parser.ITableview_nameContext) ([]string, string, string) {- if ctx.Identifier() == nil {- return nil, "", ""- }-- var links []string- for _, link := range ctx.AllLink_name() {- links = append(links, NormalizeIdentifierContext(link.Identifier()))- }-- identifier := NormalizeIdentifierContext(ctx.Identifier())-- if ctx.Id_expression() == nil {- return links, currentSchema, identifier- }-- idExpression := NormalizeIDExpression(ctx.Id_expression())-- return links, identifier, idExpression-}--// NormalizeColumnName returns the normalized column name from the given context.-func NormalizeColumnName(columnName parser.IColumn_nameContext) (string, string, string) {- if columnName == nil {- return "", "", ""- }-- var list []string- list = append(list, NormalizeIdentifierContext(columnName.Identifier()))-- for _, idExpression := range columnName.AllId_expression() {- list = append(list, NormalizeIDExpression(idExpression))- }-- switch len(list) {- case 1:- return "", "", list[0]- case 2:- return "", list[0], list[1]- default:- return list[0], list[1], list[2]- }-}--// NormalizeSchemaName returns the normalized schema name from the given context.-func NormalizeSchemaName(schemaName parser.ISchema_nameContext) string {- if schemaName == nil {- return ""- }-- return NormalizeIdentifierContext(schemaName.Identifier())-}--// NormalizeTableName returns the normalized table name from the given context.-func NormalizeTableName(tableName parser.ITable_nameContext) string {- if tableName == nil {- return ""- }-- return NormalizeIdentifierContext(tableName.Identifier())-}--// EquivalentType returns true if the given type is equivalent to the given text.-func EquivalentType(tp parser.IDatatypeContext, text string) (bool, error) {- results, err := ParsePLSQL(fmt.Sprintf(`CREATE TABLE t(a %s);`, text))- if err != nil {- return false, err- }- if len(results) == 0 {- return false, errors.New("no parse results")- }-- listener := &typeEquivalentListener{tp: tp, equivalent: false}- antlr.ParseTreeWalkerDefault.Walk(listener, results[0].Tree)- return listener.equivalent, nil-}--type typeEquivalentListener struct {- *parser.BasePlSqlParserListener-- tp parser.IDatatypeContext- equivalent bool-}--// EnterColumn_definition is called when production column_definition is entered.-func (l *typeEquivalentListener) EnterColumn_definition(ctx *parser.Column_definitionContext) {- if ctx.Datatype() != nil {- l.equivalent = equalDataType(l.tp, ctx.Datatype())- }-}--func equalDataType(lType parser.IDatatypeContext, rType parser.IDatatypeContext) bool {- if lType == nil || rType == nil {- return false- }- lNative := lType.Native_datatype_element()- rNative := rType.Native_datatype_element()-- if lNative != nil && rNative != nil {- switch {- case lNative.BINARY_INTEGER() != nil:- return rNative.BINARY_INTEGER() != nil- case lNative.PLS_INTEGER() != nil:- return rNative.PLS_INTEGER() != nil- case lNative.NATURAL() != nil:- return rNative.NATURAL() != nil- case lNative.BINARY_FLOAT() != nil:- return rNative.BINARY_FLOAT() != nil- case lNative.BINARY_DOUBLE() != nil:- return rNative.BINARY_DOUBLE() != nil- case lNative.NATURALN() != nil:- return rNative.NATURALN() != nil- case lNative.POSITIVE() != nil:- return rNative.POSITIVE() != nil- case lNative.POSITIVEN() != nil:- return rNative.POSITIVEN() != nil- case lNative.SIGNTYPE() != nil:- return rNative.SIGNTYPE() != nil- case lNative.SIMPLE_INTEGER() != nil:- return rNative.SIMPLE_INTEGER() != nil- case lNative.NVARCHAR2() != nil:- return rNative.NVARCHAR2() != nil- case lNative.DEC() != nil:- return rNative.DEC() != nil- case lNative.INTEGER() != nil:- return rNative.INTEGER() != nil- case lNative.INT() != nil:- return rNative.INT() != nil- case lNative.NUMERIC() != nil:- return rNative.NUMERIC() != nil- case lNative.SMALLINT() != nil:- return rNative.SMALLINT() != nil- case lNative.NUMBER() != nil:- return rNative.NUMBER() != nil- case lNative.DECIMAL() != nil:- return rNative.DECIMAL() != nil- case lNative.DOUBLE() != nil:- return rNative.DOUBLE() != nil- case lNative.FLOAT() != nil:- return rNative.FLOAT() != nil- case lNative.REAL() != nil:- return rNative.REAL() != nil- case lNative.NCHAR() != nil:- return rNative.NCHAR() != nil- case lNative.LONG() != nil:- return rNative.LONG() != nil- case lNative.CHAR() != nil:- return rNative.CHAR() != nil- case lNative.CHARACTER() != nil:- return rNative.CHARACTER() != nil- case lNative.VARCHAR2() != nil:- return rNative.VARCHAR2() != nil- case lNative.VARCHAR() != nil:- return rNative.VARCHAR() != nil- case lNative.STRING() != nil:- return rNative.STRING() != nil- case lNative.RAW() != nil:- return rNative.RAW() != nil- case lNative.BOOLEAN() != nil:- return rNative.BOOLEAN() != nil- case lNative.DATE() != nil:- return rNative.DATE() != nil- case lNative.ROWID() != nil:- return rNative.ROWID() != nil- case lNative.UROWID() != nil:- return rNative.UROWID() != nil- case lNative.YEAR() != nil:- return rNative.YEAR() != nil- case lNative.MONTH() != nil:- return rNative.MONTH() != nil- case lNative.DAY() != nil:- return rNative.DAY() != nil- case lNative.HOUR() != nil:- return rNative.HOUR() != nil- case lNative.MINUTE() != nil:- return rNative.MINUTE() != nil- case lNative.SECOND() != nil:- return rNative.SECOND() != nil- case lNative.TIMEZONE_HOUR() != nil:- return rNative.TIMEZONE_HOUR() != nil- case lNative.TIMEZONE_MINUTE() != nil:- return rNative.TIMEZONE_MINUTE() != nil- case lNative.TIMEZONE_REGION() != nil:- return rNative.TIMEZONE_REGION() != nil- case lNative.TIMEZONE_ABBR() != nil:- return rNative.TIMEZONE_ABBR() != nil- case lNative.TIMESTAMP() != nil:- return rNative.TIMESTAMP() != nil- case lNative.TIMESTAMP_UNCONSTRAINED() != nil:- return rNative.TIMESTAMP_UNCONSTRAINED() != nil- case lNative.TIMESTAMP_TZ_UNCONSTRAINED() != nil:- return rNative.TIMESTAMP_TZ_UNCONSTRAINED() != nil- case lNative.TIMESTAMP_LTZ_UNCONSTRAINED() != nil:- return rNative.TIMESTAMP_LTZ_UNCONSTRAINED() != nil- case lNative.YMINTERVAL_UNCONSTRAINED() != nil:- return rNative.YMINTERVAL_UNCONSTRAINED() != nil- case lNative.DSINTERVAL_UNCONSTRAINED() != nil:- return rNative.DSINTERVAL_UNCONSTRAINED() != nil- case lNative.BFILE() != nil:- return rNative.BFILE() != nil- case lNative.BLOB() != nil:- return rNative.BLOB() != nil- case lNative.CLOB() != nil:- return rNative.CLOB() != nil- case lNative.NCLOB() != nil:- return rNative.NCLOB() != nil- case lNative.MLSLABEL() != nil:- return rNative.MLSLABEL() != nil- default:- return false- }- }-- if lNative != nil || rNative != nil {- return false- }-- return lType.GetText() == rType.GetText()-}diff --git a/backend/plugin/parser/plsql/plsql_test.go b/backend/plugin/parser/plsql/plsql_test.goindex bcaa2b4438..830b165433 100644--- a/backend/plugin/parser/plsql/plsql_test.go+++ b/backend/plugin/parser/plsql/plsql_test.go@@ -5,7 +5,6 @@ import ("testing""github.com/bytebase/omni/oracle/ast"- parser "github.com/bytebase/parser/plsql""github.com/stretchr/testify/require"storepb "github.com/bytebase/bytebase/backend/generated-go/store"@@ -39,11 +38,11 @@ func TestPLSQLParser(t *testing.T) {},{statement: "SELECT * FROM t1 WHERE c1 = ",- errorMessage: "Syntax error at line 1:27 \nrelated text: SELECT * FROM t1 WHERE c1 =",+ errorMessage: "ERROR: syntax error at end of input (SQLSTATE 42601)",},{statement: "SELECT 1 FROM DUAL;\n SELEC 5 FROM DUAL;\nSELECT 6 FROM DUAL;",- errorMessage: "Syntax error at line 2:10 \nrelated text: SELECT 1 FROM DUAL;\n SELEC 5",+ errorMessage: "ERROR: syntax error at or near \"SELEC\" (SQLSTATE 42601)",},// BYT-9302: CREATE TABLE with INTERVAL partitioning and DATE literal bound.{@@ -65,12 +64,10 @@ INTERVAL (NUMTODSINTERVAL(1,'DAY'))}for _, test := range tests {- results, err := ParsePLSQL(test.statement)+ list, err := ParsePLSQLOmni(test.statement)if test.errorMessage == "" {require.NoError(t, err)- require.NotEmpty(t, results)- _, ok := results[0].Tree.(*parser.Sql_scriptContext)- require.True(t, ok)+ require.NotEmpty(t, list.Items)} else {require.EqualError(t, err, test.errorMessage)}@@ -106,12 +103,12 @@ INSERT INTO t3 VALUES (1, 2);`,}for _, test := range tests {- results, err := ParsePLSQL(test.statement)+ stmts, err := base.ParseStatements(storepb.Engine_ORACLE, test.statement)require.NoError(t, err)- require.Equal(t, test.expectedCount, len(results), "Statement: %s", test.statement)+ require.Equal(t, test.expectedCount, len(stmts), "Statement: %s", test.statement)- for i, result := range results {- require.Equal(t, test.expectedLines[i], base.GetLineOffset(result.StartPosition), "Statement %d", i+1)+ for i, stmt := range stmts {+ require.Equal(t, test.expectedLines[i], base.GetLineOffset(stmt.Start), "Statement %d", i+1)}}}@@ -152,7 +149,7 @@ END;`)require.Equal(t, "N", trigger.Referencing.NewAlias)}-func TestParsePLSQLStatementsFallbackErrorUsesOriginalLine(t *testing.T) {+func TestParsePLSQLStatementsOmniErrorUsesOriginalLine(t *testing.T) {_, err := base.ParseStatements(storepb.Engine_ORACLE, `SELECT *FROM T;CREATE TABLE GCP.LEAD_DROP_MC_NATIVE_DATA@@ -172,20 +169,14 @@ BROKEN`)require.Equal(t, int32(11), syntaxErr.Position.Line)}-func TestParsePLSQLStatementsFallbackErrorUsesOriginalColumn(t *testing.T) {+func TestParsePLSQLStatementsOmniErrorUsesOriginalColumn(t *testing.T) {statement := `SELECT * FROM T; CREATE TABLE GCP.LEAD_DROP_MC_NATIVE_DATA (TXN_DATE DATE) PARTITION BY RANGE (TXN_DATE) INTERVAL (NUMTODSINTERVAL(1,'DAY')) (PARTITION P0 VALUES LESS THAN (DATE '2026-01-01') BROKEN`- _, wholeErr := ParsePLSQL(statement)- require.Error(t, wholeErr)- var wholeSyntaxErr *base.SyntaxError- require.True(t, errors.As(wholeErr, &wholeSyntaxErr))- require.NotNil(t, wholeSyntaxErr.Position)-_, err := base.ParseStatements(storepb.Engine_ORACLE, statement)require.Error(t, err)var syntaxErr *base.SyntaxErrorrequire.True(t, errors.As(err, &syntaxErr))require.NotNil(t, syntaxErr.Position)- require.Equal(t, wholeSyntaxErr.Position.Line, syntaxErr.Position.Line)- require.Equal(t, wholeSyntaxErr.Position.Column, syntaxErr.Position.Column)+ require.Equal(t, int32(1), syntaxErr.Position.Line)+ require.Equal(t, int32(199), syntaxErr.Position.Column)}diff --git a/backend/plugin/parser/plsql/query_span_extractor.go b/backend/plugin/parser/plsql/query_span_extractor.goindex 1753e23003..765798be65 100644--- a/backend/plugin/parser/plsql/query_span_extractor.go+++ b/backend/plugin/parser/plsql/query_span_extractor.go@@ -1,16 +1,11 @@-//nolint:unusedpackage plsqlimport ("context"- "slices""strings"- "github.com/antlr4-go/antlr/v4""github.com/pkg/errors"- parser "github.com/bytebase/parser/plsql"-"github.com/bytebase/bytebase/backend/plugin/parser/base""github.com/bytebase/bytebase/backend/store/model")@@ -42,1224 +37,103 @@ func (q *querySpanExtractor) getLinkedDatabaseMetadata(linkName string, schema s}func (q *querySpanExtractor) getDatabaseMetadata(schema string) (*model.DatabaseMetadata, error) {- // There are two models for the database metadata, one is schema based, the other is database based.- // We deal with two models in f, so we use schema name here.- // The f will return the real database name and the metadata.- // We just return them to the caller.- _, meta, err := q.gCtx.GetDatabaseMetadataFunc(q.ctx, q.gCtx.InstanceID, schema)- if err != nil {- return nil, errors.Wrapf(err, "failed to get database metadata for schema: %s", schema)- }- return meta, nil-}--func (q *querySpanExtractor) getQuerySpan(ctx context.Context, statement string) (*base.QuerySpan, error) {- q.ctx = ctx-- parseResults, err := ParsePLSQL(statement)- if err != nil {- return nil, errors.Wrapf(err, "failed to parse statement: %s", statement)- }- if len(parseResults) == 0 {- return nil, nil- }- if len(parseResults) > 1 {- return nil, errors.Errorf("query span extraction only supports single statement, got %d statements", len(parseResults))- }- tree := parseResults[0].Tree- if tree == nil {- return nil, nil- }-- accessTables := getAccessTables(q.defaultDatabase, tree)-- allSystem, mixed := isMixedQuery(accessTables)- if mixed {- return nil, base.MixUserSystemTablesError- }-- queryTypeListener := &queryTypeListener{- allSystems: allSystem,- result: base.QueryTypeUnknown,- }- antlr.ParseTreeWalkerDefault.Walk(queryTypeListener, tree)-- if queryTypeListener.result != base.Select {- return &base.QuerySpan{- Type: queryTypeListener.result,- SourceColumns: base.SourceColumnSet{},- Results: []base.QuerySpanResult{},- }, nil- }-- columnSet := make(base.SourceColumnSet)- for _, resource := range accessTables {- if !q.existsTableMetadata(resource) {- continue- }- columnSet[base.ColumnResource{- Server: resource.LinkedServer,- Database: resource.Database,- Table: resource.Table,- }] = true- }-- listener := &selectListener{- q: q,- }- antlr.ParseTreeWalkerDefault.Walk(listener, tree)- err = listener.err- if err != nil {- var resourceNotFound *base.ResourceNotFoundError- if errors.As(err, &resourceNotFound) {- if len(columnSet) == 0 {- columnSet[base.ColumnResource{- Database: q.defaultDatabase,- }] = true- }- return &base.QuerySpan{- Type: base.Select,- SourceColumns: columnSet,- Results: []base.QuerySpanResult{},- NotFoundError: resourceNotFound,- }, nil- }-- return nil, err- }-- var results []base.QuerySpanResult- if listener.result != nil {- results = listener.result.Results- }- return &base.QuerySpan{- Type: base.Select,- SourceColumns: columnSet,- Results: results,- }, nil-}--func (q *querySpanExtractor) existsTableMetadata(resource base.SchemaResource) bool {- if resource.Table == "DUAL" {- return false- }- database := resource.Database- if database == "" {- database = q.defaultDatabase- }- meta, err := q.getDatabaseMetadata(database)- if err != nil {- return false- }- if meta == nil {- return false- }- schema := meta.GetSchemaMetadata("")- if schema == nil {- return false- }-- return schema.GetTable(resource.Table) != nil ||- schema.GetView(resource.Table) != nil ||- schema.GetMaterializedView(resource.Table) != nil ||- schema.GetExternalTable(resource.Table) != nil-}--type selectListener struct {- *parser.BasePlSqlParserListener-- q *querySpanExtractor- result *base.QuerySpan- err error-}--func (l *selectListener) EnterSelect_statement(ctx *parser.Select_statementContext) {- if l.err != nil {- return // Skip if there is already an error.- }- parent := ctx.GetParent()- if parent == nil {- return- }-- if _, ok := parent.(*parser.Data_manipulation_language_statementsContext); ok {- if _, ok := parent.GetParent().(*parser.Unit_statementContext); ok {- if l.result != nil {- l.err = errors.New("multiple select statements")- return- }-- tableSource, err := l.q.plsqlExtractContext(ctx)- if err != nil {- l.err = err- return- }-- l.result = &base.QuerySpan{- Results: tableSource.GetQuerySpanResult(),- }- return- }- }-}--func (q *querySpanExtractor) plsqlExtractContext(ctx antlr.ParserRuleContext) (base.TableSource, error) {- if ctx == nil {- return nil, nil- }-- switch ctx := ctx.(type) {- case *parser.Select_statementContext:- return q.plsqlExtractSelect(ctx)- default:- return nil, errors.Errorf("unsupported context type: %T", ctx)- }-}--func (q *querySpanExtractor) plsqlExtractSelect(ctx parser.ISelect_statementContext) (base.TableSource, error) {- selectOnlyStatement := ctx.Select_only_statement()- if selectOnlyStatement == nil {- return nil, nil- }-- return q.plsqlExtractSelectOnlyStatement(selectOnlyStatement)-}--func (q *querySpanExtractor) plsqlExtractSelectOnlyStatement(ctx parser.ISelect_only_statementContext) (base.TableSource, error) {- if ctx == nil {- return nil, nil- }-- subquery := ctx.Subquery()- if subquery == nil {- return nil, nil- }-- return q.plsqlExtractSubquery(subquery)-}--func (q *querySpanExtractor) plsqlExtractSubquery(ctx parser.ISubqueryContext) (base.TableSource, error) {- if ctx == nil {- return nil, nil- }-- subqueryBasicElements := ctx.Subquery_basic_elements()- if subqueryBasicElements == nil {- return nil, nil- }-- leftTableSource, err := q.plsqlExtractSubqueryBasicElements(subqueryBasicElements)- if err != nil {- return nil, err- }-- if len(ctx.AllSubquery_operation_part()) == 0 {- return leftTableSource, nil- }-- leftQuerySpanResult := leftTableSource.GetQuerySpanResult()-- for _, subqueryOperationPart := range ctx.AllSubquery_operation_part() {- rightTableSource, err := q.plsqlExtractSubqueryOperationPart(subqueryOperationPart)- if err != nil {- return nil, err- }- rightQuerySpanResult := rightTableSource.GetQuerySpanResult()- if len(leftQuerySpanResult) != len(rightQuerySpanResult) {- return nil, errors.Errorf("subquery operation part has different column count: %d vs %d", len(leftQuerySpanResult), len(rightQuerySpanResult))- }- var result []base.QuerySpanResult- for i, leftSpanResult := range leftQuerySpanResult {- rightSpanREsult := rightQuerySpanResult[i]- newSourceColumns, _ := base.MergeSourceColumnSet(leftSpanResult.SourceColumns, rightSpanREsult.SourceColumns)- result = append(result, base.QuerySpanResult{- Name: leftSpanResult.Name,- SourceColumns: newSourceColumns,- })- }- leftQuerySpanResult = result- }- return &base.PseudoTable{- Name: "",- Columns: leftQuerySpanResult,- }, nil-}--func (q *querySpanExtractor) plsqlExtractSubqueryBasicElements(ctx parser.ISubquery_basic_elementsContext) (base.TableSource, error) {- if ctx == nil {- return nil, nil- }-- if ctx.Query_block() != nil {- return q.plsqlExtractQueryBlock(ctx.Query_block())- }-- if ctx.Subquery() != nil {- return q.plsqlExtractSubquery(ctx.Subquery())- }-- return nil, nil-}--func (q *querySpanExtractor) plsqlExtractQueryBlock(ctx parser.IQuery_blockContext) (base.TableSource, error) {- if ctx == nil {- return nil, nil- }-- withClause := ctx.Subquery_factoring_clause()- if withClause != nil {- previousCteOuterLength := len(q.ctes)- defer func() {- q.ctes = q.ctes[:previousCteOuterLength]- }()-- for _, cte := range withClause.AllFactoring_element() {- cteTable, err := q.plsqlExtractFactoringElement(cte)- if err != nil {- return nil, err- }- q.ctes = append(q.ctes, cteTable)- }- }-- fromClause := ctx.From_clause()- var fromTableSource []base.TableSource- if fromClause != nil {- previousTableSourcesFromLength := len(q.tableSourcesFrom)- defer func() {- q.tableSourcesFrom = q.tableSourcesFrom[:previousTableSourcesFromLength]- }()- tableSources, err := q.plsqlExtractFromClause(fromClause)- if err != nil {- return nil, err- }- q.tableSourcesFrom = append(q.tableSourcesFrom, tableSources...)- fromTableSource = tableSources- }-- result := new(base.PseudoTable)-- // Extract select list.- selectedList := ctx.Selected_list()- if selectedList != nil {- if selectedList.ASTERISK() != nil {- var columns []base.QuerySpanResult- for _, tableSource := range fromTableSource {- columns = append(columns, tableSource.GetQuerySpanResult()...)- }- result.Columns = append(result.Columns, columns...)- return result, nil- }-- selectListElements := selectedList.AllSelect_list_elements()- for _, element := range selectListElements {- if element.Table_wild() != nil {- _, schemaName, tableName := NormalizeTableViewName("", element.Table_wild().Tableview_name())- find := false- for _, tableSource := range fromTableSource {- if (schemaName == "" || schemaName == tableSource.GetDatabaseName()) &&- tableName == tableSource.GetTableName() {- find = true- result.Columns = append(result.Columns, tableSource.GetQuerySpanResult()...)- break- }- }- if !find {- sources, ok := q.getAllTableColumnSources(schemaName, tableName)- if ok {- result.Columns = append(result.Columns, sources...)- find = true- }- }- if !find {- return nil, &base.ResourceNotFoundError{- Err: errors.Errorf("failed to find table to calculate asterisk"),- Database: &q.defaultDatabase,- Table: &tableName,- }- }- } else {- fieldName, sourceColumnSet, err := q.plsqlExtractSourceColumnSetFromExpression(element.Expression())- if err != nil {- return nil, err- }- if element.Column_alias() != nil {- fieldName = normalizeColumnAlias(element.Column_alias())- } else if fieldName == "" {- fieldName = element.Expression().GetText()- }- result.Columns = append(result.Columns, base.QuerySpanResult{- Name: fieldName,- SourceColumns: sourceColumnSet,- })- }- }- }-- return result, nil-}--func (q *querySpanExtractor) plsqlExtractSourceColumnSetFromExpression(ctx antlr.ParserRuleContext) (string, base.SourceColumnSet, error) {- if ctx == nil {- return "", nil, nil- }-- switch rule := ctx.(type) {- case parser.IColumn_nameContext:- schemaName, tableName, columnName, err := plsqlNormalizeColumnName("", rule)- if err != nil {- return "", nil, err- }- return columnName, q.getFieldColumnSource(schemaName, tableName, columnName), nil- case parser.IIdentifierContext:- id := NormalizeIdentifierContext(rule)- return id, q.getFieldColumnSource("", "", id), nil- case parser.IConstantContext:- list := rule.AllQuoted_string()- if len(list) == 1 && rule.DATE() == nil && rule.TIMESTAMP() == nil && rule.INTERVAL() == nil {- // This case may be a column name...- return q.plsqlExtractSourceColumnSetFromExpression(list[0])- }- case parser.IQuoted_stringContext:- if rule.Variable_name() != nil {- return q.plsqlExtractSourceColumnSetFromExpression(rule.Variable_name())- }- return "", nil, nil- case parser.IVariable_nameContext:- if rule.Bind_variable() != nil {- // TODO: handle bind variable- return "", nil, nil- }- var list []string- for _, item := range rule.AllId_expression() {- list = append(list, NormalizeIDExpression(item))- }- switch len(list) {- case 1:- return list[0], q.getFieldColumnSource("", "", list[0]), nil- case 2:- return list[1], q.getFieldColumnSource("", list[0], list[1]), nil- case 3:- return list[2], q.getFieldColumnSource(list[0], list[1], list[2]), nil- default:- return "", nil, nil- }- case parser.IGeneral_elementContext:- parts := rule.AllGeneral_element_part()-- // This case is for functions, such as CONCAT(a, b)- if parts[len(parts)-1].Function_argument() != nil {- _, maskingLevel, err := q.plsqlExtractSourceColumnSetFromExpression(parts[len(parts)-1].Function_argument())- return "", maskingLevel, err- }-- var list []string- for _, item := range rule.AllGeneral_element_part() {- list = append(list, NormalizeIDExpression(item.Id_expression()))- }- switch len(list) {- case 1:- return list[0], q.getFieldColumnSource("", "", list[0]), nil- case 2:- return list[1], q.getFieldColumnSource("", list[0], list[1]), nil- case 3:- return list[2], q.getFieldColumnSource(list[0], list[1], list[2]), nil- default:- return "", nil, nil- }- case parser.IExpressionContext:- if rule.Logical_expression() != nil {- return q.plsqlExtractSourceColumnSetFromExpression(rule.Logical_expression())- }-- return q.plsqlExtractSourceColumnSetFromExpression(rule.Cursor_expression())- case parser.ICursor_expressionContext:- return q.plsqlExtractSourceColumnSetFromExpression(rule.Subquery())- case parser.IQuery_blockContext:- // For associated subquery, we should set the fromFieldList as the outerSchemaInfo.- // So that the subquery can access the outer schema.- // The reason for new q is that we still need the current fromFieldList, overriding it is not expected.- subqueryExtractor := &querySpanExtractor{- ctx: q.ctx,- gCtx: q.gCtx,- defaultDatabase: q.defaultDatabase,- outerTableSources: append(q.outerTableSources, q.tableSourcesFrom...),- tableSourcesFrom: []base.TableSource{},- }- tableSource, err := subqueryExtractor.plsqlExtractQueryBlock(rule)- if err != nil {- return "", nil, errors.Wrap(err, "failed to extract select only statement")- }- spanResult := tableSource.GetQuerySpanResult()-- sourceColumnSet := make(base.SourceColumnSet)-- for _, field := range spanResult {- sourceColumnSet, _ = base.MergeSourceColumnSet(sourceColumnSet, field.SourceColumns)- }- return "", sourceColumnSet, nil- case parser.ISubqueryContext:- // For associated subquery, we should set the fromFieldList as the outerSchemaInfo.- // So that the subquery can access the outer schema.- // The reason for new q is that we still need the current fromFieldList, overriding it is not expected.- subqueryExtractor := &querySpanExtractor{- ctx: q.ctx,- gCtx: q.gCtx,- defaultDatabase: q.defaultDatabase,- outerTableSources: append(q.outerTableSources, q.tableSourcesFrom...),- tableSourcesFrom: []base.TableSource{},- }- tableSource, err := subqueryExtractor.plsqlExtractSubquery(rule)- if err != nil {- return "", nil, errors.Wrap(err, "failed to extract select only statement")- }- spanResult := tableSource.GetQuerySpanResult()-- sourceColumnSet := make(base.SourceColumnSet)-- for _, field := range spanResult {- sourceColumnSet, _ = base.MergeSourceColumnSet(sourceColumnSet, field.SourceColumns)- }- return "", sourceColumnSet, nil- case parser.ILogical_expressionContext:- if rule.Unary_logical_expression() != nil {- return q.plsqlExtractSourceColumnSetFromExpression(rule.Unary_logical_expression())- }- var list []antlr.ParserRuleContext- for _, item := range rule.AllLogical_expression() {- list = append(list, item)- }- return q.plsqlExtractSourceColumnSetFromExpressionList(list)- case parser.IUnary_logical_expressionContext:- return q.plsqlExtractSourceColumnSetFromExpression(rule.Multiset_expression())- case parser.IMultiset_expressionContext:- var list []antlr.ParserRuleContext- if rule.Relational_expression() != nil {- list = append(list, rule.Relational_expression())- }- if rule.Concatenation() != nil {- list = append(list, rule.Concatenation())- }- return q.plsqlExtractSourceColumnSetFromExpressionList(list)- case parser.IRelational_expressionContext:- var list []antlr.ParserRuleContext- for _, item := range rule.AllRelational_expression() {- list = append(list, item)- }- if rule.Compound_expression() != nil {- list = append(list, rule.Compound_expression())- }- return q.plsqlExtractSourceColumnSetFromExpressionList(list)- case parser.ICompound_expressionContext:- var list []antlr.ParserRuleContext- for _, item := range rule.AllConcatenation() {- list = append(list, item)- }- if rule.In_elements() != nil {- list = append(list, rule.In_elements())- }- if rule.Between_elements() != nil {- list = append(list, rule.Between_elements())- }- return q.plsqlExtractSourceColumnSetFromExpressionList(list)- case parser.IIn_elementsContext:- var list []antlr.ParserRuleContext- if rule.Subquery() != nil {- list = append(list, rule.Subquery())- }- for _, item := range rule.AllConcatenation() {- list = append(list, item)- }- return q.plsqlExtractSourceColumnSetFromExpressionList(list)- case parser.IBetween_elementsContext:- var list []antlr.ParserRuleContext- for _, item := range rule.AllConcatenation() {- list = append(list, item)- }- return q.plsqlExtractSourceColumnSetFromExpressionList(list)- case parser.IConcatenationContext:- var list []antlr.ParserRuleContext- if rule.Model_expression() != nil {- list = append(list, rule.Model_expression())- }- if rule.Interval_expression() != nil {- list = append(list, rule.Interval_expression())- }- for _, item := range rule.AllConcatenation() {- list = append(list, item)- }- return q.plsqlExtractSourceColumnSetFromExpressionList(list)- case parser.IModel_expressionContext:- var list []antlr.ParserRuleContext- if rule.Unary_expression() != nil {- list = append(list, rule.Unary_expression())- }- if rule.Model_expression_element() != nil {- list = append(list, rule.Model_expression_element())- }- return q.plsqlExtractSourceColumnSetFromExpressionList(list)- case parser.IInterval_expressionContext:- var list []antlr.ParserRuleContext- for _, item := range rule.AllConcatenation() {- list = append(list, item)- }- return q.plsqlExtractSourceColumnSetFromExpressionList(list)- case parser.IUnary_expressionContext:- var list []antlr.ParserRuleContext- if rule.Unary_expression() != nil {- list = append(list, rule.Unary_expression())- }- if rule.Case_statement() != nil {- list = append(list, rule.Case_statement())- }- if rule.Quantified_expression() != nil {- list = append(list, rule.Quantified_expression())- }- if rule.Standard_function() != nil {- list = append(list, rule.Standard_function())- }- if rule.Atom() != nil {- list = append(list, rule.Atom())- }- return q.plsqlExtractSourceColumnSetFromExpressionList(list)- case parser.ICase_statementContext:- var list []antlr.ParserRuleContext- if rule.Simple_case_statement() != nil {- list = append(list, rule.Simple_case_statement())- }- if rule.Searched_case_statement() != nil {- list = append(list, rule.Searched_case_statement())- }- return q.plsqlExtractSourceColumnSetFromExpressionList(list)- case parser.ISimple_case_statementContext:- var list []antlr.ParserRuleContext- if rule.Expression() != nil {- list = append(list, rule.Expression())- }- for _, item := range rule.AllSimple_case_when_part() {- list = append(list, item)- }- if rule.Case_else_part() != nil {- list = append(list, rule.Case_else_part())- }- return q.plsqlExtractSourceColumnSetFromExpressionList(list)- case parser.ISimple_case_when_partContext:- // not handle seq_of_statements- var list []antlr.ParserRuleContext- for _, item := range rule.AllExpression() {- list = append(list, item)- }- return q.plsqlExtractSourceColumnSetFromExpressionList(list)- case parser.ICase_else_partContext:- // not handle seq_of_statements- return q.plsqlExtractSourceColumnSetFromExpressionList([]antlr.ParserRuleContext{rule.Expression()})- case parser.ISearched_case_statementContext:- var list []antlr.ParserRuleContext- for _, item := range rule.AllSearched_case_when_part() {- list = append(list, item)- }- if rule.Case_else_part() != nil {- list = append(list, rule.Case_else_part())- }- return q.plsqlExtractSourceColumnSetFromExpressionList(list)- case parser.ISearched_case_when_partContext:- // not handle seq_of_statements- var list []antlr.ParserRuleContext- for _, item := range rule.AllExpression() {- list = append(list, item)- }- return q.plsqlExtractSourceColumnSetFromExpressionList(list)- case parser.IQuantified_expressionContext:- var list []antlr.ParserRuleContext- if rule.Expression() != nil {- list = append(list, rule.Expression())- }- if rule.Select_only_statement() != nil {- list = append(list, rule.Select_only_statement())- }- return q.plsqlExtractSourceColumnSetFromExpressionList(list)- case parser.ISelect_only_statementContext:- // For associated subquery, we should set the fromFieldList as the outerSchemaInfo.- // So that the subquery can access the outer schema.- // The reason for new q is that we still need the current fromFieldList, overriding it is not expected.- subqueryExtractor := &querySpanExtractor{- ctx: q.ctx,- gCtx: q.gCtx,- defaultDatabase: q.defaultDatabase,- outerTableSources: append(q.outerTableSources, q.tableSourcesFrom...),- tableSourcesFrom: []base.TableSource{},- }- tableSource, err := subqueryExtractor.plsqlExtractSelectOnlyStatement(rule)- if err != nil {- return "", nil, errors.Wrap(err, "failed to extract select only statement")- }- spanResult := tableSource.GetQuerySpanResult()-- sourceColumnSet := make(base.SourceColumnSet)-- for _, field := range spanResult {- sourceColumnSet, _ = base.MergeSourceColumnSet(sourceColumnSet, field.SourceColumns)- }- return "", sourceColumnSet, nil- case parser.IStandard_functionContext:- var list []antlr.ParserRuleContext- if rule.String_function() != nil {- list = append(list, rule.String_function())- }- if rule.Numeric_function_wrapper() != nil {- list = append(list, rule.Numeric_function_wrapper())- }- if rule.Json_function() != nil {- list = append(list, rule.Json_function())- }- if rule.Other_function() != nil {- list = append(list, rule.Other_function())- }- return q.plsqlExtractSourceColumnSetFromExpressionList(list)- case parser.IString_functionContext:- var list []antlr.ParserRuleContext- for _, item := range rule.AllExpression() {- list = append(list, item)- }- if rule.Table_element() != nil {- list = append(list, rule.Table_element())- }- if rule.Standard_function() != nil {- list = append(list, rule.Standard_function())- }- if rule.Concatenation() != nil {- list = append(list, rule.Concatenation())- }- return q.plsqlExtractSourceColumnSetFromExpressionList(list)- case parser.INumeric_function_wrapperContext:- var list []antlr.ParserRuleContext- if rule.Numeric_function() != nil {- list = append(list, rule.Numeric_function())- }- if rule.Single_column_for_loop() != nil {- list = append(list, rule.Single_column_for_loop())- }- if rule.Multi_column_for_loop() != nil {- list = append(list, rule.Multi_column_for_loop())- }- return q.plsqlExtractSourceColumnSetFromExpressionList(list)- case parser.INumeric_functionContext:- var list []antlr.ParserRuleContext- if rule.Expression() != nil {- list = append(list, rule.Expression())- }- if rule.Expressions() != nil {- list = append(list, rule.Expressions())- }- if rule.Concatenation() != nil {- list = append(list, rule.Concatenation())- }- // TODO(rebelice): handle over_clause- _, sensitive, err := q.plsqlExtractSourceColumnSetFromExpressionList(list)- return "", sensitive, err- case parser.IExpressionsContext:- var list []antlr.ParserRuleContext- for _, item := range rule.AllExpression() {- list = append(list, item)- }- return q.plsqlExtractSourceColumnSetFromExpressionList(list)- case parser.ISingle_column_for_loopContext:- var list []antlr.ParserRuleContext- if rule.Column_name() != nil {- list = append(list, rule.Column_name())- }- for _, item := range rule.AllExpression() {- list = append(list, item)- }- return q.plsqlExtractSourceColumnSetFromExpressionList(list)- case parser.IMulti_column_for_loopContext:- var list []antlr.ParserRuleContext- if rule.Paren_column_list() != nil {- list = append(list, rule.Paren_column_list())- }- if rule.Subquery() != nil {- list = append(list, rule.Subquery())- }- if rule.Expressions() != nil {- list = append(list, rule.Expressions())- }- return q.plsqlExtractSourceColumnSetFromExpressionList(list)- case parser.IJson_functionContext:- var list []antlr.ParserRuleContext- for _, item := range rule.AllJson_array_element() {- list = append(list, item)- }- for _, item := range rule.AllExpression() {- list = append(list, item)- }- if rule.Json_object_content() != nil {- list = append(list, rule.Json_object_content())- }- return q.plsqlExtractSourceColumnSetFromExpressionList(list)- case parser.IJson_array_elementContext:- var list []antlr.ParserRuleContext- if rule.Expression() != nil {- list = append(list, rule.Expression())- }- if rule.Json_function() != nil {- list = append(list, rule.Json_function())- }- return q.plsqlExtractSourceColumnSetFromExpressionList(list)- case parser.IJson_object_contentContext:- var list []antlr.ParserRuleContext- for _, item := range rule.AllJson_object_entry() {- list = append(list, item)- }- return q.plsqlExtractSourceColumnSetFromExpressionList(list)- case parser.IJson_object_entryContext:- var list []antlr.ParserRuleContext- for _, item := range rule.AllExpression() {- list = append(list, item)- }- if rule.Identifier() != nil {- list = append(list, rule.Identifier())- }- return q.plsqlExtractSourceColumnSetFromExpressionList(list)- case parser.IOther_functionContext:- var list []antlr.ParserRuleContext- if rule.Function_argument_analytic() != nil {- list = append(list, rule.Function_argument_analytic())- }- if rule.Function_argument_modeling() != nil {- list = append(list, rule.Function_argument_modeling())- }- for _, item := range rule.AllConcatenation() {- list = append(list, item)- }- if rule.Subquery() != nil {- list = append(list, rule.Subquery())- }- if rule.Table_element() != nil {- list = append(list, rule.Table_element())- }- if rule.Function_argument() != nil {- list = append(list, rule.Function_argument())- }- if rule.Argument() != nil {- list = append(list, rule.Argument())- }- if rule.Expressions() != nil {- list = append(list, rule.Expressions())- }- for _, item := range rule.AllExpression() {- list = append(list, item)- }- // TODO: handle xmltable- return q.plsqlExtractSourceColumnSetFromExpressionList(list)- case parser.IFunction_argument_analyticContext:- var list []antlr.ParserRuleContext- for _, item := range rule.AllArgument() {- list = append(list, item)- }- return q.plsqlExtractSourceColumnSetFromExpressionList(list)- case parser.IArgumentContext:- return q.plsqlExtractSourceColumnSetFromExpression(rule.Expression())- case parser.IFunction_argument_modelingContext:- // TODO(rebelice): implement standard function with USING- return "", nil, nil- case parser.ITable_elementContext:- // handled as column name- var str []string- for _, item := range rule.AllId_expression() {- str = append(str, NormalizeIDExpression(item))- }- switch len(str) {- case 1:- return str[0], q.getFieldColumnSource("", "", str[0]), nil- case 2:- return str[1], q.getFieldColumnSource("", str[0], str[1]), nil- case 3:- return str[2], q.getFieldColumnSource(str[0], str[1], str[2]), nil- default:- return "", nil, nil- }- case parser.IFunction_argumentContext:- var list []antlr.ParserRuleContext- for _, item := range rule.AllArgument() {- list = append(list, item)- }- return q.plsqlExtractSourceColumnSetFromExpressionList(list)- case parser.IAtomContext:- var list []antlr.ParserRuleContext- if rule.Table_element() != nil {- list = append(list, rule.Table_element())- }- if rule.Subquery() != nil {- list = append(list, rule.Subquery())- }- for _, item := range rule.AllSubquery_operation_part() {- list = append(list, item)- }- if rule.Expressions() != nil {- list = append(list, rule.Expressions())- }- if rule.Constant_without_variable() != nil {- list = append(list, rule.Constant_without_variable())- }- if rule.General_element() != nil {- list = append(list, rule.General_element())- }- return q.plsqlExtractSourceColumnSetFromExpressionList(list)- case parser.IConstant_without_variableContext:- list := rule.AllQuoted_string()- if len(list) == 1 && rule.DATE() == nil && rule.TIMESTAMP() == nil && rule.INTERVAL() == nil {- // This case may be a column name...- return q.plsqlExtractSourceColumnSetFromExpression(list[0])- }- case parser.ISubquery_operation_partContext:- return q.plsqlExtractSourceColumnSetFromExpression(rule.Subquery_basic_elements())- case parser.ISubquery_basic_elementsContext:- var list []antlr.ParserRuleContext- if rule.Query_block() != nil {- list = append(list, rule.Query_block())- }- if rule.Subquery() != nil {- list = append(list, rule.Subquery())- }- return q.plsqlExtractSourceColumnSetFromExpressionList(list)- case parser.IModel_expression_elementContext:- var list []antlr.ParserRuleContext- for _, item := range rule.AllExpression() {- list = append(list, item)- }- for _, item := range rule.AllSingle_column_for_loop() {- list = append(list, item)- }- if rule.Multi_column_for_loop() != nil {- list = append(list, rule.Multi_column_for_loop())- }- return q.plsqlExtractSourceColumnSetFromExpressionList(list)- default:- }-- return "", nil, nil-}--func (q *querySpanExtractor) getFieldColumnSource(schemaName, tableName, columnName string) base.SourceColumnSet {- findInTableSource := func(tableSource base.TableSource) (base.SourceColumnSet, bool) {- if schemaName != "" && schemaName != tableSource.GetDatabaseName() {- return nil, false- }- if tableName != "" && tableName != tableSource.GetTableName() {- return nil, false- }-- querySpanResult := tableSource.GetQuerySpanResult()- for _, field := range querySpanResult {- if field.Name == columnName {- return field.SourceColumns, true- }- }-- return nil, false- }-- // One sub-query may have multi-outer schemas and the multi-outer schemas can use the same name, such as:- //- // select (- // select (- // select max(a) > x1.a from t- // )- // from t1 as x1- // limit 1- // )- // from t as x1;- //- // This query has two tables can be called `x1`, and the expression x1.a uses the closer x1 table.- // This is the reason we loop the slice in reversed order.-- for i := len(q.outerTableSources) - 1; i >= 0; i-- {- if sourceColumnSet, ok := findInTableSource(q.outerTableSources[i]); ok {- return sourceColumnSet- }- }-- for _, tableSource := range q.tableSourcesFrom {- if sourceColumnSet, ok := findInTableSource(tableSource); ok {- return sourceColumnSet- }- }-- return base.SourceColumnSet{}-}--func (q *querySpanExtractor) plsqlExtractSourceColumnSetFromExpressionList(list []antlr.ParserRuleContext) (string, base.SourceColumnSet, error) {- var fieldName string- result := make(base.SourceColumnSet)- for _, item := range list {- name, sourceColumnSet, err := q.plsqlExtractSourceColumnSetFromExpression(item)- if err != nil {- return "", nil, err- }- result, _ = base.MergeSourceColumnSet(result, sourceColumnSet)- if len(list) == 1 {- fieldName = name- }- }- return fieldName, result, nil-}--func (q *querySpanExtractor) getAllTableColumnSources(schemaName string, tableName string) ([]base.QuerySpanResult, bool) {- findInTableSource := func(tableSource base.TableSource) ([]base.QuerySpanResult, bool) {- if schemaName != "" && schemaName != tableSource.GetDatabaseName() {- return nil, false- }- if tableName != "" && tableName != tableSource.GetTableName() {- return nil, false- }-- // If the table name is empty, we should check if there are ambiguous fields,- // but we delegate this responsibility to the db-server, we do the fail-open strategy here.- return tableSource.GetQuerySpanResult(), true- }-- for i := len(q.outerTableSources) - 1; i >= 0; i-- {- if result, ok := findInTableSource(q.outerTableSources[i]); ok {- return result, true- }- }-- for _, tableSource := range q.tableSourcesFrom {- if result, ok := findInTableSource(tableSource); ok {- return result, true- }- }-- return []base.QuerySpanResult{}, false-}--func (q *querySpanExtractor) plsqlExtractFromClause(ctx parser.IFrom_clauseContext) ([]base.TableSource, error) {- if ctx == nil {- return nil, nil- }-- tableRefList := ctx.Table_ref_list()- if tableRefList == nil {- return nil, nil- }-- var result []base.TableSource- for _, tableRef := range tableRefList.AllTable_ref() {- tableSource, err := q.plsqlExtractTableRef(tableRef)- if err != nil {- return nil, errors.Wrap(err, "failed to extract table ref")- }- result = append(result, tableSource)- }- return result, nil-}--func (q *querySpanExtractor) plsqlExtractTableRef(ctx parser.ITable_refContext) (base.TableSource, error) {- if ctx == nil {- return nil, nil- }-- tableRefAux := ctx.Table_ref_aux()- if tableRefAux == nil {- return nil, nil- }-- leftTableSource, err := q.plsqlExtractTableRefAux(tableRefAux)- if err != nil {- return nil, err- }-- joins := ctx.AllJoin_clause()- if len(joins) == 0 {- return leftTableSource, nil- }-- q.tableSourcesFrom = append(q.tableSourcesFrom, leftTableSource)- for _, join := range joins {- rightTableSource, err := q.plsqlExtractJoin(join)- if err != nil {- return nil, err- }- q.tableSourcesFrom = append(q.tableSourcesFrom, rightTableSource)- leftTableSource, err = q.mergeJoinTableSource(join, leftTableSource, rightTableSource)- if err != nil {- return nil, err- }- }-- return leftTableSource, nil-}--func (q *querySpanExtractor) mergeJoinTableSource(ctx parser.IJoin_clauseContext, leftTableSource, rightTableSource base.TableSource) (base.TableSource, error) {- if ctx == nil {- return nil, nil- }-- leftSpanResult, rightSpanResult := leftTableSource.GetQuerySpanResult(), rightTableSource.GetQuerySpanResult()- result := new(base.PseudoTable)-- leftSpanResultIdx, rightSpanResultIdx := make(map[string]int), make(map[string]int)- for i, spanResult := range leftSpanResult {- leftSpanResultIdx[spanResult.Name] = i- }- for i, spanResult := range rightSpanResult {- rightSpanResultIdx[spanResult.Name] = i- }-- if ctx.NATURAL() != nil {- for idx, spanResult := range leftSpanResult {- if _, ok := rightSpanResultIdx[spanResult.Name]; ok {- spanResult.SourceColumns, _ = base.MergeSourceColumnSet(spanResult.SourceColumns, rightSpanResult[idx].SourceColumns)- }- result.Columns = append(result.Columns, spanResult)- }- for _, spanResult := range rightSpanResult {- if _, ok := leftSpanResultIdx[spanResult.Name]; !ok {- result.Columns = append(result.Columns, spanResult)- }- }- return result, nil- }-- if len(ctx.AllJoin_using_part()) != 0 {- usingMap := make(map[string]bool)- for _, part := range ctx.AllJoin_using_part() {- for _, column := range part.Paren_column_list().Column_list().AllColumn_name() {- _, _, name, err := plsqlNormalizeColumnName(q.defaultDatabase, column)- if err != nil {- return nil, err- }- usingMap[name] = true- }- }-- for _, field := range leftSpanResult {- _, existsInUsingMap := usingMap[field.Name]- rightIdx, existsInRight := rightSpanResultIdx[field.Name]- if existsInUsingMap && existsInRight {- field.SourceColumns, _ = base.MergeSourceColumnSet(field.SourceColumns, rightSpanResult[rightIdx].SourceColumns)- }- result.Columns = append(result.Columns, field)- }- for _, field := range rightSpanResult {- if _, existsInUsingMap := usingMap[field.Name]; !existsInUsingMap {- result.Columns = append(result.Columns, field)- }- }- return result, nil- }-- result.Columns = append(result.Columns, leftSpanResult...)- result.Columns = append(result.Columns, rightSpanResult...)- return result, nil-}--func (q *querySpanExtractor) plsqlExtractJoin(ctx parser.IJoin_clauseContext) (base.TableSource, error) {- if ctx == nil {- return nil, nil- }-- tableRefAux := ctx.Table_ref_aux()- if tableRefAux == nil {- return nil, nil+ _, meta, err := q.gCtx.GetDatabaseMetadataFunc(q.ctx, q.gCtx.InstanceID, schema)+ if err != nil {+ return nil, errors.Wrapf(err, "failed to get database metadata for schema: %s", schema)}-- return q.plsqlExtractTableRefAux(tableRefAux)+ return meta, nil}-func (q *querySpanExtractor) plsqlExtractTableRefAux(ctx parser.ITable_ref_auxContext) (base.TableSource, error) {- if ctx == nil {- return nil, nil+func (q *querySpanExtractor) existsTableMetadata(resource base.SchemaResource) bool {+ if resource.Table == "DUAL" {+ return false}-- tableRefAuxInternal := ctx.Table_ref_aux_internal()- tableSource, err := q.plsqlExtractTableRefAuxInternal(tableRefAuxInternal)- if err != nil {- return nil, errors.Wrap(err, "failed to extract table ref aux internal")+ database := resource.Database+ if database == "" {+ database = q.defaultDatabase}-- tableAlias := ctx.Table_alias()- if tableAlias == nil {- return tableSource, nil+ meta, err := q.getDatabaseMetadata(database)+ if err != nil || meta == nil {+ return false}-- alias := NormalizeTableAlias(tableAlias)- return &base.PseudoTable{- Name: alias,- Columns: tableSource.GetQuerySpanResult(),- }, nil-}--func (q *querySpanExtractor) plsqlExtractTableRefAuxInternal(ctx parser.ITable_ref_aux_internalContext) (base.TableSource, error) {- if ctx == nil {- return nil, nil+ schema := meta.GetSchemaMetadata("")+ if schema == nil {+ return false}- switch rule := ctx.(type) {- case *parser.Table_ref_aux_internal_oneContext:- return q.plsqlExtractDmlTableExpressionClause(rule.Dml_table_expression_clause())- case *parser.Table_ref_aux_internal_twoContext:- if len(rule.AllSubquery_operation_part()) == 0 {- return q.plsqlExtractTableRef(rule.Table_ref())- }-- leftSpanResults, err := q.plsqlExtractTableRef(rule.Table_ref())- if err != nil {- return nil, errors.Wrap(err, "failed to extract left table ref")- }- leftQuerySpanResult := leftSpanResults.GetQuerySpanResult()- for _, part := range rule.AllSubquery_operation_part() {- rightSpanResults, err := q.plsqlExtractSubqueryOperationPart(part)- if err != nil {- return nil, errors.Wrap(err, "failed to extract right subquery operation part")- }- rightQuerySpanResult := rightSpanResults.GetQuerySpanResult()- if len(leftQuerySpanResult) != len(rightQuerySpanResult) {- return nil, errors.Errorf("left and right query span result length mismatch: %d != %d", len(leftQuerySpanResult), len(rightQuerySpanResult))- }- var result []base.QuerySpanResult- for i, leftSpanResult := range leftQuerySpanResult {- rightSpanResult := rightQuerySpanResult[i]- newResourceColumns, _ := base.MergeSourceColumnSet(leftSpanResult.SourceColumns, rightSpanResult.SourceColumns)- result = append(result, base.QuerySpanResult{- Name: leftSpanResult.Name,- SourceColumns: newResourceColumns,- })- }- leftQuerySpanResult = result- }- return &base.PseudoTable{- Name: "",- Columns: leftQuerySpanResult,- }, nil- case *parser.Table_ref_aux_internal_threeContext:- return q.plsqlExtractDmlTableExpressionClause(rule.Dml_table_expression_clause())- default:- return nil, errors.Errorf("unknown table_ref_aux_internal rule: %T", rule)- }+ return schema.GetTable(resource.Table) != nil ||+ schema.GetView(resource.Table) != nil ||+ schema.GetMaterializedView(resource.Table) != nil ||+ schema.GetExternalTable(resource.Table) != nil}-func (q *querySpanExtractor) plsqlExtractDmlTableExpressionClause(ctx parser.IDml_table_expression_clauseContext) (base.TableSource, error) {- if ctx == nil {- return nil, nil- }-- tableViewName := ctx.Tableview_name()- if tableViewName != nil {- dbLink, schema, table := NormalizeTableViewName(q.defaultDatabase, tableViewName)- if len(dbLink) != 0 {- // Use the user in db link as default instead of the connected database.- dbLink, schema, table = NormalizeTableViewName("", tableViewName)+func isMixedQuery(m []base.SchemaResource) (bool, bool) {+ hasSystem, hasUser := false, false+ for _, item := range m {+ if systemSchemaMap[item.Database] {+ hasSystem = true+ } else {+ hasUser = true}- return q.plsqlFindTableSchema(dbLink, schema, table)}- if ctx.Select_statement() != nil {- return q.plsqlExtractSelect(ctx.Select_statement())+ if hasSystem && hasUser {+ return false, true}- // TODO(rebelice): handle other cases for DML_TABLE_EXPRESSION_CLAUSE- return nil, errors.Errorf("unsupported dml_table_expression_clause: %T", ctx)+ return !hasUser && hasSystem, false+}++var systemSchemaMap = map[string]bool{+ "ANONYMOUS": true,+ "APPQOSSYS": true,+ "AUDSYS": true,+ "CTXSYS": true,+ "DBSFWUSER": true,+ "DBSNMP": true,+ "DGPDB_INT": true,+ "DIP": true,+ "DVF": true,+ "DVSYS": true,+ "GGSYS": true,+ "GSMADMIN_INTERNAL": true,+ "GSMCATUSER": true,+ "GSMROOTUSER": true,+ "GSMUSER": true,+ "LBACSYS": true,+ "MDDATA": true,+ "MDSYS": true,+ "OPS$ORACLE": true,+ "ORACLE_OCM": true,+ "OUTLN": true,+ "REMOTE_SCHEDULER_AGENT": true,+ "SYS": true,+ "SYS$UMF": true,+ "SYSBACKUP": true,+ "SYSDG": true,+ "SYSKM": true,+ "SYSRAC": true,+ "SYSTEM": true,+ "XDB": true,+ "XS$NULL": true,+ "XS$$NULL": true,+ "FLOWS_FILES": true,+ "HR": true,+ "EXFSYS": true,+ "MGMT_VIEW": true,+ "OLAPSYS": true,+ "ORDDATA": true,+ "ORDPLUGINS": true,+ "ORDSYS": true,+ "OWBSYS": true,+ "OWBSYS_AUDIT": true,+ "SCOTT": true,+ "SI_INFORMTN_SCHEMA": true,+ "SPATIAL_CSW_ADMIN_USR": true,+ "SPATIAL_WFS_ADMIN_USR": true,+ "SYSMAN": true,+ "WMSYS": true,+ "OJVMSYS": true,}func (q *querySpanExtractor) plsqlFindTableSchema(dbLink []string, schemaName, tableName string) (base.TableSource, error) {@@ -1283,15 +157,6 @@ func (q *querySpanExtractor) plsqlFindTableSchema(dbLink []string, schemaName, treturn q.findTableSchemaInMetadata(linkedInstanceID, linkedMeta, schemaName, tableName)}- // Each CTE name in one WITH clause must be unique, but we can use the same name in the different level CTE, such as:- //- // with tt2 as (- // with tt2 as (select * from t)- // select max(a) from tt2)- // select * from tt2- //- // This query has two CTE can be called `tt2`, and the FROM clause 'from tt2' uses the closer tt2 CTE.- // This is the reason we loop the slice in reversed order.if schemaName == q.defaultDatabase {for i := len(q.ctes) - 1; i >= 0; i-- {table := q.ctes[i]@@ -1359,8 +224,7 @@ func (q *querySpanExtractor) findTableSchemaInMetadata(instanceID string, dbMeta}if view != nil && view.Definition != "" {- defaultDatabase := databaseName- columns, err := q.getColumnsForView(instanceID, defaultDatabase, view.Definition)+ columns, err := q.getColumnsForView(instanceID, databaseName, view.Definition)if err != nil {return nil, err}@@ -1371,8 +235,7 @@ func (q *querySpanExtractor) findTableSchemaInMetadata(instanceID string, dbMeta}if materializedView != nil && materializedView.Definition != "" {- defaultDatabase := databaseName- columns, err := q.getColumnsForMaterializedView(instanceID, defaultDatabase, materializedView.Definition)+ columns, err := q.getColumnsForMaterializedView(instanceID, databaseName, materializedView.Definition)if err != nil {return nil, err}@@ -1419,311 +282,3 @@ func (q *querySpanExtractor) getColumnsForMaterializedView(instanceID, defaultDa}return span.Results, nil}--func (q *querySpanExtractor) plsqlExtractFactoringElement(ctx parser.IFactoring_elementContext) (*base.PseudoTable, error) {- if ctx == nil {- return nil, nil- }-- // Deal with recursive CTE first.- tableName := NormalizeIdentifierContext(ctx.Query_name().Identifier())-- if yes, lastPart := q.plsqlIsRecursiveCTE(ctx); yes {- subquery := ctx.Subquery()- initialTableSource, err := q.plsqlExtractSubqueryExceptLastPart(subquery)- if err != nil {- return nil, err- }-- initialQuerySpanResult := initialTableSource.GetQuerySpanResult()-- if ctx.Paren_column_list() != nil {- var columnNames []string- for _, column := range ctx.Paren_column_list().Column_list().AllColumn_name() {- _, _, columnName, err := plsqlNormalizeColumnName("", column)- if err != nil {- return nil, err- }- columnNames = append(columnNames, columnName)- }- if len(columnNames) != len(initialQuerySpanResult) {- return nil, errors.Errorf("column name count mismatch: %d != %d", len(columnNames), len(initialQuerySpanResult))- }- for i, columnName := range columnNames {- initialQuerySpanResult[i].Name = columnName- }- }-- cteTableResource := &base.PseudoTable{- Name: tableName,- Columns: initialQuerySpanResult,- }-- // Compute dependent closures.- // There are two ways to compute dependent closures:- // 1. find the all dependent edges, then use graph theory traversal to find the closure.- // 2. Iterate to simulate the CTE recursive process, each turn check whether the columns have changed, and stop if not change.- //- // Consider the option 2 can easy to implementation, because the simulate process has been written.- // On the other hand, the number of iterations of the entire algorithm will not exceed the length of fields.- // In actual use, the length of fields will not be more than 20 generally.- // So I think it's OK for now.- // If any performance issues in use, optimize here.- q.ctes = append(q.ctes, cteTableResource)- defer func() {- q.ctes = q.ctes[:len(q.ctes)-1]- }()-- for {- recursiveTableSource, err := q.plsqlExtractSubqueryBasicElements(lastPart.Subquery_basic_elements())- if err != nil {- return nil, err- }- recursiveQuerySpanResult := recursiveTableSource.GetQuerySpanResult()- if len(initialQuerySpanResult) != len(recursiveQuerySpanResult) {- return nil, errors.Errorf("initial and recursive query span result length mismatch: %d != %d", len(initialQuerySpanResult), len(recursiveQuerySpanResult))- }-- changed := false- for i, spanQueryResult := range recursiveQuerySpanResult {- newResourceColumns, hasDiff := base.MergeSourceColumnSet(initialQuerySpanResult[i].SourceColumns, spanQueryResult.SourceColumns)- if hasDiff {- changed = true- initialQuerySpanResult[i].SourceColumns = newResourceColumns- }- }-- if !changed {- break- }- q.ctes[len(q.ctes)-1].Columns = initialQuerySpanResult- }- return cteTableResource, nil- }-- return q.plsqlExtractNonRecursiveCTE(ctx)-}--func (q *querySpanExtractor) plsqlExtractNonRecursiveCTE(ctx parser.IFactoring_elementContext) (*base.PseudoTable, error) {- if ctx == nil {- return nil, nil- }-- tableSource, err := q.plsqlExtractSubquery(ctx.Subquery())- if err != nil {- return nil, err- }-- querySpanResult := tableSource.GetQuerySpanResult()-- if ctx.Paren_column_list() != nil {- var columnNames []string- for _, column := range ctx.Paren_column_list().Column_list().AllColumn_name() {- _, _, columnName, err := plsqlNormalizeColumnName("", column)- if err != nil {- return nil, err- }- columnNames = append(columnNames, columnName)- }- if len(columnNames) != len(querySpanResult) {- return nil, errors.Errorf("column name count mismatch: %d != %d", len(columnNames), len(querySpanResult))- }- for i, columnName := range columnNames {- querySpanResult[i].Name = columnName- }- }-- tableName := NormalizeIdentifierContext(ctx.Query_name().Identifier())- return &base.PseudoTable{- Name: tableName,- Columns: querySpanResult,- }, nil-}--func (q *querySpanExtractor) plsqlExtractSubqueryExceptLastPart(ctx parser.ISubqueryContext) (base.TableSource, error) {- if ctx == nil {- return nil, nil- }-- subqueryBasicElements := ctx.Subquery_basic_elements()- if subqueryBasicElements == nil {- return nil, nil- }-- leftTableSource, err := q.plsqlExtractSubqueryBasicElements(subqueryBasicElements)- if err != nil {- return nil, err- }-- leftQuerySpanResult := leftTableSource.GetQuerySpanResult()-- allParts := ctx.AllSubquery_operation_part()- for _, part := range allParts[:len(allParts)-1] {- rightTableSource, err := q.plsqlExtractSubqueryOperationPart(part)- if err != nil {- return nil, err- }-- rightQueryStanResult := rightTableSource.GetQuerySpanResult()- if len(leftQuerySpanResult) != len(rightQueryStanResult) {- return nil, errors.Errorf("left and right query span result length mismatch: %d != %d", len(leftQuerySpanResult), len(rightQueryStanResult))- }- var result []base.QuerySpanResult- for i, leftSpanResult := range leftQuerySpanResult {- rightSpanResult := rightQueryStanResult[i]- newResourceColumns, _ := base.MergeSourceColumnSet(leftSpanResult.SourceColumns, rightSpanResult.SourceColumns)- result = append(result, base.QuerySpanResult{- Name: leftSpanResult.Name,- SourceColumns: newResourceColumns,- })- }- leftQuerySpanResult = result- }-- return &base.PseudoTable{- Name: "",- Columns: leftQuerySpanResult,- }, nil-}--func (q *querySpanExtractor) plsqlExtractSubqueryOperationPart(ctx parser.ISubquery_operation_partContext) (base.TableSource, error) {- if ctx == nil {- return nil, nil- }-- return q.plsqlExtractSubqueryBasicElements(ctx.Subquery_basic_elements())-}--func (*querySpanExtractor) plsqlIsRecursiveCTE(ctx parser.IFactoring_elementContext) (bool, parser.ISubquery_operation_partContext) {- subquery := ctx.Subquery()- allParts := subquery.AllSubquery_operation_part()- if len(allParts) == 0 {- return false, nil- }- lastPart := allParts[len(allParts)-1]- return lastPart.ALL() != nil, lastPart-}--func isMixedQuery(m []base.SchemaResource) (bool, bool) {- hasSystem, hasUser := false, false- for _, item := range m {- if systemSchemaMap[item.Database] {- hasSystem = true- } else {- hasUser = true- }- }-- if hasSystem && hasUser {- return false, true- }-- return !hasUser && hasSystem, false-}--var systemSchemaMap = map[string]bool{- "ANONYMOUS": true,- "APPQOSSYS": true,- "AUDSYS": true,- "CTXSYS": true,- "DBSFWUSER": true,- "DBSNMP": true,- "DGPDB_INT": true,- "DIP": true,- "DVF": true,- "DVSYS": true,- "GGSYS": true,- "GSMADMIN_INTERNAL": true,- "GSMCATUSER": true,- "GSMROOTUSER": true,- "GSMUSER": true,- "LBACSYS": true,- "MDDATA": true,- "MDSYS": true,- "OPS$ORACLE": true,- "ORACLE_OCM": true,- "OUTLN": true,- "REMOTE_SCHEDULER_AGENT": true,- "SYS": true,- "SYS$UMF": true,- "SYSBACKUP": true,- "SYSDG": true,- "SYSKM": true,- "SYSRAC": true,- "SYSTEM": true,- "XDB": true,- "XS$NULL": true,- "XS$$NULL": true,- "FLOWS_FILES": true,- "HR": true,- "EXFSYS": true,- "MGMT_VIEW": true,- "OLAPSYS": true,- "ORDDATA": true,- "ORDPLUGINS": true,- "ORDSYS": true,- "OWBSYS": true,- "OWBSYS_AUDIT": true,- "SCOTT": true,- "SI_INFORMTN_SCHEMA": true,- "SPATIAL_CSW_ADMIN_USR": true,- "SPATIAL_WFS_ADMIN_USR": true,- "SYSMAN": true,- "WMSYS": true,- "OJVMSYS": true,-}--func getAccessTables(currentDatabase string, tree antlr.Tree) []base.SchemaResource {- l := &resourceExtractListener{- currentDatabase: currentDatabase,- resourceMap: make(map[string]base.SchemaResource),- }-- var result []base.SchemaResource- antlr.ParseTreeWalkerDefault.Walk(l, tree)- for _, resource := range l.resourceMap {- result = append(result, resource)- }-- slices.SortFunc(result, func(a, b base.SchemaResource) int {- if a.String() < b.String() {- return -1- }- if a.String() > b.String() {- return 1- }- return 0- })-- return result-}--type resourceExtractListener struct {- *parser.BasePlSqlParserListener-- currentDatabase string- resourceMap map[string]base.SchemaResource-}--func (l *resourceExtractListener) EnterTableview_name(ctx *parser.Tableview_nameContext) {- if ctx.Identifier() == nil {- return- }-- var schema, tableOrView string- if ctx.Id_expression() == nil {- tableOrView = NormalizeIdentifierContext(ctx.Identifier())- } else {- schema = NormalizeIdentifierContext(ctx.Identifier())- tableOrView = NormalizeIDExpression(ctx.Id_expression())- }- if schema == "" {- schema = l.currentDatabase- }-- resource := base.SchemaResource{- Database: schema,- Table: tableOrView,- }- l.resourceMap[resource.String()] = resource-}diff --git a/backend/plugin/parser/plsql/query_span_test.go b/backend/plugin/parser/plsql/query_span_test.goindex 710943a184..301de39bcb 100644--- a/backend/plugin/parser/plsql/query_span_test.go+++ b/backend/plugin/parser/plsql/query_span_test.go@@ -6,6 +6,7 @@ import ("os""testing"+ oracleast "github.com/bytebase/omni/oracle/ast""github.com/pkg/errors""github.com/stretchr/testify/require""gopkg.in/yaml.v3"@@ -226,10 +227,13 @@ func TestGetAccessTables(t *testing.T) {}for _, test := range tests {- results, err := ParsePLSQL(test.statement)+ results, err := ParsePLSQLOmni(test.statement)require.NoError(t, err)require.NotEmpty(t, results)- resources := getAccessTables("DB", results[0].Tree)+ require.NotEmpty(t, results.Items)+ raw, ok := results.Items[0].(*oracleast.RawStmt)+ require.True(t, ok)+ resources := collectOmniAccessTables("DB", raw.Stmt)require.Equal(t, test.expected, resources, test.statement)}}diff --git a/backend/plugin/parser/plsql/query_type.go b/backend/plugin/parser/plsql/query_type.godeleted file mode 100644index cd1cd1b1d9..0000000000--- a/backend/plugin/parser/plsql/query_type.go+++ /dev/null@@ -1,158 +0,0 @@-//nolint:unused-package plsql--import (- "github.com/bytebase/parser/plsql"-- "github.com/bytebase/bytebase/backend/plugin/parser/base"-)--type queryTypeListener struct {- *plsql.BasePlSqlParserListener-- allSystems bool- result base.QueryType-}--func (l *queryTypeListener) EnterUnit_statement(ctx *plsql.Unit_statementContext) {- switch {- case ctx.Alter_analytic_view() != nil,- ctx.Alter_attribute_dimension() != nil,- ctx.Alter_audit_policy() != nil,- ctx.Alter_cluster() != nil,- ctx.Alter_database() != nil,- ctx.Alter_database_link() != nil,- ctx.Alter_dimension() != nil,- ctx.Alter_diskgroup() != nil,- ctx.Alter_flashback_archive() != nil,- ctx.Alter_function() != nil,- ctx.Alter_hierarchy() != nil,- ctx.Alter_index() != nil,- ctx.Alter_inmemory_join_group() != nil,- ctx.Alter_java() != nil,- ctx.Alter_library() != nil,- ctx.Alter_lockdown_profile() != nil,- ctx.Alter_materialized_view() != nil,- ctx.Alter_materialized_view_log() != nil,- ctx.Alter_materialized_zonemap() != nil,- ctx.Alter_operator() != nil,- ctx.Alter_outline() != nil,- ctx.Alter_package() != nil,- ctx.Alter_pmem_filestore() != nil,- ctx.Alter_procedure() != nil,- ctx.Alter_resource_cost() != nil,- ctx.Alter_role() != nil,- ctx.Alter_rollback_segment() != nil,- ctx.Alter_sequence() != nil,- ctx.Alter_session() != nil,- ctx.Alter_synonym() != nil,- ctx.Alter_table() != nil,- ctx.Alter_tablespace() != nil,- ctx.Alter_tablespace_set() != nil,- ctx.Alter_trigger() != nil,- ctx.Alter_type() != nil,- ctx.Alter_user() != nil,- ctx.Alter_view() != nil,- ctx.Create_analytic_view() != nil,- ctx.Create_attribute_dimension() != nil,- ctx.Create_audit_policy() != nil,- ctx.Create_cluster() != nil,- ctx.Create_context() != nil,- ctx.Create_controlfile() != nil,- ctx.Create_database() != nil,- ctx.Create_database_link() != nil,- ctx.Create_dimension() != nil,- ctx.Create_directory() != nil,- ctx.Create_diskgroup() != nil,- ctx.Create_edition() != nil,- ctx.Create_flashback_archive() != nil,- ctx.Create_function_body() != nil,- ctx.Create_hierarchy() != nil,- ctx.Create_index() != nil,- ctx.Create_inmemory_join_group() != nil,- ctx.Create_java() != nil,- ctx.Create_library() != nil,- ctx.Create_lockdown_profile() != nil,- ctx.Create_materialized_view() != nil,- ctx.Create_materialized_view_log() != nil,- ctx.Create_materialized_zonemap() != nil,- ctx.Create_operator() != nil,- ctx.Create_outline() != nil,- ctx.Create_package() != nil,- ctx.Create_package_body() != nil,- ctx.Create_pmem_filestore() != nil,- ctx.Create_procedure_body() != nil,- ctx.Create_profile() != nil,- ctx.Create_restore_point() != nil,- ctx.Create_role() != nil,- ctx.Create_rollback_segment() != nil,- ctx.Create_sequence() != nil,- ctx.Create_spfile() != nil,- ctx.Create_synonym() != nil,- ctx.Create_table() != nil,- ctx.Create_tablespace() != nil,- ctx.Create_tablespace_set() != nil,- ctx.Create_trigger() != nil,- ctx.Create_type() != nil,- ctx.Create_user() != nil,- ctx.Create_view() != nil,- ctx.Drop_analytic_view() != nil,- ctx.Drop_attribute_dimension() != nil,- ctx.Drop_audit_policy() != nil,- ctx.Drop_cluster() != nil,- ctx.Drop_context() != nil,- ctx.Drop_database() != nil,- ctx.Drop_database_link() != nil,- ctx.Drop_directory() != nil,- ctx.Drop_diskgroup() != nil,- ctx.Drop_edition() != nil,- ctx.Drop_flashback_archive() != nil,- ctx.Drop_function() != nil,- ctx.Drop_hierarchy() != nil,- ctx.Drop_index() != nil,- ctx.Drop_indextype() != nil,- ctx.Drop_inmemory_join_group() != nil,- ctx.Drop_java() != nil,- ctx.Drop_library() != nil,- ctx.Drop_lockdown_profile() != nil,- ctx.Drop_materialized_view() != nil,- ctx.Drop_materialized_zonemap() != nil,- ctx.Drop_operator() != nil,- ctx.Drop_outline() != nil,- ctx.Drop_package() != nil,- ctx.Drop_pmem_filestore() != nil,- ctx.Drop_procedure() != nil,- ctx.Drop_restore_point() != nil,- ctx.Drop_role() != nil,- ctx.Drop_rollback_segment() != nil,- ctx.Drop_sequence() != nil,- ctx.Drop_synonym() != nil,- ctx.Drop_table() != nil,- ctx.Drop_tablespace() != nil,- ctx.Drop_tablespace_set() != nil,- ctx.Drop_trigger() != nil,- ctx.Drop_type() != nil,- ctx.Drop_user() != nil,- ctx.Drop_view() != nil:- l.result = base.DDL- case ctx.Data_manipulation_language_statements() != nil:- dml := ctx.Data_manipulation_language_statements()- if dml.Explain_statement() != nil {- l.result = base.Explain- return- }- if dml.Select_statement() != nil {- if l.allSystems {- l.result = base.SelectInfoSchema- } else {- l.result = base.Select- }- return- }- l.result = base.DML- case ctx.Sql_call_statement() != nil:- l.result = base.DML- default:- // Other statement types- }-}diff --git a/backend/plugin/parser/plsql/resource_change_test.go b/backend/plugin/parser/plsql/resource_change_test.goindex 59608102a8..dcfc20a726 100644--- a/backend/plugin/parser/plsql/resource_change_test.go+++ b/backend/plugin/parser/plsql/resource_change_test.go@@ -165,12 +165,15 @@ END;`_, ok := asts[0].(*OmniAST)require.True(t, ok)- antlrASTs, err := ParsePLSQL(triggerStatement)- require.NoError(t, err)- require.Len(t, antlrASTs, 1)- asts = append(asts, antlrASTs[0])+ asts = append(asts, testAST{})got, err := extractChangedResources("DB", "", nil /* dbMetadata */, asts, statement)require.NoError(t, err)require.Equal(t, want, got)}++type testAST struct{}++func (testAST) ASTStartPosition() *storepb.Position {+ return nil+}diff --git a/backend/plugin/parser/plsql/split.go b/backend/plugin/parser/plsql/split.goindex 87a24d544c..2f8e07f9d3 100644--- a/backend/plugin/parser/plsql/split.go+++ b/backend/plugin/parser/plsql/split.go@@ -3,11 +3,8 @@ package plsqlimport ("strings"- "github.com/antlr4-go/antlr/v4"oracleparser "github.com/bytebase/omni/oracle/parser"- parser "github.com/bytebase/parser/plsql"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/parser/base")@@ -16,24 +13,6 @@ func init() {base.RegisterSplitterFunc(storepb.Engine_ORACLE, SplitSQL)}-// consumeTrailingSemicolon walks forward from stopIdx through hidden-channel-// tokens (whitespace, comments) looking for a trailing ';' that belongs to the-// statement ending at stopIdx. Returns the index of the ';' if found before any-// default-channel token, otherwise stopIdx (no consumption). ParsePLSQL uses-// this to avoid BYT-9367's secondary AST-classification leak.-func consumeTrailingSemicolon(allTokens []antlr.Token, stopIdx int) int {- for nextIdx := stopIdx + 1; nextIdx < len(allTokens); nextIdx++ {- next := allTokens[nextIdx]- if next.GetTokenType() == parser.PlSqlParserSEMICOLON {- return nextIdx- }- if next.GetChannel() == antlr.TokenDefaultChannel {- return stopIdx- }- }- return stopIdx-}-// SplitSQL splits the given SQL statement into multiple SQL statements.//// It uses omni's lexical Oracle splitter, which handles strings, comments,@@ -110,59 +89,31 @@ func trimOracleSegmentTrailingHidden(text string) int {}func SplitSQLForCompletion(statement string) ([]base.Statement, error) {- tree, stream, err := ParsePLSQLForStringsManipulation(statement)- if err != nil {- return nil, err- }- if tree == nil {- return nil, nil- }- tokens, ok := stream.(*antlr.CommonTokenStream)- if !ok {- return nil, nil- }-- var result []base.Statement- for _, item := range tree.GetChildren() {- if stmt, ok := item.(parser.IUnit_statementContext); ok {- if isCallStatement(item) && len(result) > 0 {- lastResult := result[len(result)-1]- stopIndex := stmt.GetStop().GetTokenIndex()- lastToken := tokens.Get(stopIndex)- result[len(result)-1] = base.Statement{- Text: lastResult.Text + tokens.GetTextFromTokens(stmt.GetStart(), lastToken),- End: common.ConvertANTLRTokenToExclusiveEndPosition(- int32(lastToken.GetLine()),- int32(lastToken.GetColumn()),- lastToken.GetText(),- ),- Empty: false,- }- continue- }-- stopIndex := stmt.GetStop().GetTokenIndex()- lastToken := tokens.Get(stopIndex)+ segments := oracleparser.Split(statement)- result = append(result, base.Statement{- Text: tokens.GetTextFromTokens(stmt.GetStart(), lastToken),- End: common.ConvertANTLRTokenToExclusiveEndPosition(- int32(lastToken.GetLine()),- int32(lastToken.GetColumn()),- lastToken.GetText(),- ),- Empty: base.IsEmpty(tokens.GetAllTokens()[stmt.GetStart().GetTokenIndex():stmt.GetStop().GetTokenIndex()+1], parser.PlSqlParserSEMICOLON),- })+ result := make([]base.Statement, 0, len(segments))+ positionMapper := base.NewByteOffsetPositionMapper(statement)+ for i := 0; i < len(segments); i++ {+ seg := segments[i]+ if seg.Kind == oracleparser.SegmentSQLPlusCommand {+ continue}+ byteStart := seg.ByteStart+ byteEnd := seg.ByteEnd+ if end, ok := matchRecognizeDefineMergeEnd(statement, segments, i); ok {+ byteEnd = end+ i += 2+ }+ result = append(result, base.Statement{+ Text: statement[byteStart:byteEnd],+ Start: positionMapper.Position(byteStart),+ End: positionMapper.Position(byteEnd),+ Empty: seg.Empty(),+ Range: &storepb.Range{+ Start: int32(byteStart),+ End: int32(byteEnd),+ },+ })}return result, nil}--func isCallStatement(item antlr.Tree) bool {- unitStmt, ok := item.(parser.IUnit_statementContext)- if !ok {- return false- }- // BYT-8268: Changed from Call_statement to Sql_call_statement- return unitStmt.Sql_call_statement() != nil-}diff --git a/backend/plugin/parser/plsql/statement_type.go b/backend/plugin/parser/plsql/statement_type.goindex cf7c9dfd86..0939f64291 100644--- a/backend/plugin/parser/plsql/statement_type.go+++ b/backend/plugin/parser/plsql/statement_type.go@@ -3,9 +3,7 @@ package plsqlimport ("strings"- "github.com/antlr4-go/antlr/v4"oracleast "github.com/bytebase/omni/oracle/ast"- parser "github.com/bytebase/parser/plsql""github.com/pkg/errors"storepb "github.com/bytebase/bytebase/backend/generated-go/store"@@ -22,12 +20,7 @@ func GetStatementTypes(asts []base.AST) ([]storepb.StatementType, error) {continue}- antlrAST, ok := base.GetANTLRAST(ast)- if !ok {- return nil, errors.New("expected Oracle AST")- }- t := getStatementType(antlrAST.Tree)- sqlTypeSet[t] = true+ return nil, errors.New("expected Oracle omni AST")}var sqlTypes []storepb.StatementTypefor sqlType := range sqlTypeSet {@@ -127,44 +120,3 @@ func classifyOmniDropStatementType(objectType oracleast.ObjectType) storepb.Statreturn storepb.StatementType_STATEMENT_TYPE_UNSPECIFIED}}--func getStatementType(node antlr.Tree) storepb.StatementType {- switch ctx := node.(type) {- case *parser.Sql_scriptContext, *parser.Unit_statementContext, *parser.Data_manipulation_language_statementsContext:- for _, child := range ctx.GetChildren() {- return getStatementType(child)- }- case *parser.Alter_databaseContext:- return storepb.StatementType_ALTER_DATABASE- case *parser.Alter_indexContext:- return storepb.StatementType_ALTER_INDEX- case *parser.Alter_tableContext:- return storepb.StatementType_ALTER_TABLE- case *parser.Create_databaseContext:- return storepb.StatementType_CREATE_DATABASE- case *parser.Create_indexContext:- return storepb.StatementType_CREATE_INDEX- case *parser.Create_tableContext:- return storepb.StatementType_CREATE_TABLE- case *parser.Create_viewContext:- return storepb.StatementType_CREATE_VIEW- case *parser.Drop_databaseContext:- return storepb.StatementType_DROP_DATABASE- case *parser.Drop_indexContext:- return storepb.StatementType_DROP_INDEX- case *parser.Drop_tableContext:- return storepb.StatementType_DROP_TABLE- case *parser.Drop_viewContext:- return storepb.StatementType_DROP_VIEW- case *parser.Truncate_tableContext:- return storepb.StatementType_TRUNCATE- case *parser.Delete_statementContext:- return storepb.StatementType_DELETE- case *parser.Insert_statementContext:- return storepb.StatementType_INSERT- case *parser.Update_statementContext:- return storepb.StatementType_UPDATE- default:- }- return storepb.StatementType_STATEMENT_TYPE_UNSPECIFIED-}diff --git a/backend/plugin/parser/plsql/statement_type_test.go b/backend/plugin/parser/plsql/statement_type_test.goindex 4e8ace6c63..80186d9ddf 100644--- a/backend/plugin/parser/plsql/statement_type_test.go+++ b/backend/plugin/parser/plsql/statement_type_test.go@@ -49,17 +49,15 @@ func TestGetStatementType(t *testing.T) {}}-func TestGetStatementTypeUsesOmniASTWithoutANTLRFallback(t *testing.T) {+func TestGetStatementTypeUsesOmniAST(t *testing.T) {stmts, err := base.ParseStatements(storepb.Engine_ORACLE, "CREATE SEQUENCE seq START WITH 1;")require.NoError(t, err)require.Len(t, stmts, 1)- omniAST, ok := stmts[0].AST.(*OmniAST)+ _, ok := stmts[0].AST.(*OmniAST)require.True(t, ok)- require.False(t, omniAST.antlrParsed)sqlTypes, err := GetStatementTypes(base.ExtractASTs(stmts))require.NoError(t, err)require.Equal(t, []storepb.StatementType{storepb.StatementType_CREATE_SEQUENCE}, sqlTypes)- require.False(t, omniAST.antlrParsed)}diff --git a/backend/plugin/parser/plsql/util.go b/backend/plugin/parser/plsql/util.godeleted file mode 100644index d82db53081..0000000000--- a/backend/plugin/parser/plsql/util.go+++ /dev/null@@ -1,83 +0,0 @@-package plsql--import (- "github.com/antlr4-go/antlr/v4"- "github.com/bytebase/parser/plsql"- "github.com/pkg/errors"-)--//nolint:unused-func plsqlNormalizeColumnName(currentSchema string, ctx plsql.IColumn_nameContext) (string, string, string, error) {- var buf []string- buf = append(buf, NormalizeIdentifierContext(ctx.Identifier()))- for _, idExpression := range ctx.AllId_expression() {- buf = append(buf, NormalizeIDExpression(idExpression))- }- switch len(buf) {- case 1:- return currentSchema, "", buf[0], nil- case 2:- return currentSchema, buf[0], buf[1], nil- case 3:- return buf[0], buf[1], buf[2], nil- default:- return "", "", "", errors.Errorf("invalid column name: %s", ctx.GetText())- }-}--//nolint:unused-func normalizeColumnAlias(ctx plsql.IColumn_aliasContext) string {- if ctx == nil {- return ""- }-- if ctx.Identifier() != nil {- return NormalizeIdentifierContext(ctx.Identifier())- }-- if ctx.Quoted_string() != nil {- return ctx.Quoted_string().GetText()- }-- return ""-}--func NormalizeTableAlias(ctx plsql.ITable_aliasContext) string {- if ctx == nil {- return ""- }-- if ctx.Identifier() != nil {- return NormalizeIdentifierContext(ctx.Identifier())- }-- if ctx.Quoted_string() != nil {- return ctx.Quoted_string().GetText()- }-- return ""-}--// NormalizeQuotedString returns the string without the quotes.-func NormalizeQuotedString(ctx plsql.IQuoted_stringContext) string {- if ctx == nil {- return ""- }-- raw := ctx.GetText()- return raw[1 : len(raw)-1]-}--func IsTopLevelStatement(ctx antlr.Tree) bool {- if ctx == nil {- return true- }- switch ctx := ctx.(type) {- case *plsql.Unit_statementContext, *plsql.Sql_scriptContext:- return true- case *plsql.Data_manipulation_language_statementsContext:- return IsTopLevelStatement(ctx.GetParent())- default:- return false- }-}diff --git a/backend/plugin/schema/oracle/get_database_metadata.go b/backend/plugin/schema/oracle/get_database_metadata.goindex 305fc53a86..f88693b9ac 100644--- a/backend/plugin/schema/oracle/get_database_metadata.go+++ b/backend/plugin/schema/oracle/get_database_metadata.go@@ -1,17 +1,7 @@package oracleimport (- "fmt"- "slices"- "strconv"- "strings"-- "github.com/antlr4-go/antlr/v4"- parser "github.com/bytebase/parser/plsql"- "github.com/pkg/errors"-storepb "github.com/bytebase/bytebase/backend/generated-go/store"- oracleparser "github.com/bytebase/bytebase/backend/plugin/parser/plsql""github.com/bytebase/bytebase/backend/plugin/schema")@@ -23,1461 +13,3 @@ func init() {func GetDatabaseMetadata(schemaText string) (*storepb.DatabaseSchemaMetadata, error) {return GetDatabaseMetadataOmni(schemaText)}--func getDatabaseMetadataANTLR(schemaText string) (*storepb.DatabaseSchemaMetadata, error) {- results, err := oracleparser.ParsePLSQL(schemaText)- if err != nil {- return nil, errors.Wrapf(err, "failed to parse Oracle schema")- }- if len(results) == 0 {- return nil, errors.New("no parse results")- }-- extractor := &metadataExtractor{- currentSchema: "",- currentTable: "",- tables: make(map[string]*storepb.TableMetadata),- views: make(map[string]*storepb.ViewMetadata),- materializedViews: make(map[string]*storepb.MaterializedViewMetadata),- functions: make(map[string]*storepb.FunctionMetadata),- procedures: make(map[string]*storepb.ProcedureMetadata),- triggers: make(map[string]*storepb.TriggerMetadata),- sequences: make(map[string]*storepb.SequenceMetadata),- packages: make(map[string]*storepb.PackageMetadata),- inlinePrimaryKeys: make(map[string][]string),- inlineUniqueKeys: make(map[string][]string),- }-- // Walk all parse result trees to extract metadata from all statements- for _, result := range results {- if result.Tree != nil {- antlr.ParseTreeWalkerDefault.Walk(extractor, result.Tree)- }- }-- if extractor.err != nil {- return nil, extractor.err- }-- // Build the final metadata structure- schemaMetadata := &storepb.DatabaseSchemaMetadata{- Name: extractor.currentDatabase,- Schemas: []*storepb.SchemaMetadata{},- }-- // Create single schema for Oracle (Oracle uses schemas, not separate databases)- // Keep schema name empty if not specified - this matches sync.go behavior- // and allows proper schema diff comparison- schemaName := extractor.currentSchema-- schema := &storepb.SchemaMetadata{- Name: schemaName,- Tables: []*storepb.TableMetadata{},- Views: []*storepb.ViewMetadata{},- MaterializedViews: []*storepb.MaterializedViewMetadata{},- Procedures: []*storepb.ProcedureMetadata{},- Functions: []*storepb.FunctionMetadata{},- Sequences: []*storepb.SequenceMetadata{},- }-- // Sort and add tables (exclude tables that are actually materialized views)- var tableNames []string- for name := range extractor.tables {- // Skip tables that are actually materialized views- if _, isMaterializedView := extractor.materializedViews[name]; !isMaterializedView {- tableNames = append(tableNames, name)- }- }- slices.Sort(tableNames)- for _, name := range tableNames {- schema.Tables = append(schema.Tables, extractor.tables[name])- }-- // Sort and add views- var viewNames []string- for name := range extractor.views {- viewNames = append(viewNames, name)- }- slices.Sort(viewNames)- for _, name := range viewNames {- schema.Views = append(schema.Views, extractor.views[name])- }-- // Sort and add materialized views- var materializedViewNames []string- for name := range extractor.materializedViews {- materializedViewNames = append(materializedViewNames, name)- }- slices.Sort(materializedViewNames)- for _, name := range materializedViewNames {- schema.MaterializedViews = append(schema.MaterializedViews, extractor.materializedViews[name])- }-- // Sort and add functions- var functionNames []string- for name := range extractor.functions {- functionNames = append(functionNames, name)- }- slices.Sort(functionNames)- for _, name := range functionNames {- schema.Functions = append(schema.Functions, extractor.functions[name])- }-- // Sort and add procedures- var procedureNames []string- for name := range extractor.procedures {- procedureNames = append(procedureNames, name)- }- slices.Sort(procedureNames)- for _, name := range procedureNames {- schema.Procedures = append(schema.Procedures, extractor.procedures[name])- }-- // Sort and add sequences- var sequenceNames []string- for name := range extractor.sequences {- sequenceNames = append(sequenceNames, name)- }- slices.Sort(sequenceNames)- for _, name := range sequenceNames {- schema.Sequences = append(schema.Sequences, extractor.sequences[name])- }-- schemaMetadata.Schemas = append(schemaMetadata.Schemas, schema)- return schemaMetadata, nil-}--// metadataExtractor walks the parse tree and extracts Oracle metadata-type metadataExtractor struct {- *parser.BasePlSqlParserListener-- currentDatabase string- currentSchema string- currentTable string // Track current table being processed- tables map[string]*storepb.TableMetadata- views map[string]*storepb.ViewMetadata- materializedViews map[string]*storepb.MaterializedViewMetadata- functions map[string]*storepb.FunctionMetadata- procedures map[string]*storepb.ProcedureMetadata- triggers map[string]*storepb.TriggerMetadata- sequences map[string]*storepb.SequenceMetadata- packages map[string]*storepb.PackageMetadata- err error- inlinePrimaryKeys map[string][]string // Track inline primary key columns by table- inlineUniqueKeys map[string][]string // Track inline unique key columns by table-}--// Helper function to get or create table-func (e *metadataExtractor) getOrCreateTable(tableName string) *storepb.TableMetadata {- if table, exists := e.tables[tableName]; exists {- return table- }-- table := &storepb.TableMetadata{- Name: tableName,- Columns: []*storepb.ColumnMetadata{},- Indexes: []*storepb.IndexMetadata{},- ForeignKeys: []*storepb.ForeignKeyMetadata{},- CheckConstraints: []*storepb.CheckConstraintMetadata{},- Triggers: []*storepb.TriggerMetadata{},- Partitions: []*storepb.TablePartitionMetadata{},- }- e.tables[tableName] = table- return table-}--// EnterCreate_table is called when entering a create table statement-func (e *metadataExtractor) EnterCreate_table(ctx *parser.Create_tableContext) {- if e.err != nil {- return- }-- if ctx.Table_name() == nil {- return- }-- // Extract schema and table name- if ctx.Schema_name() != nil {- e.currentSchema = oracleparser.NormalizeSchemaName(ctx.Schema_name())- }-- tableName := oracleparser.NormalizeTableName(ctx.Table_name())- if tableName == "" {- return- }-- // Set current table for inline constraint tracking- e.currentTable = tableName- table := e.getOrCreateTable(tableName)-- // Extract table elements (columns, constraints)- if ctx.Relational_table() != nil {- e.extractRelationalTable(ctx.Relational_table(), table)-- // Process inline constraints after all columns are parsed- e.processInlineConstraints(tableName, table)- }-- // Clear current table- e.currentTable = ""-}--// EnterCreate_index is called when entering a create index statement-func (e *metadataExtractor) EnterCreate_index(ctx *parser.Create_indexContext) {- if e.err != nil {- return- }-- if ctx.Index_name() == nil {- return- }-- // Extract schema and index name- schemaName, indexName := oracleparser.NormalizeIndexName(ctx.Index_name())- if indexName == "" {- return- }- if schemaName != "" {- e.currentSchema = schemaName- }-- // Extract table name from the index definition- tableName := ""- if ctx.Table_index_clause() != nil && ctx.Table_index_clause().Tableview_name() != nil {- tableName = normalizeTableViewName(ctx.Table_index_clause().Tableview_name())- } else if ctx.Cluster_index_clause() != nil {- // Handle cluster indexes if needed- return- }-- if tableName == "" {- return- }-- // Get or create the table- table := e.getOrCreateTable(tableName)-- // Create index metadata- index := &storepb.IndexMetadata{- Name: indexName,- Primary: false,- Unique: ctx.UNIQUE() != nil,- Type: "NORMAL", // Oracle default- Expressions: []string{},- Visible: true, // Oracle indexes are visible by default- }-- // Determine index type- if ctx.BITMAP() != nil {- index.Type = "BITMAP"- }-- // Extract index expressions- if ctx.Table_index_clause() != nil {- e.extractIndexExpressions(ctx.Table_index_clause(), index)- }-- table.Indexes = append(table.Indexes, index)-}--// extractIndexExpressions extracts column expressions from table index clause using ANTLR parser-func (*metadataExtractor) extractIndexExpressions(ctx parser.ITable_index_clauseContext, index *storepb.IndexMetadata) {- if ctx == nil {- return- }-- isFunctionBased := false- var descendingFlags []bool-- // Extract index expressions using ANTLR parser- indexExprOptions := ctx.AllIndex_expr_option()- for _, exprOption := range indexExprOptions {- if exprOption == nil {- continue- }-- var exprText string- isDescending := false-- // Get the index expression- if indexExpr := exprOption.Index_expr(); indexExpr != nil {- if columnName := indexExpr.Column_name(); columnName != nil {- // Simple column reference - extract without quotes- _, _, exprText = oracleparser.NormalizeColumnName(columnName)- // Remove quotes if present to match database metadata format- exprText = strings.Trim(exprText, "\"")- } else if expression := indexExpr.Expression(); expression != nil {- // Function-based expression- exprText = getTextFromContext(expression)- isFunctionBased = true- }- }-- // Check for ASC/DESC modifiers- isDescending = exprOption.DESC() != nil- // Note: Don't mark simple column DESC as function-based in the parser- // Oracle may internally treat it as function-based, but for DDL generation purposes,- // we should generate it as a normal index with explicit ASC/DESC modifiers-- // Store the expression (without ASC/DESC modifiers)- if exprText != "" {- index.Expressions = append(index.Expressions, exprText)- descendingFlags = append(descendingFlags, isDescending)- }- }-- // Always set descending flags to match the number of expressions- if len(descendingFlags) > 0 {- index.Descending = descendingFlags- }-- // Check if we have any descending columns to determine if this is function-based- hasDescending := false- for _, desc := range descendingFlags {- if desc {- hasDescending = true- break- }- }-- // Update index type for function-based indexes- // Oracle treats indexes with DESC columns or functions as "FUNCTION-BASED NORMAL"- if (isFunctionBased || hasDescending) && index.Type == "NORMAL" {- index.Type = "FUNCTION-BASED NORMAL"- }-}--// EnterCreate_view is called when entering a create view statement-func (e *metadataExtractor) EnterCreate_view(ctx *parser.Create_viewContext) {- if e.err != nil {- return- }-- // Extract schema and view name- schemaName := ""- viewName := ""-- if ctx.Schema_name() != nil {- schemaName = oracleparser.NormalizeSchemaName(ctx.Schema_name())- e.currentSchema = schemaName- }-- // Extract view name from GetV() which returns id_expression- if ctx.GetV() != nil {- viewName = oracleparser.NormalizeIDExpression(ctx.GetV())- }-- if viewName == "" {- return- }-- // Extract the select statement as the view definition- definition := ""- if ctx.Select_only_statement() != nil {- definition = getTextFromContext(ctx.Select_only_statement())- }-- view := &storepb.ViewMetadata{- Name: viewName,- Definition: definition,- }-- e.views[viewName] = view-}--// EnterCreate_materialized_view is called when entering a create materialized view statement-func (e *metadataExtractor) EnterCreate_materialized_view(ctx *parser.Create_materialized_viewContext) {- if e.err != nil {- return- }-- // Extract materialized view name from tableview_name- viewName := ""-- if ctx.Tableview_name() != nil {- viewName = normalizeTableViewName(ctx.Tableview_name())- }-- if viewName == "" {- return- }-- // Extract the select statement as the definition- definition := ""- if ctx.Select_only_statement() != nil {- definition = getTextFromContext(ctx.Select_only_statement())- // Ensure the definition ends with a newline to match database format- if definition != "" && !strings.HasSuffix(definition, "\n") {- definition += "\n"- }- }-- materializedView := &storepb.MaterializedViewMetadata{- Name: viewName,- Definition: definition,- }-- e.materializedViews[viewName] = materializedView-- // Ensure this materialized view is not also treated as a table- // Oracle parsing might have triggered table creation first- delete(e.tables, viewName)-}--// EnterCreate_sequence is called when entering a create sequence statement-func (e *metadataExtractor) EnterCreate_sequence(ctx *parser.Create_sequenceContext) {- if e.err != nil {- return- }-- if ctx.Sequence_name() == nil {- return- }-- // Extract sequence name- sequenceName := normalizeSequenceName(ctx.Sequence_name())- if sequenceName == "" {- return- }-- sequence := &storepb.SequenceMetadata{- Name: sequenceName,- }-- // Extract sequence options- e.extractSequenceOptions(ctx, sequence)-- e.sequences[sequenceName] = sequence-}--// extractSequenceOptions extracts sequence specification options using ANTLR parser-func (*metadataExtractor) extractSequenceOptions(ctx *parser.Create_sequenceContext, sequence *storepb.SequenceMetadata) {- // Extract sequence specifications using ANTLR parser- // Note: sequence_start_clause is now nested inside sequence_spec- sequenceSpecs := ctx.AllSequence_spec()- for _, spec := range sequenceSpecs {- // Extract START WITH clause (now nested in sequence_spec)- if startClause := spec.Sequence_start_clause(); startClause != nil {- if startClause.START() != nil && startClause.WITH() != nil && startClause.UNSIGNED_INTEGER() != nil {- startValue := startClause.UNSIGNED_INTEGER().GetText()- if startValue != "" {- sequence.Start = startValue- }- }- }-- // Extract INCREMENT BY value- if spec.INCREMENT() != nil && spec.BY() != nil && spec.UNSIGNED_INTEGER() != nil {- incrementValue := spec.UNSIGNED_INTEGER().GetText()- if incrementValue != "" && incrementValue != "1" {- // Only store non-default increment values (Oracle defaults to 1)- sequence.Increment = incrementValue- }- }-- // We could extract other sequence properties here if needed:- // - MAXVALUE/NOMAXVALUE- // - MINVALUE/NOMINVALUE- // - CYCLE/NOCYCLE- // - CACHE/NOCACHE- // - ORDER/NOORDER- }-}--// EnterCreate_function_body is called when entering a create function statement-func (e *metadataExtractor) EnterCreate_function_body(ctx *parser.Create_function_bodyContext) {- if e.err != nil {- return- }-- if ctx.Function_name() == nil {- return- }-- // Extract function name- functionName := normalizeFunctionName(ctx.Function_name())- if functionName == "" {- return- }-- // Extract the function body and ensure it has proper formatting- definition := getTextFromContext(ctx)-- // Clean up the definition to match expected format- // Remove CREATE OR REPLACE prefix if present- if strings.HasPrefix(strings.ToUpper(definition), "CREATE OR REPLACE ") {- definition = definition[18:] // Remove "CREATE OR REPLACE "- } else if strings.HasPrefix(strings.ToUpper(definition), "CREATE ") {- definition = definition[7:] // Remove "CREATE "- }-- // Ensure definition starts with FUNCTION keyword- if !strings.HasPrefix(strings.ToUpper(definition), "FUNCTION") {- definition = "FUNCTION " + definition- }-- function := &storepb.FunctionMetadata{- Name: functionName,- Definition: definition,- }-- e.functions[functionName] = function-}--// EnterCreate_procedure_body is called when entering a create procedure statement-func (e *metadataExtractor) EnterCreate_procedure_body(ctx *parser.Create_procedure_bodyContext) {- if e.err != nil {- return- }-- if ctx.Procedure_name() == nil {- return- }-- // Extract procedure name- procedureName := normalizeProcedureName(ctx.Procedure_name())- if procedureName == "" {- return- }-- // Extract the procedure body- definition := getTextFromContext(ctx)-- procedure := &storepb.ProcedureMetadata{- Name: procedureName,- Definition: definition,- }-- e.procedures[procedureName] = procedure-}--// extractRelationalTable extracts columns and constraints from relational table definition-func (e *metadataExtractor) extractRelationalTable(ctx parser.IRelational_tableContext, table *storepb.TableMetadata) {- if ctx == nil {- return- }-- // Extract all relational properties- for _, prop := range ctx.AllRelational_property() {- if prop == nil {- continue- }-- switch {- case prop.Column_definition() != nil:- column := e.extractColumnDefinition(prop.Column_definition())- if column != nil {- // Set position based on current column count (1-indexed)- column.Position = int32(len(table.Columns) + 1)- table.Columns = append(table.Columns, column)- }- case prop.Virtual_column_definition() != nil:- column := e.extractVirtualColumnDefinition(prop.Virtual_column_definition())- if column != nil {- // Set position based on current column count (1-indexed)- column.Position = int32(len(table.Columns) + 1)- table.Columns = append(table.Columns, column)- }- case prop.Out_of_line_constraint() != nil:- e.extractOutOfLineConstraint(prop.Out_of_line_constraint(), table)- case prop.Out_of_line_ref_constraint() != nil:- e.extractOutOfLineRefConstraint(prop.Out_of_line_ref_constraint(), table)- default:- // Other relational properties- }- }-}--// extractColumnDefinition extracts column metadata from column definition-func (e *metadataExtractor) extractColumnDefinition(ctx parser.IColumn_definitionContext) *storepb.ColumnMetadata {- if ctx == nil || ctx.Column_name() == nil {- return nil- }-- // Extract column name- columnName := normalizeColumnName(ctx.Column_name())- if columnName == "" {- return nil- }-- column := &storepb.ColumnMetadata{- Name: columnName,- Type: "VARCHAR2(100)", // Default type- Nullable: true, // Default to nullable- }-- // Extract data type- if ctx.Datatype() != nil {- column.Type = e.extractDataType(ctx.Datatype())- } else if ctx.Regular_id() != nil {- // Handle user-defined types- column.Type = strings.ToUpper(ctx.Regular_id().GetText())- }-- // Extract default value using ANTLR parser- if ctx.DEFAULT() != nil {- if expr := ctx.Expression(); expr != nil {- column.Default = getTextFromContext(expr)- }- }-- // Extract collation if specified- if ctx.COLLATE() != nil && ctx.Column_collation_name() != nil {- if collationName := ctx.Column_collation_name().Id_expression(); collationName != nil {- column.Collation = oracleparser.NormalizeIDExpression(collationName)- }- }-- // Extract identity clause- if ctx.Identity_clause() != nil {- e.extractIdentityClause(ctx.Identity_clause(), column)- }-- // Extract inline constraints- for _, constraint := range ctx.AllInline_constraint() {- e.extractInlineConstraint(constraint, column)- }-- // Check visibility - don't add to comment as this is structural info- if ctx.INVISIBLE() != nil {- // TODO: Set invisible column flag when available in proto- _ = ctx.INVISIBLE() // Acknowledge the context for now- }-- return column-}--// extractVirtualColumnDefinition extracts virtual column metadata-func (e *metadataExtractor) extractVirtualColumnDefinition(ctx parser.IVirtual_column_definitionContext) *storepb.ColumnMetadata {- if ctx == nil || ctx.Column_name() == nil {- return nil- }-- columnName := normalizeColumnName(ctx.Column_name())- if columnName == "" {- return nil- }-- column := &storepb.ColumnMetadata{- Name: columnName,- Type: "NUMBER", // Default type for virtual columns- Nullable: true,- }-- // Extract data type if specified- if ctx.Datatype() != nil {- column.Type = e.extractDataType(ctx.Datatype())- }-- // Mark as virtual and extract expression from context- // Virtual columns have expressions like: col_name AS (expression)- text := getTextFromContext(ctx)- if asIdx := strings.Index(strings.ToUpper(text), "AS"); asIdx != -1 {- // Find the expression in parentheses- remaining := text[asIdx+2:]- if openIdx := strings.Index(remaining, "("); openIdx != -1 {- // Find matching closing parenthesis- parenCount := 1- i := openIdx + 1- for i < len(remaining) && parenCount > 0 {- switch remaining[i] {- case '(':- parenCount++- case ')':- parenCount--- default:- // Other characters- }- i++- }- if parenCount == 0 {- column.Default = remaining[openIdx+1 : i-1]- }- }- }-- // Mark as virtual column - don't add to comment as this is structural info- // TODO: Set virtual column flag when available in proto-- // Extract inline constraints- for _, constraint := range ctx.AllInline_constraint() {- e.extractInlineConstraint(constraint, column)- }-- return column-}--// extractDataType extracts Oracle data type using ANTLR parser with fallback to text-func (*metadataExtractor) extractDataType(ctx parser.IDatatypeContext) string {- if ctx == nil {- return ""- }-- // For now, use the original approach to get full text and normalize it- // The ANTLR parsing of complex types like INTERVAL and TIMESTAMP WITH TIME ZONE- // requires more detailed grammar understanding than currently implemented- return normalizeDataTypeText(getTextFromContext(ctx))-}--// extractInlineConstraint extracts inline column constraints-func (e *metadataExtractor) extractInlineConstraint(ctx parser.IInline_constraintContext, column *storepb.ColumnMetadata) {- if ctx == nil {- return- }-- // Handle NOT NULL constraint- if ctx.NOT() != nil && ctx.NULL_() != nil {- column.Nullable = false- }-- // Handle NULL constraint (explicitly nullable)- if ctx.NULL_() != nil && ctx.NOT() == nil {- column.Nullable = true- }-- // Handle PRIMARY KEY constraint- if ctx.PRIMARY() != nil && ctx.KEY() != nil {- column.Nullable = false- // Track this column for primary key index creation- if e.currentTable != "" {- if e.inlinePrimaryKeys[e.currentTable] == nil {- e.inlinePrimaryKeys[e.currentTable] = []string{}- }- e.inlinePrimaryKeys[e.currentTable] = append(e.inlinePrimaryKeys[e.currentTable], column.Name)- }- }-- // Handle UNIQUE constraint- if ctx.UNIQUE() != nil {- // Note: UNIQUE columns can be nullable in Oracle- // Track this column for unique index creation- if e.currentTable != "" {- if e.inlineUniqueKeys[e.currentTable] == nil {- e.inlineUniqueKeys[e.currentTable] = []string{}- }- e.inlineUniqueKeys[e.currentTable] = append(e.inlineUniqueKeys[e.currentTable], column.Name)- }- }-- // Handle CHECK constraint - check if the text contains CHECK keyword- text := strings.ToUpper(getTextFromContext(ctx))- if strings.Contains(text, "CHECK") {- // Check constraints are parsed but not added to column comments- // This is structural information handled elsewhere- _ = text // Acknowledge we checked the text- }-- // Handle REFERENCES (inline foreign key)- if ctx.References_clause() != nil {- // Don't add foreign key info to comment - this is structural information- _ = ctx.References_clause() // Acknowledge the context- }-}--// extractIdentityClause extracts identity column information-func (*metadataExtractor) extractIdentityClause(ctx parser.IIdentity_clauseContext, column *storepb.ColumnMetadata) {- if ctx == nil {- return- }-- // Mark as identity column- if ctx.ALWAYS() != nil {- column.IsIdentity = true- // TODO: Set identity generation type when proto is updated- } else if ctx.BY() != nil && ctx.DEFAULT() != nil {- column.IsIdentity = true- // TODO: Set identity generation type when proto is updated- }- // Don't add identity info to comment - this is structural information-- // Identity columns are NOT NULL by default- column.Nullable = false-}--// extractOutOfLineConstraint extracts out-of-line table constraints-func (e *metadataExtractor) extractOutOfLineConstraint(ctx parser.IOut_of_line_constraintContext, table *storepb.TableMetadata) {- if ctx == nil {- return- }-- // Extract constraint name- constraintName := ""- if ctx.Constraint_name() != nil {- constraintName = normalizeConstraintName(ctx.Constraint_name())- }-- // Handle different constraint types- switch {- case ctx.PRIMARY() != nil && ctx.KEY() != nil:- e.extractPrimaryKeyConstraint(ctx, table, constraintName)- case ctx.UNIQUE() != nil:- e.extractUniqueConstraint(ctx, table, constraintName)- case ctx.CHECK() != nil:- e.extractCheckConstraint(ctx, table, constraintName)- default:- // Other constraint types- }-}--// extractOutOfLineRefConstraint extracts out-of-line foreign key constraints-func (e *metadataExtractor) extractOutOfLineRefConstraint(ctx parser.IOut_of_line_ref_constraintContext, table *storepb.TableMetadata) {- if ctx == nil {- return- }-- // Extract constraint name- constraintName := ""- if ctx.Constraint_name() != nil {- constraintName = normalizeConstraintName(ctx.Constraint_name())- }-- if ctx.FOREIGN() != nil && ctx.KEY() != nil {- e.extractForeignKeyConstraint(ctx, table, constraintName)- }-}--// extractPrimaryKeyConstraint extracts primary key constraint-func (*metadataExtractor) extractPrimaryKeyConstraint(ctx parser.IOut_of_line_constraintContext, table *storepb.TableMetadata, constraintName string) {- if constraintName == "" {- constraintName = fmt.Sprintf("PK_%s", table.Name)- }-- // Extract column names- var columns []string- for _, colName := range ctx.AllColumn_name() {- if normalized := normalizeColumnName(colName); normalized != "" {- columns = append(columns, normalized)- }- }-- if len(columns) == 0 {- return- }-- // Create primary key index- index := &storepb.IndexMetadata{- Name: constraintName,- Primary: true,- Unique: true,- Type: "NORMAL",- Expressions: columns,- Visible: true, // Oracle indexes are visible by default- IsConstraint: true, // This represents a primary key constraint- }-- table.Indexes = append(table.Indexes, index)-- // Mark columns as NOT NULL- for _, col := range table.Columns {- for _, pkCol := range columns {- if col.Name == pkCol {- col.Nullable = false- break- }- }- }-}--// extractUniqueConstraint extracts unique constraint-func (*metadataExtractor) extractUniqueConstraint(ctx parser.IOut_of_line_constraintContext, table *storepb.TableMetadata, constraintName string) {- if constraintName == "" {- constraintName = fmt.Sprintf("UK_%s_%d", table.Name, len(table.Indexes)+1)- }-- // Extract column names- var columns []string- for _, colName := range ctx.AllColumn_name() {- if normalized := normalizeColumnName(colName); normalized != "" {- columns = append(columns, normalized)- }- }-- if len(columns) == 0 {- return- }-- // Create unique index- index := &storepb.IndexMetadata{- Name: constraintName,- Primary: false,- Unique: true,- Type: "NORMAL",- Expressions: columns,- Visible: false, // Oracle constraint-based unique indexes are not visible- IsConstraint: true, // This represents a unique constraint- }-- table.Indexes = append(table.Indexes, index)-}--// extractCheckConstraint extracts check constraint using ANTLR parser-func (*metadataExtractor) extractCheckConstraint(ctx parser.IOut_of_line_constraintContext, table *storepb.TableMetadata, constraintName string) {- if constraintName == "" {- constraintName = fmt.Sprintf("CHK_%s_%d", table.Name, len(table.CheckConstraints)+1)- }-- // Extract check condition using ANTLR parser- if ctx.CHECK() != nil {- if condition := ctx.Condition(); condition != nil {- check := &storepb.CheckConstraintMetadata{- Name: constraintName,- Expression: getTextFromContext(condition),- }- table.CheckConstraints = append(table.CheckConstraints, check)- }- }-}--// extractForeignKeyConstraint extracts foreign key constraint-func (e *metadataExtractor) extractForeignKeyConstraint(ctx parser.IOut_of_line_ref_constraintContext, table *storepb.TableMetadata, constraintName string) {- if constraintName == "" {- constraintName = fmt.Sprintf("FK_%s_%d", table.Name, len(table.ForeignKeys)+1)- }-- // Extract local columns from the context- var columns []string- // The foreign key columns are usually specified after FOREIGN KEY- text := getTextFromContext(ctx)- if fkIdx := strings.Index(strings.ToUpper(text), "FOREIGNKEY"); fkIdx != -1 {- // Find the column list in parentheses- if openIdx := strings.Index(text[fkIdx:], "("); openIdx != -1 {- if closeIdx := strings.Index(text[fkIdx+openIdx:], ")"); closeIdx != -1 {- colList := text[fkIdx+openIdx+1 : fkIdx+openIdx+closeIdx]- for _, col := range strings.Split(colList, ",") {- col = strings.TrimSpace(col)- col = strings.Trim(col, "\"")- if col != "" {- columns = append(columns, strings.ToUpper(col))- }- }- }- }- }-- if len(columns) == 0 || ctx.References_clause() == nil {- return- }-- // Extract referenced table and columns- referencedTable, referencedColumns := e.extractReferencesClause(ctx.References_clause())- if referencedTable == "" || len(referencedColumns) == 0 {- return- }-- foreignKey := &storepb.ForeignKeyMetadata{- Name: constraintName,- Columns: columns,- ReferencedTable: referencedTable,- ReferencedColumns: referencedColumns,- }-- // Extract ON DELETE action from the text- text = strings.ToUpper(getTextFromContext(ctx))- if strings.Contains(text, "ONDELETECASCADE") {- foreignKey.OnDelete = "CASCADE"- } else if strings.Contains(text, "ONDELETESETNULL") {- foreignKey.OnDelete = "SET NULL"- }-- table.ForeignKeys = append(table.ForeignKeys, foreignKey)-}--// extractReferencesClause extracts referenced table and columns from references clause-func (*metadataExtractor) extractReferencesClause(ctx parser.IReferences_clauseContext) (string, []string) {- if ctx == nil || ctx.Tableview_name() == nil {- return "", nil- }-- // Extract referenced table name- referencedTable := normalizeTableViewName(ctx.Tableview_name())-- // Extract referenced columns from parentheses after table name- var referencedColumns []string- text := getTextFromContext(ctx)- tableEnd := strings.Index(text, referencedTable) + len(referencedTable)- if tableEnd < len(text) {- remaining := text[tableEnd:]- if openIdx := strings.Index(remaining, "("); openIdx != -1 {- if closeIdx := strings.Index(remaining[openIdx:], ")"); closeIdx != -1 {- colList := remaining[openIdx+1 : openIdx+closeIdx]- for _, col := range strings.Split(colList, ",") {- col = strings.TrimSpace(col)- col = strings.Trim(col, "\"")- if col != "" {- referencedColumns = append(referencedColumns, strings.ToUpper(col))- }- }- }- }- }-- // If no columns specified, default to primary key columns (Oracle behavior)- if len(referencedColumns) == 0 {- referencedColumns = []string{"ID"} // Default assumption- }-- return referencedTable, referencedColumns-}--// normalizeColumnName extracts and normalizes column name-func normalizeColumnName(ctx parser.IColumn_nameContext) string {- if ctx == nil {- return ""- }-- // Extract all parts of the column name- var parts []string- if ctx.Identifier() != nil {- parts = append(parts, oracleparser.NormalizeIdentifierContext(ctx.Identifier()))- }- for _, idExpr := range ctx.AllId_expression() {- parts = append(parts, oracleparser.NormalizeIDExpression(idExpr))- }-- // Return the last part as the column name- if len(parts) > 0 {- return parts[len(parts)-1]- }- return ""-}--// normalizeConstraintName extracts and normalizes constraint name-func normalizeConstraintName(ctx parser.IConstraint_nameContext) string {- if ctx == nil {- return ""- }-- // Extract all parts of the constraint name- var parts []string- if ctx.Identifier() != nil {- parts = append(parts, oracleparser.NormalizeIdentifierContext(ctx.Identifier()))- }- for _, idExpr := range ctx.AllId_expression() {- parts = append(parts, oracleparser.NormalizeIDExpression(idExpr))- }-- // Return the full constraint name- return strings.Join(parts, ".")-}--// normalizeTableViewName extracts and normalizes table/view name-func normalizeTableViewName(ctx parser.ITableview_nameContext) string {- if ctx == nil {- return ""- }-- // Extract the table/view name parts- var parts []string- if ctx.Identifier() != nil {- parts = append(parts, oracleparser.NormalizeIdentifierContext(ctx.Identifier()))- }- if ctx.Id_expression() != nil {- parts = append(parts, oracleparser.NormalizeIDExpression(ctx.Id_expression()))- }-- // Return the last part as the table/view name- if len(parts) > 0 {- return parts[len(parts)-1]- }- return ""-}--// normalizeSequenceName extracts and normalizes sequence name-func normalizeSequenceName(ctx parser.ISequence_nameContext) string {- if ctx == nil {- return ""- }-- // Extract all parts of the sequence name- var parts []string- for _, idExpr := range ctx.AllId_expression() {- parts = append(parts, oracleparser.NormalizeIDExpression(idExpr))- }-- // Return the last part as the sequence name- if len(parts) > 0 {- return parts[len(parts)-1]- }- return ""-}--// normalizeFunctionName extracts and normalizes function name-func normalizeFunctionName(ctx parser.IFunction_nameContext) string {- if ctx == nil {- return ""- }-- // Function name is a simple identifier or schema.function format- // Get the text and parse it- text := getTextFromContext(ctx)- parts := strings.Split(text, ".")- for i, part := range parts {- parts[i] = strings.ToUpper(strings.Trim(part, "\""))- }-- // Return the last part as the function name- if len(parts) > 0 {- return parts[len(parts)-1]- }- return ""-}--// normalizeProcedureName extracts and normalizes procedure name-func normalizeProcedureName(ctx parser.IProcedure_nameContext) string {- if ctx == nil {- return ""- }-- // Procedure name is a simple identifier or schema.procedure format- // Get the text and parse it- text := getTextFromContext(ctx)- parts := strings.Split(text, ".")- for i, part := range parts {- parts[i] = strings.ToUpper(strings.Trim(part, "\""))- }-- // Return the last part as the procedure name- if len(parts) > 0 {- return parts[len(parts)-1]- }- return ""-}--// EnterComment_on_table is called when entering a comment on table statement-func (e *metadataExtractor) EnterComment_on_table(ctx *parser.Comment_on_tableContext) {- if e.err != nil {- return- }-- if ctx.Tableview_name() == nil {- return- }-- // Extract table name- tableName := normalizeTableViewName(ctx.Tableview_name())- if tableName == "" {- return- }-- // Extract comment text- comment := ""- if ctx.Quoted_string() != nil {- comment = oracleparser.NormalizeQuotedString(ctx.Quoted_string())- }-- if comment != "" {- if table, exists := e.tables[tableName]; exists {- table.Comment = comment- }- }-}--// EnterComment_on_column is called when entering a comment on column statement-func (e *metadataExtractor) EnterComment_on_column(ctx *parser.Comment_on_columnContext) {- if e.err != nil {- return- }-- if ctx.Column_name() == nil {- return- }-- // Extract table and column names from the column_name context- // Column name can be in format: table.column or just column- parts := []string{}- if ctx.Column_name().Identifier() != nil {- parts = append(parts, oracleparser.NormalizeIdentifierContext(ctx.Column_name().Identifier()))- }- for _, idExpr := range ctx.Column_name().AllId_expression() {- parts = append(parts, oracleparser.NormalizeIDExpression(idExpr))- }-- var tableName, columnName string- switch len(parts) {- case 1:- // Just column name, need to find the table- // In this case, we might need to use the most recently created table- // or handle it differently based on context- return- case 2:- // table.column format- tableName = parts[0]- columnName = parts[1]- case 3:- // schema.table.column format- tableName = parts[1]- columnName = parts[2]- default:- return- }-- // Extract comment text- comment := ""- if ctx.Quoted_string() != nil {- comment = oracleparser.NormalizeQuotedString(ctx.Quoted_string())- }-- if tableName != "" && columnName != "" && comment != "" {- if table, exists := e.tables[tableName]; exists {- for _, col := range table.Columns {- if col.Name == columnName {- // Set the actual user comment- col.Comment = comment- break- }- }- }- }-}--// normalizeDataTypeText normalizes Oracle data type text to match database output format-func normalizeDataTypeText(text string) string {- if text == "" {- return ""- }-- // Convert to uppercase but preserve the precision/scale information- normalized := strings.ToUpper(text)-- // Handle special cases for Oracle data types- switch {- case strings.HasPrefix(normalized, "VARCHAR2"):- // Handle VARCHAR2 with BYTE/CHAR specifiers- if strings.HasPrefix(normalized, "VARCHAR2(") && strings.HasSuffix(normalized, ")") {- start := strings.Index(normalized, "(") + 1- end := strings.LastIndex(normalized, ")")- if start < end {- sizeStr := normalized[start:end]- if size := parseInt(sizeStr); size > 0 {- // Oracle defaults to BYTE semantics, add BYTE specifier- return fmt.Sprintf("VARCHAR2(%d BYTE)", size)- }- }- }- return normalized- case strings.HasPrefix(normalized, "CHAR("):- // Handle CHAR with BYTE/CHAR specifiers- if strings.HasSuffix(normalized, ")") {- start := strings.Index(normalized, "(") + 1- end := strings.LastIndex(normalized, ")")- if start < end {- sizeStr := normalized[start:end]- if size := parseInt(sizeStr); size > 0 {- // Oracle defaults to BYTE semantics, add BYTE specifier- return fmt.Sprintf("CHAR(%d BYTE)", size)- }- }- }- return normalized- case strings.HasPrefix(normalized, "TIMESTAMP"):- // Handle TIMESTAMP variations and apply Oracle defaults- // Check for both spaced and non-spaced formats- if strings.Contains(normalized, "WITH LOCAL TIME ZONE") || strings.Contains(normalized, "WITHLOCALTIMEZONE") {- // Handle TIMESTAMP WITH LOCAL TIME ZONE- if normalized == "TIMESTAMP WITH LOCAL TIME ZONE" {- return "TIMESTAMP(6) WITH LOCAL TIME ZONE"- }- // If it already has precision, keep proper spacing- if strings.Contains(normalized, "(") && strings.Contains(normalized, ")") {- // Ensure proper spacing- result := strings.ReplaceAll(normalized, "WITHLOCALTIMEZONE", " WITH LOCAL TIME ZONE")- return result- }- return "TIMESTAMP(6) WITH LOCAL TIME ZONE"- } else if strings.Contains(normalized, "WITH TIME ZONE") || strings.Contains(normalized, "WITHTIMEZONE") {- // Handle TIMESTAMP WITH TIME ZONE- if normalized == "TIMESTAMP WITH TIME ZONE" {- return "TIMESTAMP(6) WITH TIME ZONE"- }- // If it already has precision, keep proper spacing- if strings.Contains(normalized, "(") && strings.Contains(normalized, ")") {- // Ensure proper spacing- result := strings.ReplaceAll(normalized, "WITHTIMEZONE", " WITH TIME ZONE")- return result- }- return "TIMESTAMP(6) WITH TIME ZONE"- } else if normalized == "TIMESTAMP" {- // Plain TIMESTAMP gets default precision- return "TIMESTAMP(6)"- }- return normalized- case strings.HasPrefix(normalized, "INTERVAL"):- // Handle INTERVAL types with proper spacing and precision- // Check for both spaced and non-spaced formats- if strings.Contains(normalized, "YEAR TO MONTH") || strings.Contains(normalized, "YEARTOMONTH") {- // Handle INTERVAL YEAR TO MONTH- if normalized == "INTERVAL YEAR TO MONTH" {- return "INTERVAL YEAR(2) TO MONTH"- }- // If it already has precision, keep proper spacing- if strings.Contains(normalized, "(") && strings.Contains(normalized, ")") {- // Ensure proper spacing- result := strings.ReplaceAll(normalized, "YEARTOMONTH", " YEAR TO MONTH")- result = strings.ReplaceAll(result, "INTERVALYEAR", "INTERVAL YEAR")- return result- }- return "INTERVAL YEAR(2) TO MONTH"- } else if strings.Contains(normalized, "DAY TO SECOND") || strings.Contains(normalized, "DAYTOSECOND") {- // Handle INTERVAL DAY TO SECOND- if normalized == "INTERVAL DAY TO SECOND" {- return "INTERVAL DAY(2) TO SECOND(6)"- }- // If it already has precision, keep proper spacing- if strings.Contains(normalized, "(") && strings.Contains(normalized, ")") {- // Ensure proper spacing- result := strings.ReplaceAll(normalized, "DAYTOSECOND", " DAY TO SECOND")- result = strings.ReplaceAll(result, "INTERVALDAY", "INTERVAL DAY")- return result- }- return "INTERVAL DAY(2) TO SECOND(6)"- }- return normalized- case strings.HasPrefix(normalized, "LONGRAW"):- return "LONG RAW"- case strings.HasPrefix(normalized, "DOUBLE"):- return "DOUBLE PRECISION"- case normalized == "UROWID":- // Oracle's default UROWID size is 4000- return "UROWID(4000)"- case normalized == "FLOAT":- // Oracle's default FLOAT precision is 126- return "FLOAT(126)"- case strings.HasPrefix(normalized, "NVARCHAR2"):- // Handle Oracle NVARCHAR2 type expansion - Oracle expands sizes based on character set- // For AL16UTF16: NVARCHAR2(2000) becomes NVARCHAR2(4000) in the database- // We need to expand parsed DDL sizes to match what Oracle stores- if strings.HasPrefix(normalized, "NVARCHAR2(") && strings.HasSuffix(normalized, ")") {- start := strings.Index(normalized, "(") + 1- end := strings.LastIndex(normalized, ")")- if start < end {- sizeStr := normalized[start:end]- if size := parseInt(sizeStr); size > 0 {- // Expand to match Oracle's internal storage- // Oracle doubles the size for AL16UTF16 character set- if size == 2000 {- return "NVARCHAR2(4000)"- } else if size <= 2000 {- return fmt.Sprintf("NVARCHAR2(%d)", size*2)- }- }- }- }- return normalized- case strings.HasPrefix(normalized, "NCHAR"):- // Handle Oracle NCHAR type expansion - Oracle expands NCHAR sizes based on character set- // AL16UTF16 uses 2 bytes per character, so NCHAR(100) becomes NCHAR(200) in the database- // We need to expand parsed DDL sizes to match what Oracle stores- if strings.HasPrefix(normalized, "NCHAR(") && strings.HasSuffix(normalized, ")") {- start := strings.Index(normalized, "(") + 1- end := strings.LastIndex(normalized, ")")- if start < end {- sizeStr := normalized[start:end]- if size := parseInt(sizeStr); size > 0 {- // Expand to match Oracle's internal storage (double for AL16UTF16)- return fmt.Sprintf("NCHAR(%d)", size*2)- }- }- }- return normalized- default:- return normalized- }-}--// parseInt helper function to parse integer from string-func parseInt(s string) int {- if i, err := strconv.Atoi(s); err == nil {- return i- }- return 0-}--// getTextFromContext gets text from ANTLR context preserving original spacing-func getTextFromContext(ctx any) string {- // Try to get parser-aware context first- if parserCtx, ok := ctx.(interface {- GetParser() antlr.Parser- }); ok {- parser := parserCtx.GetParser()- if parser != nil {- if ruleCtx, ok := ctx.(antlr.RuleContext); ok {- return parser.GetTokenStream().GetTextFromRuleContext(ruleCtx)- }- }- }-- // Fallback to GetText() for other contexts- if textCtx, ok := ctx.(interface{ GetText() string }); ok {- return textCtx.GetText()- }-- return ""-}--// processInlineConstraints creates indexes for inline PRIMARY KEY and UNIQUE constraints-// This simulates Oracle's automatic index creation behavior-func (e *metadataExtractor) processInlineConstraints(tableName string, table *storepb.TableMetadata) {- // Process inline primary key constraints- if primaryKeyColumns := e.inlinePrimaryKeys[tableName]; len(primaryKeyColumns) > 0 {- constraintName := fmt.Sprintf("PK_%s", tableName)-- // Check if a primary key index already exists (from out-of-line constraints)- hasExistingPK := false- for _, idx := range table.Indexes {- if idx.Primary {- hasExistingPK = true- break- }- }-- // Oracle automatically creates a unique index for PRIMARY KEY constraints- if !hasExistingPK {- index := &storepb.IndexMetadata{- Name: constraintName,- Primary: true,- Unique: true,- Type: "NORMAL",- Expressions: primaryKeyColumns,- Visible: true, // Oracle indexes are visible by default- IsConstraint: true, // This represents a primary key constraint- }- table.Indexes = append(table.Indexes, index)- }-- // Clean up the tracking- delete(e.inlinePrimaryKeys, tableName)- }-- // Process inline unique constraints- if uniqueKeyColumns := e.inlineUniqueKeys[tableName]; len(uniqueKeyColumns) > 0 {- for _, columnName := range uniqueKeyColumns {- constraintName := fmt.Sprintf("UK_%s_%s", tableName, columnName)-- // Check if a unique index already exists for this column- hasExistingUnique := false- for _, idx := range table.Indexes {- if idx.Unique && !idx.Primary && len(idx.Expressions) == 1 && idx.Expressions[0] == columnName {- hasExistingUnique = true- break- }- }-- // Oracle automatically creates a unique index for UNIQUE constraints- if !hasExistingUnique {- index := &storepb.IndexMetadata{- Name: constraintName,- Primary: false,- Unique: true,- Type: "NORMAL",- Expressions: []string{columnName},- Visible: true, // Oracle indexes are visible by default- IsConstraint: true, // This represents a unique constraint- }- table.Indexes = append(table.Indexes, index)- }- }-- // Clean up the tracking- delete(e.inlineUniqueKeys, tableName)- }-}diff --git a/backend/plugin/schema/oracle/get_database_metadata_omni.go b/backend/plugin/schema/oracle/get_database_metadata_omni.goindex 74ea9d3a83..f9128d1483 100644--- a/backend/plugin/schema/oracle/get_database_metadata_omni.go+++ b/backend/plugin/schema/oracle/get_database_metadata_omni.go@@ -465,7 +465,7 @@ func (e *oracleOmniMetadataExtractor) checkConstraintNameNextSet(table *storepb.return next}-func (*oracleOmniMetadataExtractor) appendForeignKey(table *storepb.TableMetadata, name string, columns []string, refTable *ast.ObjectName, refColumns *ast.List, _ string) {+func (*oracleOmniMetadataExtractor) appendForeignKey(table *storepb.TableMetadata, name string, columns []string, refTable *ast.ObjectName, refColumns *ast.List, onDelete string) {referencedTable := objectName(refTable)referencedColumns := stringList(refColumns)if len(columns) == 0 || referencedTable == "" {@@ -476,6 +476,7 @@ func (*oracleOmniMetadataExtractor) appendForeignKey(table *storepb.TableMetadatColumns: columns,ReferencedTable: referencedTable,ReferencedColumns: referencedColumns,+ OnDelete: onDelete,}table.ForeignKeys = append(table.ForeignKeys, foreignKey)}diff --git a/backend/plugin/schema/oracle/get_database_metadata_omni_test.go b/backend/plugin/schema/oracle/get_database_metadata_omni_test.goindex b78f619543..e87b05411d 100644--- a/backend/plugin/schema/oracle/get_database_metadata_omni_test.go+++ b/backend/plugin/schema/oracle/get_database_metadata_omni_test.go@@ -4,7 +4,6 @@ import ("testing""github.com/stretchr/testify/require"- "google.golang.org/protobuf/proto"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/schema"@@ -65,7 +64,7 @@ CREATE SEQUENCE emp_seq START WITH 1 INCREMENT BY 1;requireIndex(t, employees, "UK_EMPLOYEES_EMAIL", []string{"EMAIL"}, false, true)requireIndex(t, employees, "IDX_EMP_DEPT", []string{"DEPT_ID"}, false, false)requireCheckConstraint(t, employees, "CHK_SALARY", "SALARY>=0")- requireForeignKey(t, employees, "FK_EMP_DEPT", []string{"DEPT_ID"}, "DEPARTMENTS", []string{"DEPT_ID"})+ requireForeignKey(t, employees, "FK_EMP_DEPT", []string{"DEPT_ID"}, "DEPARTMENTS", []string{"DEPT_ID"}, "SET NULL")require.Len(t, schemaMetadata.Views, 1)require.Equal(t, "ACTIVE_EMPLOYEES", schemaMetadata.Views[0].Name)@@ -224,7 +223,7 @@ ALTER TABLE DEPARTMENTS ADD CONSTRAINT fk_dept_managerverify: func(t *testing.T, metadata *storepb.DatabaseSchemaMetadata) {schemaMetadata := requireSingleSchema(t, metadata)departments := requireTable(t, schemaMetadata, "DEPARTMENTS")- requireForeignKey(t, departments, "FK_DEPT_MANAGER", []string{"MANAGER_ID"}, "EMPLOYEES", []string{"EMP_ID"})+ requireForeignKey(t, departments, "FK_DEPT_MANAGER", []string{"MANAGER_ID"}, "EMPLOYEES", []string{"EMP_ID"}, "SET NULL")},},{@@ -269,8 +268,8 @@ CREATE TABLE EMPLOYEES (employees := requireTable(t, requireSingleSchema(t, metadata), "EMPLOYEES")requireCheckConstraint(t, employees, "CHK_EMPLOYEES_SALARY", "SALARY>0")requireCheckConstraint(t, employees, "CHK_EMPLOYEES_SALARY_2", "SALARY<1000000")- requireForeignKey(t, employees, "FK_EMPLOYEES_DEPT_ID", []string{"DEPT_ID"}, "DEPARTMENTS", []string{"DEPT_ID"})- requireForeignKey(t, employees, "FK_MANAGER_DEPT", []string{"MANAGER_DEPT_ID"}, "DEPARTMENTS", []string{"DEPT_ID"})+ requireForeignKey(t, employees, "FK_EMPLOYEES_DEPT_ID", []string{"DEPT_ID"}, "DEPARTMENTS", []string{"DEPT_ID"}, "")+ requireForeignKey(t, employees, "FK_MANAGER_DEPT", []string{"MANAGER_DEPT_ID"}, "DEPARTMENTS", []string{"DEPT_ID"}, "")},},{@@ -360,23 +359,6 @@ END financial_utils;}}-func TestGetDatabaseMetadataOmniParityWithANTLR(t *testing.T) {- for _, tc := range oracleMetadataTestCases() {- t.Run(tc.name, func(t *testing.T) {- expected, err := getDatabaseMetadataANTLR(tc.ddl)- require.NoError(t, err)-- actual, err := GetDatabaseMetadataOmni(tc.ddl)- require.NoError(t, err)-- actualForANTLR, ok := proto.Clone(actual).(*storepb.DatabaseSchemaMetadata)- require.True(t, ok)- trimOmniOnlyConstraintMetadata(expected, actualForANTLR)- compareMetadata(t, expected, actualForANTLR, tc.name)- })- }-}-func TestGetDatabaseMetadataUsesOmni(t *testing.T) {metadata, err := schema.GetDatabaseMetadata(storepb.Engine_ORACLE, `CREATE TABLE T (@@ -489,7 +471,7 @@ func requireCheckConstraint(t *testing.T, table *storepb.TableMetadata, name strt.Fatalf("check constraint %q not found in table %q", name, table.Name)}-func requireForeignKey(t *testing.T, table *storepb.TableMetadata, name string, columns []string, referencedTable string, referencedColumns []string) {+func requireForeignKey(t *testing.T, table *storepb.TableMetadata, name string, columns []string, referencedTable string, referencedColumns []string, onDelete string) {t.Helper()for _, fk := range table.ForeignKeys {if fk.Name != name {@@ -498,58 +480,8 @@ func requireForeignKey(t *testing.T, table *storepb.TableMetadata, name string,require.Equal(t, columns, fk.Columns)require.Equal(t, referencedTable, fk.ReferencedTable)require.Equal(t, referencedColumns, fk.ReferencedColumns)- require.Empty(t, fk.OnDelete)+ require.Equal(t, onDelete, fk.OnDelete)return}t.Fatalf("foreign key %q not found in table %q", name, table.Name)}--func trimOmniOnlyConstraintMetadata(expected *storepb.DatabaseSchemaMetadata, actual *storepb.DatabaseSchemaMetadata) {- if len(expected.Schemas) != 1 || len(actual.Schemas) != 1 {- return- }-- expectedTableByName := make(map[string]*storepb.TableMetadata)- for _, table := range expected.Schemas[0].Tables {- expectedTableByName[table.Name] = table- }-- for _, actualTable := range actual.Schemas[0].Tables {- expectedTable, ok := expectedTableByName[actualTable.Name]- if !ok {- continue- }- actualTable.ForeignKeys = filterForeignKeysByExpected(actualTable.ForeignKeys, expectedTable.ForeignKeys)- actualTable.CheckConstraints = filterCheckConstraintsByExpected(actualTable.CheckConstraints, expectedTable.CheckConstraints)- }-}--func filterForeignKeysByExpected(actual []*storepb.ForeignKeyMetadata, expected []*storepb.ForeignKeyMetadata) []*storepb.ForeignKeyMetadata {- expectedName := make(map[string]bool)- for _, foreignKey := range expected {- expectedName[foreignKey.Name] = true- }-- var filtered []*storepb.ForeignKeyMetadata- for _, foreignKey := range actual {- if expectedName[foreignKey.Name] {- filtered = append(filtered, foreignKey)- }- }- return filtered-}--func filterCheckConstraintsByExpected(actual []*storepb.CheckConstraintMetadata, expected []*storepb.CheckConstraintMetadata) []*storepb.CheckConstraintMetadata {- expectedName := make(map[string]bool)- for _, checkConstraint := range expected {- expectedName[checkConstraint.Name] = true- }-- var filtered []*storepb.CheckConstraintMetadata- for _, checkConstraint := range actual {- if expectedName[checkConstraint.Name] {- filtered = append(filtered, checkConstraint)- }- }- return filtered-}diff --git a/backend/plugin/schema/oracle/metadata_helpers.go b/backend/plugin/schema/oracle/metadata_helpers.gonew file mode 100644index 0000000000..1e2dfdc3f5--- /dev/null+++ b/backend/plugin/schema/oracle/metadata_helpers.go@@ -0,0 +1,133 @@+package oracle++import (+ "fmt"+ "strconv"+ "strings"+)++func normalizeDataTypeText(text string) string {+ if text == "" {+ return ""+ }++ normalized := strings.ToUpper(text)++ switch {+ case strings.HasPrefix(normalized, "VARCHAR2"):+ if strings.HasPrefix(normalized, "VARCHAR2(") && strings.HasSuffix(normalized, ")") {+ start := strings.Index(normalized, "(") + 1+ end := strings.LastIndex(normalized, ")")+ if start < end {+ sizeStr := normalized[start:end]+ if size := parseInt(sizeStr); size > 0 {+ return fmt.Sprintf("VARCHAR2(%d BYTE)", size)+ }+ }+ }+ return normalized+ case strings.HasPrefix(normalized, "CHAR("):+ if strings.HasSuffix(normalized, ")") {+ start := strings.Index(normalized, "(") + 1+ end := strings.LastIndex(normalized, ")")+ if start < end {+ sizeStr := normalized[start:end]+ if size := parseInt(sizeStr); size > 0 {+ return fmt.Sprintf("CHAR(%d BYTE)", size)+ }+ }+ }+ return normalized+ case strings.HasPrefix(normalized, "TIMESTAMP"):+ if strings.Contains(normalized, "WITH LOCAL TIME ZONE") || strings.Contains(normalized, "WITHLOCALTIMEZONE") {+ if normalized == "TIMESTAMP WITH LOCAL TIME ZONE" {+ return "TIMESTAMP(6) WITH LOCAL TIME ZONE"+ }+ if strings.Contains(normalized, "(") && strings.Contains(normalized, ")") {+ return strings.ReplaceAll(normalized, "WITHLOCALTIMEZONE", " WITH LOCAL TIME ZONE")+ }+ return "TIMESTAMP(6) WITH LOCAL TIME ZONE"+ }+ if strings.Contains(normalized, "WITH TIME ZONE") || strings.Contains(normalized, "WITHTIMEZONE") {+ if normalized == "TIMESTAMP WITH TIME ZONE" {+ return "TIMESTAMP(6) WITH TIME ZONE"+ }+ if strings.Contains(normalized, "(") && strings.Contains(normalized, ")") {+ return strings.ReplaceAll(normalized, "WITHTIMEZONE", " WITH TIME ZONE")+ }+ return "TIMESTAMP(6) WITH TIME ZONE"+ }+ if normalized == "TIMESTAMP" {+ return "TIMESTAMP(6)"+ }+ return normalized+ case strings.HasPrefix(normalized, "INTERVAL"):+ if strings.Contains(normalized, "YEAR TO MONTH") || strings.Contains(normalized, "YEARTOMONTH") {+ if normalized == "INTERVAL YEAR TO MONTH" {+ return "INTERVAL YEAR(2) TO MONTH"+ }+ if strings.Contains(normalized, "(") && strings.Contains(normalized, ")") {+ result := strings.ReplaceAll(normalized, "YEARTOMONTH", " YEAR TO MONTH")+ return strings.ReplaceAll(result, "INTERVALYEAR", "INTERVAL YEAR")+ }+ return "INTERVAL YEAR(2) TO MONTH"+ }+ if strings.Contains(normalized, "DAY TO SECOND") || strings.Contains(normalized, "DAYTOSECOND") {+ if normalized == "INTERVAL DAY TO SECOND" {+ return "INTERVAL DAY(2) TO SECOND(6)"+ }+ if strings.Contains(normalized, "(") && strings.Contains(normalized, ")") {+ result := strings.ReplaceAll(normalized, "DAYTOSECOND", " DAY TO SECOND")+ return strings.ReplaceAll(result, "INTERVALDAY", "INTERVAL DAY")+ }+ return "INTERVAL DAY(2) TO SECOND(6)"+ }+ return normalized+ case strings.HasPrefix(normalized, "LONGRAW"):+ return "LONG RAW"+ case strings.HasPrefix(normalized, "DOUBLE"):+ return "DOUBLE PRECISION"+ case normalized == "UROWID":+ return "UROWID(4000)"+ case normalized == "FLOAT":+ return "FLOAT(126)"+ case strings.HasPrefix(normalized, "NVARCHAR2"):+ if strings.HasPrefix(normalized, "NVARCHAR2(") && strings.HasSuffix(normalized, ")") {+ start := strings.Index(normalized, "(") + 1+ end := strings.LastIndex(normalized, ")")+ if start < end {+ sizeStr := normalized[start:end]+ if size := parseInt(sizeStr); size > 0 {+ if size == 2000 {+ return "NVARCHAR2(4000)"+ }+ if size <= 2000 {+ return fmt.Sprintf("NVARCHAR2(%d)", size*2)+ }+ }+ }+ }+ return normalized+ case strings.HasPrefix(normalized, "NCHAR"):+ if strings.HasPrefix(normalized, "NCHAR(") && strings.HasSuffix(normalized, ")") {+ start := strings.Index(normalized, "(") + 1+ end := strings.LastIndex(normalized, ")")+ if start < end {+ sizeStr := normalized[start:end]+ if size := parseInt(sizeStr); size > 0 {+ return fmt.Sprintf("NCHAR(%d)", size*2)+ }+ }+ }+ return normalized+ default:+ return normalized+ }+}++func parseInt(s string) int {+ if i, err := strconv.Atoi(s); err == nil {+ return i+ }+ return 0+}