Skip to content

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

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.go
index 3edf1a3298..d6f5b24186 100644
--- a/backend/plugin/advisor/oracle/generic_checker.go
+++ b/backend/plugin/advisor/oracle/generic_checker.go
@@ -2,27 +2,12 @@
package oracle
import (
- "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.go
index 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 oracle
import (
- "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.go
index 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 oracle
import (
"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.ParsedSt
if 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.go
index 2b282a1997..61fa255e39 100644
--- a/backend/plugin/advisor/oracle/parser.go
+++ b/backend/plugin/advisor/oracle/parser.go
@@ -4,68 +4,8 @@ package oracle
import (
"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.go
index 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.Context
checkCtx advisor.Context
- updateStatements []plsql.IUpdate_statementContext
- deleteStatements []plsql.IDelete_statementContext
statementInfoList []statementInfo
hasDDL bool
}
@@ -117,34 +112,6 @@ func (r *StatementPriorBackupCheckRule) GetAdviceList() ([]*storepb.Advice, erro
return 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.Advice
diff --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.go
index 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 {
BaseRule
currentDatabase 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.go
index 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 string
payload *storepb.SQLReviewRule_CommentConventionRulePayload
- tableName string
columnNames []string
columnComment map[string]string
columnLine 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.go
index 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 oracle
import (
"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.go
index 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 oracle
import (
"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.go
index 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 string
nullableColumns 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.go
index 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 string
requiredColumns 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 types
diff --git a/backend/plugin/advisor/oracle/rule_column_require_default.go b/backend/plugin/advisor/oracle/rule_column_require_default.go
index 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 string
noDefaultColumns 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.go
index 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.go
index 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.go
index 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 oracle
import (
"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.go
index 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.go
index 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.go
index 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.go
index 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.go
index 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 oracle
import (
"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.go
index 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.go
index 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.go
index 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]tableRef
type indexedByAlias = map[string]map[string]bool
type 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 string
dbMetadata *model.DatabaseMetadata
isObjectCaseSensitive 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 true
default:
+ 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.go
index 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.go
index 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 {
BaseRule
currentDatabase string
- tableName string
tableWithFK map[string]bool
tableLine 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.go
index 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 {
BaseRule
currentDatabase string
- tableName string
tableWitPK map[string]bool
tableLine 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.go
index 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.go
index 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.go
index 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 oracle
import (
"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.yaml
index 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: 0
endposition: 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: 1
want:
- status: 2
@@ -92,14 +92,14 @@
column: 0
endposition: 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: 1
want:
- status: 2
code: 257
title: 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: 1
column: 0
@@ -131,14 +131,14 @@
column: 0
endposition: 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: 1
want:
- status: 2
code: 257
title: 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: 1
column: 0
diff --git a/backend/plugin/advisor/oracle/test/statement_insert_must_specify_column.yaml b/backend/plugin/advisor/oracle/test/statement_insert_must_specify_column.yaml
index 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: 1
column: 0
endposition: 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: null
diff --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.yaml
index 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: 0
endposition: 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: 2
code: 234
@@ -955,8 +954,8 @@
column: 0
endposition: 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: 2
code: 234
@@ -967,10 +966,10 @@
column: 0
endposition: 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 references
diff --git a/backend/plugin/advisor/oracle/test/statement_where_require_select.yaml b/backend/plugin/advisor/oracle/test/statement_where_require_select.yaml
index 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 > 0
changeType: 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: 1
want:
- status: 2
diff --git a/backend/plugin/advisor/oracle/test/statement_where_require_update_delete.yaml b/backend/plugin/advisor/oracle/test/statement_where_require_update_delete.yaml
index 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 > 10
changeType: 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: null
diff --git a/backend/plugin/advisor/oracle/utils_omni.go b/backend/plugin/advisor/oracle/utils_omni.go
index 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.go
index 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_RULE
FROM SYS.ALL_CONSTRAINTS
WHERE 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 portability
rConstraintKey := 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.go
new file mode 100644
index 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.go
index 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.SyntaxError
if errors.As(convertOmniError(err, base.Statement{Text: statement}), &syntaxErr) {
return syntaxErr
diff --git a/backend/plugin/parser/plsql/omni.go b/backend/plugin/parser/plsql/omni.go
index 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.go
index 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.go
index f193401e30..1b678dd943 100644
--- a/backend/plugin/parser/plsql/plsql.go
+++ b/backend/plugin/parser/plsql/plsql.go
@@ -1,14 +1,11 @@
package plsql
import (
- "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 positions
stmts, 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.go
index 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.SyntaxError
require.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.go
index 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:unused
package plsql
import (
"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, t
return 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.go
index 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.go
deleted file mode 100644
index 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.go
index 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.go
index 87a24d544c..2f8e07f9d3 100644
--- a/backend/plugin/parser/plsql/split.go
+++ b/backend/plugin/parser/plsql/split.go
@@ -3,11 +3,8 @@ package plsql
import (
"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.go
index cf7c9dfd86..0939f64291 100644
--- a/backend/plugin/parser/plsql/statement_type.go
+++ b/backend/plugin/parser/plsql/statement_type.go
@@ -3,9 +3,7 @@ package plsql
import (
"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.StatementType
for sqlType := range sqlTypeSet {
@@ -127,44 +120,3 @@ func classifyOmniDropStatementType(objectType oracleast.ObjectType) storepb.Stat
return 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.go
index 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.go
deleted file mode 100644
index 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.go
index 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 oracle
import (
- "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.go
index 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.TableMetadat
Columns: 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.go
index 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_manager
verify: 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 str
t.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.go
new file mode 100644
index 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
+}