Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
refactor(plugin): drop the vestigial _omni suffix (#21414)
Danny Xu2b34bdfa9127
diff --git a/backend/api/v1/release_service_check.go b/backend/api/v1/release_service_check.goindex 37c5fdd207..c887af1196 100644--- a/backend/api/v1/release_service_check.go+++ b/backend/api/v1/release_service_check.go@@ -901,7 +901,7 @@ func (s *ReleaseService) runSQLReviewCheckForFile(// COMMENT statements to declare the desired schema. ALTER SEQUENCE is allowed for// setting ownership (OWNED BY). CREATE TRIGGER is deliberately shared: both SDL// pipelines fully manage triggers — the PostgreSQL dump emits CREATE TRIGGER and the pg-// omni differ handles OpDropTrigger with a drop advice (pg/sdl_migration_omni.go), the+// omni differ handles OpDropTrigger with a drop advice (pg/sdl_migration.go), the// same as MySQL — so a declared trigger is legal SDL on both engines.// STATEMENT_TYPE_UNSPECIFIED is (and must stay) absent from every allowlist so that a// parsed-but-unclassified statement fails CLOSED as disallowed.diff --git a/backend/plugin/advisor/mssql/generic_checker_omni.go b/backend/plugin/advisor/mssql/generic_checker.gosimilarity index 95%rename from backend/plugin/advisor/mssql/generic_checker_omni.gorename to backend/plugin/advisor/mssql/generic_checker.goindex 2e9f8f048f..8578b46905 100644--- a/backend/plugin/advisor/mssql/generic_checker_omni.go+++ b/backend/plugin/advisor/mssql/generic_checker.go@@ -119,9 +119,9 @@ func (r *OmniBaseRule) FindLineByName(name string) int32 {return pos.Line}-// RunOmniRules iterates over parsed statements and dispatches each omni AST node to all rules.+// RunRules iterates over parsed statements and dispatches each omni AST node to all rules.// Returns combined advice from all rules. Skips statements without omni AST.-func RunOmniRules(stmts []base.ParsedStatement, rules []OmniRule) []*storepb.Advice {+func RunRules(stmts []base.ParsedStatement, rules []OmniRule) []*storepb.Advice {for _, stmt := range stmts {if stmt.AST == nil {continuediff --git a/backend/plugin/advisor/mssql/rule_builtin_prior_backup_check.go b/backend/plugin/advisor/mssql/rule_builtin_prior_backup_check.goindex 4a63ec949d..94c7719dc3 100644--- a/backend/plugin/advisor/mssql/rule_builtin_prior_backup_check.go+++ b/backend/plugin/advisor/mssql/rule_builtin_prior_backup_check.go@@ -69,7 +69,7 @@ func (*StatementPriorBackupCheckAdvisor) Check(ctx context.Context, checkCtx advddlRule := &statementDisallowMixDMLOmniRule{OmniBaseRule: OmniBaseRule{Level: level, Title: title},}- RunOmniRules(checkCtx.ParsedStatements, []OmniRule{ddlRule})+ RunRules(checkCtx.ParsedStatements, []OmniRule{ddlRule})if ddlRule.hasDDL {adviceList = append(adviceList, &storepb.Advice{diff --git a/backend/plugin/advisor/mssql/rule_builtin_prior_backup_check_test.go b/backend/plugin/advisor/mssql/rule_builtin_prior_backup_check_test.goindex 0ebf15bcbe..283992cb9f 100644--- a/backend/plugin/advisor/mssql/rule_builtin_prior_backup_check_test.go+++ b/backend/plugin/advisor/mssql/rule_builtin_prior_backup_check_test.go@@ -13,7 +13,7 @@ import (func TestPrepareTransformationUsesOmniAST(t *testing.T) {sql := `UPDATE p SET c1 = 1 FROM dbo.pokes AS p WHERE p.c1 = 1;DELETE p FROM dbo.pokes AS p WHERE p.c1 = 1;`- omniStmts, err := tsqlparser.ParseTSQLOmni(sql)+ omniStmts, err := tsqlparser.ParseTSQL(sql)require.NoError(t, err)var parsedStatements []base.ParsedStatementdiff --git a/backend/plugin/advisor/mssql/rule_column_maximum_varchar_length.go b/backend/plugin/advisor/mssql/rule_column_maximum_varchar_length.goindex 894c8bf623..4118e94624 100644--- a/backend/plugin/advisor/mssql/rule_column_maximum_varchar_length.go+++ b/backend/plugin/advisor/mssql/rule_column_maximum_varchar_length.go@@ -51,7 +51,7 @@ func (*ColumnMaximumVarcharLengthAdvisor) Check(_ context.Context, checkCtx advi"nchar": true,},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type columnMaximumVarcharLengthRule struct {diff --git a/backend/plugin/advisor/mssql/rule_column_no_null.go b/backend/plugin/advisor/mssql/rule_column_no_null.goindex f230b50305..00f6f2466b 100644--- a/backend/plugin/advisor/mssql/rule_column_no_null.go+++ b/backend/plugin/advisor/mssql/rule_column_no_null.go@@ -34,7 +34,7 @@ func (*ColumnNoNullAdvisor) Check(_ context.Context, checkCtx advisor.Context) (rule := &columnNoNullOmniRule{OmniBaseRule: OmniBaseRule{Level: level, Title: checkCtx.Rule.Type.String()},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type columnNoNullOmniRule struct {diff --git a/backend/plugin/advisor/mssql/rule_column_require.go b/backend/plugin/advisor/mssql/rule_column_require.goindex 1c8a3a3015..5eac9598b9 100644--- a/backend/plugin/advisor/mssql/rule_column_require.go+++ b/backend/plugin/advisor/mssql/rule_column_require.go@@ -47,7 +47,7 @@ func (*ColumnRequireAdvisor) Check(_ context.Context, checkCtx advisor.Context)rule.requireColumns[col] = true}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type columnRequireOmniRule struct {diff --git a/backend/plugin/advisor/mssql/rule_column_type_disallow_list.go b/backend/plugin/advisor/mssql/rule_column_type_disallow_list.goindex 22ff7c2316..9b71d2780c 100644--- a/backend/plugin/advisor/mssql/rule_column_type_disallow_list.go+++ b/backend/plugin/advisor/mssql/rule_column_type_disallow_list.go@@ -44,7 +44,7 @@ func (*ColumnTypeDisallowListAdvisor) Check(_ context.Context, checkCtx advisor.OmniBaseRule: OmniBaseRule{Level: level, Title: checkCtx.Rule.Type.String()},disallowTypes: disallowTypes,}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type columnTypeDisallowListRule struct {diff --git a/backend/plugin/advisor/mssql/rule_function_disallow_create_or_alter.go b/backend/plugin/advisor/mssql/rule_function_disallow_create_or_alter.goindex db0f567512..eb1bf63560 100644--- a/backend/plugin/advisor/mssql/rule_function_disallow_create_or_alter.go+++ b/backend/plugin/advisor/mssql/rule_function_disallow_create_or_alter.go@@ -22,7 +22,7 @@ func (*FunctionDisallowCreateOrAlterAdvisor) Check(_ context.Context, checkCtx areturn nil, err}rule := &functionDisallowCreateOrAlterRule{OmniBaseRule: OmniBaseRule{Level: level, Title: checkCtx.Rule.Type.String()}}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type functionDisallowCreateOrAlterRule struct {diff --git a/backend/plugin/advisor/mssql/rule_index_not_redundant.go b/backend/plugin/advisor/mssql/rule_index_not_redundant.goindex 7aa5c83d93..c0459b3276 100644--- a/backend/plugin/advisor/mssql/rule_index_not_redundant.go+++ b/backend/plugin/advisor/mssql/rule_index_not_redundant.go@@ -36,7 +36,7 @@ func (IndexNotRedundantAdvisor) Check(_ context.Context, checkCtx advisor.ContexcurDB: checkCtx.CurrentDatabase,indexMap: getIndexMapFromMetadata(checkCtx.DBSchema),}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type indexNotRedundantRule struct {diff --git a/backend/plugin/advisor/mssql/rule_migration_compatibility.go b/backend/plugin/advisor/mssql/rule_migration_compatibility.goindex 80457080f8..0d32a33277 100644--- a/backend/plugin/advisor/mssql/rule_migration_compatibility.go+++ b/backend/plugin/advisor/mssql/rule_migration_compatibility.go@@ -38,7 +38,7 @@ func (*MigrationCompatibilityAdvisor) Check(_ context.Context, checkCtx advisor.newSchemas: make(map[string]any),newDatabases: make(map[string]any),}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type migrationCompatibilityOmniRule struct {diff --git a/backend/plugin/advisor/mssql/rule_naming_identifier_no_keyword.go b/backend/plugin/advisor/mssql/rule_naming_identifier_no_keyword.goindex 641ed3dede..db6f0028ba 100644--- a/backend/plugin/advisor/mssql/rule_naming_identifier_no_keyword.go+++ b/backend/plugin/advisor/mssql/rule_naming_identifier_no_keyword.go@@ -35,7 +35,7 @@ func (*NamingIdentifierNoKeywordAdvisor) Check(_ context.Context, checkCtx advisrule := &namingIdentifierNoKeywordRule{OmniBaseRule: OmniBaseRule{Level: level, Title: checkCtx.Rule.Type.String()},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type namingIdentifierNoKeywordRule struct {diff --git a/backend/plugin/advisor/mssql/rule_naming_table.go b/backend/plugin/advisor/mssql/rule_naming_table.goindex ab790e6da7..e2df481958 100644--- a/backend/plugin/advisor/mssql/rule_naming_table.go+++ b/backend/plugin/advisor/mssql/rule_naming_table.go@@ -52,7 +52,7 @@ func (*NamingTableAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([format: format,maxLength: maxLength,}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type namingTableRule struct {diff --git a/backend/plugin/advisor/mssql/rule_naming_table_no_keyword.go b/backend/plugin/advisor/mssql/rule_naming_table_no_keyword.goindex 21b755527f..19bb447f9e 100644--- a/backend/plugin/advisor/mssql/rule_naming_table_no_keyword.go+++ b/backend/plugin/advisor/mssql/rule_naming_table_no_keyword.go@@ -34,7 +34,7 @@ func (*NamingTableNoKeywordAdvisor) Check(_ context.Context, checkCtx advisor.Corule := &namingTableNoKeywordRule{OmniBaseRule: OmniBaseRule{Level: level, Title: checkCtx.Rule.Type.String()},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type namingTableNoKeywordRule struct {diff --git a/backend/plugin/advisor/mssql/rule_procedure_disallow_create_or_alter.go b/backend/plugin/advisor/mssql/rule_procedure_disallow_create_or_alter.goindex 9a810ec680..d55c20400f 100644--- a/backend/plugin/advisor/mssql/rule_procedure_disallow_create_or_alter.go+++ b/backend/plugin/advisor/mssql/rule_procedure_disallow_create_or_alter.go@@ -22,7 +22,7 @@ func (*ProcedureDisallowCreateOrAlterAdvisor) Check(_ context.Context, checkCtxreturn nil, err}rule := &procedureDisallowCreateOrAlterRule{OmniBaseRule: OmniBaseRule{Level: level, Title: checkCtx.Rule.Type.String()}}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type procedureDisallowCreateOrAlterRule struct {diff --git a/backend/plugin/advisor/mssql/rule_select_no_select_all.go b/backend/plugin/advisor/mssql/rule_select_no_select_all.goindex b534fab8b4..3d0f4af945 100644--- a/backend/plugin/advisor/mssql/rule_select_no_select_all.go+++ b/backend/plugin/advisor/mssql/rule_select_no_select_all.go@@ -22,7 +22,7 @@ func (*SelectNoSelectAllAdvisor) Check(_ context.Context, checkCtx advisor.Contereturn nil, err}rule := &selectNoSelectAllRule{OmniBaseRule: OmniBaseRule{Level: level, Title: checkCtx.Rule.Type.String()}}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type selectNoSelectAllRule struct {diff --git a/backend/plugin/advisor/mssql/rule_statement_disallow_cross_db_queries.go b/backend/plugin/advisor/mssql/rule_statement_disallow_cross_db_queries.goindex ba0795a2c6..67793c38b1 100644--- a/backend/plugin/advisor/mssql/rule_statement_disallow_cross_db_queries.go+++ b/backend/plugin/advisor/mssql/rule_statement_disallow_cross_db_queries.go@@ -28,7 +28,7 @@ func (*DisallowCrossDBQueriesAdvisor) Check(_ context.Context, checkCtx advisor.OmniBaseRule: OmniBaseRule{Level: level, Title: checkCtx.Rule.Type.String()},curDB: checkCtx.CurrentDatabase,}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type disallowCrossDBQueriesRule struct {diff --git a/backend/plugin/advisor/mssql/rule_statement_disallow_truncate.go b/backend/plugin/advisor/mssql/rule_statement_disallow_truncate.goindex 685647bf83..5f56dd1590 100644--- a/backend/plugin/advisor/mssql/rule_statement_disallow_truncate.go+++ b/backend/plugin/advisor/mssql/rule_statement_disallow_truncate.go@@ -28,7 +28,7 @@ func (*StatementDisallowTruncateAdvisor) Check(_ context.Context, checkCtx advisrule := &statementDisallowTruncateRule{OmniBaseRule: OmniBaseRule{Level: level, Title: checkCtx.Rule.Type.String()},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type statementDisallowTruncateRule struct{ OmniBaseRule }diff --git a/backend/plugin/advisor/mssql/rule_statement_where_disallow_functions_and_calculations.go b/backend/plugin/advisor/mssql/rule_statement_where_disallow_functions_and_calculations.goindex b319be7fd7..3e5ddcd788 100644--- a/backend/plugin/advisor/mssql/rule_statement_where_disallow_functions_and_calculations.go+++ b/backend/plugin/advisor/mssql/rule_statement_where_disallow_functions_and_calculations.go@@ -35,7 +35,7 @@ func (*DisallowFuncAndCalculationsAdvisor) Check(_ context.Context, checkCtx advrule.dbMetadata = model.NewDatabaseMetadata(checkCtx.DBSchema, nil, nil, storepb.Engine_MSSQL, checkCtx.IsObjectCaseSensitive)}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type disallowFuncAndCalcOmniRule struct {diff --git a/backend/plugin/advisor/mssql/rule_statement_where_requirement_for_select.go b/backend/plugin/advisor/mssql/rule_statement_where_requirement_for_select.goindex 005aa89cd2..3c9be14129 100644--- a/backend/plugin/advisor/mssql/rule_statement_where_requirement_for_select.go+++ b/backend/plugin/advisor/mssql/rule_statement_where_requirement_for_select.go@@ -22,7 +22,7 @@ func (*WhereRequirementForSelectAdvisor) Check(_ context.Context, checkCtx advisreturn nil, err}rule := &whereRequirementForSelectRule{OmniBaseRule: OmniBaseRule{Level: level, Title: checkCtx.Rule.Type.String()}}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type whereRequirementForSelectRule struct {diff --git a/backend/plugin/advisor/mssql/rule_statement_where_requirement_for_update_delete.go b/backend/plugin/advisor/mssql/rule_statement_where_requirement_for_update_delete.goindex a228a8db1c..00c14c0b3a 100644--- a/backend/plugin/advisor/mssql/rule_statement_where_requirement_for_update_delete.go+++ b/backend/plugin/advisor/mssql/rule_statement_where_requirement_for_update_delete.go@@ -22,7 +22,7 @@ func (*WhereRequirementForUpdateDeleteAdvisor) Check(_ context.Context, checkCtxreturn nil, err}rule := &whereRequirementForUpdateDeleteRule{OmniBaseRule: OmniBaseRule{Level: level, Title: checkCtx.Rule.Type.String()}}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type whereRequirementForUpdateDeleteRule struct {diff --git a/backend/plugin/advisor/mssql/rule_table_disallow_ddl.go b/backend/plugin/advisor/mssql/rule_table_disallow_ddl.goindex 10bb740cea..8c9e58f3ac 100644--- a/backend/plugin/advisor/mssql/rule_table_disallow_ddl.go+++ b/backend/plugin/advisor/mssql/rule_table_disallow_ddl.go@@ -32,7 +32,7 @@ func (*TableDisallowDDLAdvisor) Check(_ context.Context, checkCtx advisor.ContexOmniBaseRule: OmniBaseRule{Level: level, Title: checkCtx.Rule.Type.String()},disallowList: stringArrayPayload.List,}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type tableDisallowDDLRule struct {diff --git a/backend/plugin/advisor/mssql/rule_table_disallow_dml.go b/backend/plugin/advisor/mssql/rule_table_disallow_dml.goindex 68ea1d4fd9..d266f224df 100644--- a/backend/plugin/advisor/mssql/rule_table_disallow_dml.go+++ b/backend/plugin/advisor/mssql/rule_table_disallow_dml.go@@ -38,7 +38,7 @@ func (*TableDisallowDMLAdvisor) Check(_ context.Context, checkCtx advisor.ContexOmniBaseRule: OmniBaseRule{Level: level, Title: checkCtx.Rule.Type.String()},disallowList: stringArrayPayload.List,}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type tableDisallowDMLRule struct {diff --git a/backend/plugin/advisor/mssql/rule_table_drop_naming_convention.go b/backend/plugin/advisor/mssql/rule_table_drop_naming_convention.goindex 5c06547876..7d8c9fc074 100644--- a/backend/plugin/advisor/mssql/rule_table_drop_naming_convention.go+++ b/backend/plugin/advisor/mssql/rule_table_drop_naming_convention.go@@ -40,7 +40,7 @@ func (*TableDropNamingConventionAdvisor) Check(_ context.Context, checkCtx advisOmniBaseRule: OmniBaseRule{Level: level, Title: checkCtx.Rule.Type.String()},format: format,}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type tableDropNamingConventionRule struct {diff --git a/backend/plugin/advisor/mssql/rule_table_no_foreign_key.go b/backend/plugin/advisor/mssql/rule_table_no_foreign_key.goindex 800b8b8f51..6e77aced6e 100644--- a/backend/plugin/advisor/mssql/rule_table_no_foreign_key.go+++ b/backend/plugin/advisor/mssql/rule_table_no_foreign_key.go@@ -38,7 +38,7 @@ func (*TableNoForeignKeyAdvisor) Check(_ context.Context, checkCtx advisor.ContetableBaseLine: make(map[string]int),}- advice := RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule})+ advice := RunRules(checkCtx.ParsedStatements, []OmniRule{rule})advice = append(advice, rule.generateFinalAdvice()...)return advice, nil}diff --git a/backend/plugin/advisor/mssql/rule_table_require_pk.go b/backend/plugin/advisor/mssql/rule_table_require_pk.goindex 48fe267fb3..2cb34b00fb 100644--- a/backend/plugin/advisor/mssql/rule_table_require_pk.go+++ b/backend/plugin/advisor/mssql/rule_table_require_pk.go@@ -38,7 +38,7 @@ func (*TableRequirePkAdvisor) Check(_ context.Context, checkCtx advisor.Context)tableBaseLine: make(map[string]int),}- advice := RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule})+ advice := RunRules(checkCtx.ParsedStatements, []OmniRule{rule})advice = append(advice, rule.generateFinalAdvice()...)return advice, nil}diff --git a/backend/plugin/advisor/mssql/utils_omni.go b/backend/plugin/advisor/mssql/utils.gosimilarity index 100%rename from backend/plugin/advisor/mssql/utils_omni.gorename to backend/plugin/advisor/mssql/utils.godiff --git a/backend/plugin/advisor/mysql/generic_checker_omni.go b/backend/plugin/advisor/mysql/generic_checker.gosimilarity index 96%rename from backend/plugin/advisor/mysql/generic_checker_omni.gorename to backend/plugin/advisor/mysql/generic_checker.goindex 310064eefc..97c8b3d440 100644--- a/backend/plugin/advisor/mysql/generic_checker_omni.go+++ b/backend/plugin/advisor/mysql/generic_checker.go@@ -126,9 +126,9 @@ func (r *OmniBaseRule) FindLineByName(name string) int32 {return pos.Line}-// RunOmniRules iterates over parsed statements and dispatches each omni AST node to all rules.+// RunRules iterates over parsed statements and dispatches each omni AST node to all rules.// Returns combined advice from all rules. Skips statements without omni AST.-func RunOmniRules(stmts []base.ParsedStatement, rules []OmniRule) []*storepb.Advice {+func RunRules(stmts []base.ParsedStatement, rules []OmniRule) []*storepb.Advice {for _, stmt := range stmts {if stmt.AST == nil {continuediff --git a/backend/plugin/advisor/mysql/rule_charset_allowlist.go b/backend/plugin/advisor/mysql/rule_charset_allowlist.goindex 6886791920..48b3713321 100644--- a/backend/plugin/advisor/mysql/rule_charset_allowlist.go+++ b/backend/plugin/advisor/mysql/rule_charset_allowlist.go@@ -48,7 +48,7 @@ func (*CharsetAllowlistAdvisor) Check(_ context.Context, checkCtx advisor.ContexallowList: allowList,}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type charsetAllowlistOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_collation_allowlist.go b/backend/plugin/advisor/mysql/rule_collation_allowlist.goindex b9d12029ed..998293e83c 100644--- a/backend/plugin/advisor/mysql/rule_collation_allowlist.go+++ b/backend/plugin/advisor/mysql/rule_collation_allowlist.go@@ -48,7 +48,7 @@ func (*CollationAllowlistAdvisor) Check(_ context.Context, checkCtx advisor.ContallowList: allowList,}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type collationAllowlistOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_column_comment_convention.go b/backend/plugin/advisor/mysql/rule_column_comment_convention.goindex d0fa1f4f69..d219633b7b 100644--- a/backend/plugin/advisor/mysql/rule_column_comment_convention.go+++ b/backend/plugin/advisor/mysql/rule_column_comment_convention.go@@ -41,7 +41,7 @@ func (*ColumnCommentConventionAdvisor) Check(_ context.Context, checkCtx advisorpayload: commentPayload,}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type columnCommentConventionOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_column_disallow_changing.go b/backend/plugin/advisor/mysql/rule_column_disallow_changing.goindex 60194a4f07..cced9cc890 100644--- a/backend/plugin/advisor/mysql/rule_column_disallow_changing.go+++ b/backend/plugin/advisor/mysql/rule_column_disallow_changing.go@@ -40,7 +40,7 @@ func (*ColumnDisallowChangingAdvisor) Check(_ context.Context, checkCtx advisor.},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type columnDisallowChangingOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_column_disallow_changing_order.go b/backend/plugin/advisor/mysql/rule_column_disallow_changing_order.goindex a6cbfbd80a..6959aed8b8 100644--- a/backend/plugin/advisor/mysql/rule_column_disallow_changing_order.go+++ b/backend/plugin/advisor/mysql/rule_column_disallow_changing_order.go@@ -40,7 +40,7 @@ func (*ColumnDisallowChangingOrderAdvisor) Check(_ context.Context, checkCtx adv},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type columnDisallowChangingOrderOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_column_disallow_changing_type.go b/backend/plugin/advisor/mysql/rule_column_disallow_changing_type.goindex cb2c05bf57..ed32ac4164 100644--- a/backend/plugin/advisor/mysql/rule_column_disallow_changing_type.go+++ b/backend/plugin/advisor/mysql/rule_column_disallow_changing_type.go@@ -43,7 +43,7 @@ func (*ColumnDisallowChangingTypeAdvisor) Check(_ context.Context, checkCtx advioriginalMetadata: checkCtx.OriginalMetadata,}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type columnDisallowChangingTypeOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_column_disallow_drop.go b/backend/plugin/advisor/mysql/rule_column_disallow_drop.goindex bde74c9ca8..4cf70390ab 100644--- a/backend/plugin/advisor/mysql/rule_column_disallow_drop.go+++ b/backend/plugin/advisor/mysql/rule_column_disallow_drop.go@@ -38,7 +38,7 @@ func (*ColumnDisallowDropAdvisor) Check(_ context.Context, checkCtx advisor.Cont},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type columnDisallowDropOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_column_disallow_drop_in_index.go b/backend/plugin/advisor/mysql/rule_column_disallow_drop_in_index.goindex 35cfca6c0a..1d367bc53d 100644--- a/backend/plugin/advisor/mysql/rule_column_disallow_drop_in_index.go+++ b/backend/plugin/advisor/mysql/rule_column_disallow_drop_in_index.go@@ -43,7 +43,7 @@ func (*ColumnDisallowDropInIndexAdvisor) Check(_ context.Context, checkCtx advisoriginalMetadata: checkCtx.OriginalMetadata,}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type columnDisallowDropInIndexOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_column_disallow_set_charset.go b/backend/plugin/advisor/mysql/rule_column_disallow_set_charset.goindex f9ecb238c6..9d8d6fc0a3 100644--- a/backend/plugin/advisor/mysql/rule_column_disallow_set_charset.go+++ b/backend/plugin/advisor/mysql/rule_column_disallow_set_charset.go@@ -40,7 +40,7 @@ func (*ColumnDisallowSetCharsetAdvisor) Check(_ context.Context, checkCtx adviso},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type columnDisallowSetCharsetOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_column_no_null.go b/backend/plugin/advisor/mysql/rule_column_no_null.goindex ec71ad6f97..408ac9aa80 100644--- a/backend/plugin/advisor/mysql/rule_column_no_null.go+++ b/backend/plugin/advisor/mysql/rule_column_no_null.go@@ -45,7 +45,7 @@ func (*ColumnNoNullAdvisor) Check(_ context.Context, checkCtx advisor.Context) (}// Walk all statements to collect columns.- RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule})+ RunRules(checkCtx.ParsedStatements, []OmniRule{rule})// Generate advice after walking all statements.rule.generateAdvice()diff --git a/backend/plugin/advisor/mysql/rule_column_require_charset.go b/backend/plugin/advisor/mysql/rule_column_require_charset.goindex 54b6dbb4a0..5c86ce5f23 100644--- a/backend/plugin/advisor/mysql/rule_column_require_charset.go+++ b/backend/plugin/advisor/mysql/rule_column_require_charset.go@@ -38,7 +38,7 @@ func (*ColumnRequireCharsetAdvisor) Check(_ context.Context, checkCtx advisor.Co},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type columnRequireCharsetOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_column_require_collation.go b/backend/plugin/advisor/mysql/rule_column_require_collation.goindex cf4b7d5fdc..534bddf97a 100644--- a/backend/plugin/advisor/mysql/rule_column_require_collation.go+++ b/backend/plugin/advisor/mysql/rule_column_require_collation.go@@ -37,7 +37,7 @@ func (*ColumnRequireCollationAdvisor) Check(_ context.Context, checkCtx advisor.},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type columnRequireCollationOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_column_require_default.go b/backend/plugin/advisor/mysql/rule_column_require_default.goindex 570bb8442e..b3dcfbf2f2 100644--- a/backend/plugin/advisor/mysql/rule_column_require_default.go+++ b/backend/plugin/advisor/mysql/rule_column_require_default.go@@ -39,7 +39,7 @@ func (*ColumnRequireDefaultAdvisor) Check(_ context.Context, checkCtx advisor.Co},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type columnRequireDefaultOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_column_required.go b/backend/plugin/advisor/mysql/rule_column_required.goindex 214d20cd88..bb27172bb5 100644--- a/backend/plugin/advisor/mysql/rule_column_required.go+++ b/backend/plugin/advisor/mysql/rule_column_required.go@@ -54,7 +54,7 @@ func (*ColumnRequirementAdvisor) Check(_ context.Context, checkCtx advisor.Conteline: make(map[string]int),}- adviceList := RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule})+ adviceList := RunRules(checkCtx.ParsedStatements, []OmniRule{rule})adviceList = append(adviceList, rule.generateAdviceList()...)return adviceList, nil}diff --git a/backend/plugin/advisor/mysql/rule_column_set_default_for_not_null.go b/backend/plugin/advisor/mysql/rule_column_set_default_for_not_null.goindex 9a50a4edaf..8cae5a8726 100644--- a/backend/plugin/advisor/mysql/rule_column_set_default_for_not_null.go+++ b/backend/plugin/advisor/mysql/rule_column_set_default_for_not_null.go@@ -39,7 +39,7 @@ func (*ColumnSetDefaultForNotNullAdvisor) Check(_ context.Context, checkCtx advi},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type columnSetDefaultForNotNullOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_database_drop_empty_db.go b/backend/plugin/advisor/mysql/rule_database_drop_empty_db.goindex 488fda4457..ffe91e7266 100644--- a/backend/plugin/advisor/mysql/rule_database_drop_empty_db.go+++ b/backend/plugin/advisor/mysql/rule_database_drop_empty_db.go@@ -42,7 +42,7 @@ func (*DatabaseAllowDropIfEmptyAdvisor) Check(_ context.Context, checkCtx advisooriginMetadata: checkCtx.OriginalMetadata,}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type databaseDropEmptyDBOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_disallow_procedure.go b/backend/plugin/advisor/mysql/rule_disallow_procedure.goindex 193ecae213..2e67e5df3b 100644--- a/backend/plugin/advisor/mysql/rule_disallow_procedure.go+++ b/backend/plugin/advisor/mysql/rule_disallow_procedure.go@@ -38,7 +38,7 @@ func (*ProcedureDisallowCreateAdvisor) Check(_ context.Context, checkCtx advisor},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type procedureDisallowCreateOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_event_disallow_create.go b/backend/plugin/advisor/mysql/rule_event_disallow_create.goindex 1afff28c2d..bd18a10dbc 100644--- a/backend/plugin/advisor/mysql/rule_event_disallow_create.go+++ b/backend/plugin/advisor/mysql/rule_event_disallow_create.go@@ -38,7 +38,7 @@ func (*EventDisallowCreateAdvisor) Check(_ context.Context, checkCtx advisor.Con},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type eventDisallowCreateOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_function_disallow_create.go b/backend/plugin/advisor/mysql/rule_function_disallow_create.goindex 2b150c5c06..6a52a4a383 100644--- a/backend/plugin/advisor/mysql/rule_function_disallow_create.go+++ b/backend/plugin/advisor/mysql/rule_function_disallow_create.go@@ -38,7 +38,7 @@ func (*FunctionDisallowCreateAdvisor) Check(_ context.Context, checkCtx advisor.},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type functionDisallowCreateOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_function_disallowed_list.go b/backend/plugin/advisor/mysql/rule_function_disallowed_list.goindex eb7da6c7e4..51407a355f 100644--- a/backend/plugin/advisor/mysql/rule_function_disallowed_list.go+++ b/backend/plugin/advisor/mysql/rule_function_disallowed_list.go@@ -46,7 +46,7 @@ func (*FunctionDisallowedListAdvisor) Check(_ context.Context, checkCtx advisor.disallowList: disallowList,}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type functionDisallowedListOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_index_key_number_limit.go b/backend/plugin/advisor/mysql/rule_index_key_number_limit.goindex 9090f8cf00..5d3c244ce3 100644--- a/backend/plugin/advisor/mysql/rule_index_key_number_limit.go+++ b/backend/plugin/advisor/mysql/rule_index_key_number_limit.go@@ -46,7 +46,7 @@ func (*IndexKeyNumberLimitAdvisor) Check(_ context.Context, checkCtx advisor.Conmax: int(numberPayload.Number),}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type indexKeyNumberLimitOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_index_no_duplicate_column.go b/backend/plugin/advisor/mysql/rule_index_no_duplicate_column.goindex b51129096a..c50c3c4036 100644--- a/backend/plugin/advisor/mysql/rule_index_no_duplicate_column.go+++ b/backend/plugin/advisor/mysql/rule_index_no_duplicate_column.go@@ -41,7 +41,7 @@ func (*IndexNoDuplicateColumnAdvisor) Check(_ context.Context, checkCtx advisor.},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type indexNoDuplicateColumnOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_index_pk_type.go b/backend/plugin/advisor/mysql/rule_index_pk_type.goindex 098dbe1126..016352a007 100644--- a/backend/plugin/advisor/mysql/rule_index_pk_type.go+++ b/backend/plugin/advisor/mysql/rule_index_pk_type.go@@ -45,7 +45,7 @@ func (*IndexPkTypeAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([tablesNewColumns: make(tableColumnTypes),}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type indexPkTypeOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_index_primary_key_type_allowlist.go b/backend/plugin/advisor/mysql/rule_index_primary_key_type_allowlist.goindex 1455d38ddb..2a788c606d 100644--- a/backend/plugin/advisor/mysql/rule_index_primary_key_type_allowlist.go+++ b/backend/plugin/advisor/mysql/rule_index_primary_key_type_allowlist.go@@ -50,7 +50,7 @@ func (*IndexPrimaryKeyTypeAllowlistAdvisor) Check(_ context.Context, checkCtx adtablesNewColumns: make(tableColumnTypes),}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type indexPrimaryKeyTypeAllowlistOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_index_total_number_limit.go b/backend/plugin/advisor/mysql/rule_index_total_number_limit.goindex 4d8592d584..f42bd5f8dd 100644--- a/backend/plugin/advisor/mysql/rule_index_total_number_limit.go+++ b/backend/plugin/advisor/mysql/rule_index_total_number_limit.go@@ -50,7 +50,7 @@ func (*IndexTotalNumberLimitAdvisor) Check(_ context.Context, checkCtx advisor.CfinalMetadata: checkCtx.FinalMetadata,}- RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule})+ RunRules(checkCtx.ParsedStatements, []OmniRule{rule})return rule.generateAdvice(), nil}diff --git a/backend/plugin/advisor/mysql/rule_index_type_allow_list.go b/backend/plugin/advisor/mysql/rule_index_type_allow_list.goindex 5bf0b75b17..8214a8ce79 100644--- a/backend/plugin/advisor/mysql/rule_index_type_allow_list.go+++ b/backend/plugin/advisor/mysql/rule_index_type_allow_list.go@@ -41,7 +41,7 @@ func (*IndexTypeAllowListAdvisor) Check(_ context.Context, checkCtx advisor.ContallowList: stringArrayPayload.List,}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type indexTypeAllowListOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_index_type_no_blob.go b/backend/plugin/advisor/mysql/rule_index_type_no_blob.goindex d109f56ecf..7fdc6caae7 100644--- a/backend/plugin/advisor/mysql/rule_index_type_no_blob.go+++ b/backend/plugin/advisor/mysql/rule_index_type_no_blob.go@@ -45,7 +45,7 @@ func (*IndexTypeNoBlobAdvisor) Check(_ context.Context, checkCtx advisor.ContexttablesNewColumns: make(tableColumnTypes),}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type indexTypeNoBlobOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_insert_disallow_order_by_rand.go b/backend/plugin/advisor/mysql/rule_insert_disallow_order_by_rand.goindex e1bbb0327d..a806f96207 100644--- a/backend/plugin/advisor/mysql/rule_insert_disallow_order_by_rand.go+++ b/backend/plugin/advisor/mysql/rule_insert_disallow_order_by_rand.go@@ -43,7 +43,7 @@ func (*InsertDisallowOrderByRandAdvisor) Check(_ context.Context, checkCtx advis},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type insertDisallowOrderByRandOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_insert_must_specify_column.go b/backend/plugin/advisor/mysql/rule_insert_must_specify_column.goindex c0d804698e..a4a1c3c426 100644--- a/backend/plugin/advisor/mysql/rule_insert_must_specify_column.go+++ b/backend/plugin/advisor/mysql/rule_insert_must_specify_column.go@@ -40,7 +40,7 @@ func (*InsertMustSpecifyColumnAdvisor) Check(_ context.Context, checkCtx advisor},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type insertMustSpecifyColumnOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_migration_compatibility.go b/backend/plugin/advisor/mysql/rule_migration_compatibility.goindex 66ebb121b0..fa5aeabfd6 100644--- a/backend/plugin/advisor/mysql/rule_migration_compatibility.go+++ b/backend/plugin/advisor/mysql/rule_migration_compatibility.go@@ -40,7 +40,7 @@ func (*CompatibilityAdvisor) Check(_ context.Context, checkCtx advisor.Context)},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type compatibilityOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_naming_auto_increment_column.go b/backend/plugin/advisor/mysql/rule_naming_auto_increment_column.goindex 60ba813bb3..fa5bc99ef2 100644--- a/backend/plugin/advisor/mysql/rule_naming_auto_increment_column.go+++ b/backend/plugin/advisor/mysql/rule_naming_auto_increment_column.go@@ -58,7 +58,7 @@ func (*NamingAutoIncrementColumnAdvisor) Check(_ context.Context, checkCtx advismaxLength: maxLength,}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type namingAutoIncrementColumnOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_naming_column.go b/backend/plugin/advisor/mysql/rule_naming_column.goindex 3867496911..7d07f04004 100644--- a/backend/plugin/advisor/mysql/rule_naming_column.go+++ b/backend/plugin/advisor/mysql/rule_naming_column.go@@ -57,7 +57,7 @@ func (*NamingColumnConventionAdvisor) Check(_ context.Context, checkCtx advisor.maxLength: maxLength,}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type namingColumnOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_naming_foreign_key_convention.go b/backend/plugin/advisor/mysql/rule_naming_foreign_key_convention.goindex d2000c3b1b..97f2768b5d 100644--- a/backend/plugin/advisor/mysql/rule_naming_foreign_key_convention.go+++ b/backend/plugin/advisor/mysql/rule_naming_foreign_key_convention.go@@ -64,7 +64,7 @@ func (*NamingFKConventionAdvisor) Check(_ context.Context, checkCtx advisor.ConttemplateList: templateList,}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}// fkIndexMetaData is the metadata for foreign key.diff --git a/backend/plugin/advisor/mysql/rule_naming_identifier_no_keyword.go b/backend/plugin/advisor/mysql/rule_naming_identifier_no_keyword.goindex 32dc227478..630d444ed6 100644--- a/backend/plugin/advisor/mysql/rule_naming_identifier_no_keyword.go+++ b/backend/plugin/advisor/mysql/rule_naming_identifier_no_keyword.go@@ -39,7 +39,7 @@ func (*NamingIdentifierNoKeywordAdvisor) Check(_ context.Context, checkCtx advis},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type namingIdentifierNoKeywordOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_naming_index_convention.go b/backend/plugin/advisor/mysql/rule_naming_index_convention.goindex 207e9db11d..fc617af889 100644--- a/backend/plugin/advisor/mysql/rule_naming_index_convention.go+++ b/backend/plugin/advisor/mysql/rule_naming_index_convention.go@@ -74,7 +74,7 @@ func (*NamingIndexConventionAdvisor) Check(_ context.Context, checkCtx advisor.CoriginalMetadata: checkCtx.OriginalMetadata,}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type namingIndexOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_naming_table.go b/backend/plugin/advisor/mysql/rule_naming_table.goindex 33ebc12911..7406f22c21 100644--- a/backend/plugin/advisor/mysql/rule_naming_table.go+++ b/backend/plugin/advisor/mysql/rule_naming_table.go@@ -59,7 +59,7 @@ func (*NamingTableConventionAdvisor) Check(_ context.Context, checkCtx advisor.CmaxLength: maxLength,}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type namingTableOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_naming_unique_key_convention.go b/backend/plugin/advisor/mysql/rule_naming_unique_key_convention.goindex 87d579356d..0f17e367b5 100644--- a/backend/plugin/advisor/mysql/rule_naming_unique_key_convention.go+++ b/backend/plugin/advisor/mysql/rule_naming_unique_key_convention.go@@ -66,7 +66,7 @@ func (*NamingUKConventionAdvisor) Check(_ context.Context, checkCtx advisor.ContoriginalMetadata: checkCtx.OriginalMetadata,}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}// ukIndexMetaData is the metadata for unique key.diff --git a/backend/plugin/advisor/mysql/rule_online_migration.go b/backend/plugin/advisor/mysql/rule_online_migration.goindex 248a834fb3..86a1536542 100644--- a/backend/plugin/advisor/mysql/rule_online_migration.go+++ b/backend/plugin/advisor/mysql/rule_online_migration.go@@ -73,7 +73,7 @@ func (*OnlineMigrationAdvisor) Check(ctx context.Context, checkCtx advisor.ContechangedResources: make(map[string]base.SchemaResource),}- RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule})+ RunRules(checkCtx.ParsedStatements, []OmniRule{rule})adviceList := rule.GetAdviceList()diff --git a/backend/plugin/advisor/mysql/rule_statement_add_column_without_position.go b/backend/plugin/advisor/mysql/rule_statement_add_column_without_position.goindex 13fa9644f5..234a88cb42 100644--- a/backend/plugin/advisor/mysql/rule_statement_add_column_without_position.go+++ b/backend/plugin/advisor/mysql/rule_statement_add_column_without_position.go@@ -38,7 +38,7 @@ func (*StatementAddColumnWithoutPositionAdvisor) Check(_ context.Context, checkC},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type addColumnWithoutPositionOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_statement_disallow_truncate.go b/backend/plugin/advisor/mysql/rule_statement_disallow_truncate.goindex cf1f176847..ff7ee42ff7 100644--- a/backend/plugin/advisor/mysql/rule_statement_disallow_truncate.go+++ b/backend/plugin/advisor/mysql/rule_statement_disallow_truncate.go@@ -30,7 +30,7 @@ func (*StatementDisallowTruncateAdvisor) Check(_ context.Context, checkCtx advisrule := &statementDisallowTruncateOmniRule{OmniBaseRule: OmniBaseRule{Level: level, Title: checkCtx.Rule.Type.String()},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type statementDisallowTruncateOmniRule struct{ OmniBaseRule }diff --git a/backend/plugin/advisor/mysql/rule_statement_maximum_statements_in_transaction.go b/backend/plugin/advisor/mysql/rule_statement_maximum_statements_in_transaction.goindex 8e5cd9e6f1..35d5344173 100644--- a/backend/plugin/advisor/mysql/rule_statement_maximum_statements_in_transaction.go+++ b/backend/plugin/advisor/mysql/rule_statement_maximum_statements_in_transaction.go@@ -36,7 +36,7 @@ func (*StatementMaximumStatementsInTransactionAdvisor) Check(_ context.Context,}// This rule was a no-op in ANTLR (OnEnter only stored text, no advice generated).- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type maxStmtsInTxnOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_statement_merge_alter_table.go b/backend/plugin/advisor/mysql/rule_statement_merge_alter_table.goindex d4388da418..982aa5f5af 100644--- a/backend/plugin/advisor/mysql/rule_statement_merge_alter_table.go+++ b/backend/plugin/advisor/mysql/rule_statement_merge_alter_table.go@@ -42,7 +42,7 @@ func (*StatementMergeAlterTableAdvisor) Check(_ context.Context, checkCtx advisotableMap: make(map[string]tableStatement),}- RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule})+ RunRules(checkCtx.ParsedStatements, []OmniRule{rule})rule.generateAdvice()return rule.GetAdviceList(), nil}diff --git a/backend/plugin/advisor/mysql/rule_statement_where_disallow_using_function.go b/backend/plugin/advisor/mysql/rule_statement_where_disallow_using_function.goindex 45ed75b148..45f5e00182 100644--- a/backend/plugin/advisor/mysql/rule_statement_where_disallow_using_function.go+++ b/backend/plugin/advisor/mysql/rule_statement_where_disallow_using_function.go@@ -41,7 +41,7 @@ func (*StatementWhereDisallowUsingFunctionAdvisor) Check(_ context.Context, checrule.dbMetadata = model.NewDatabaseMetadata(checkCtx.DBSchema, nil, nil, storepb.Engine_MYSQL, checkCtx.IsObjectCaseSensitive)}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type whereDisallowFuncOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_statement_where_no_equal_null.go b/backend/plugin/advisor/mysql/rule_statement_where_no_equal_null.goindex 1bd3a9fbc2..eeca614590 100644--- a/backend/plugin/advisor/mysql/rule_statement_where_no_equal_null.go+++ b/backend/plugin/advisor/mysql/rule_statement_where_no_equal_null.go@@ -37,7 +37,7 @@ func (*StatementWhereNoEqualNullAdvisor) Check(_ context.Context, checkCtx advis},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type whereNoEqualNullOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_stmt_disallow_commit.go b/backend/plugin/advisor/mysql/rule_stmt_disallow_commit.goindex ae71ee5eca..3d2e49269a 100644--- a/backend/plugin/advisor/mysql/rule_stmt_disallow_commit.go+++ b/backend/plugin/advisor/mysql/rule_stmt_disallow_commit.go@@ -41,7 +41,7 @@ func (*StatementDisallowCommitAdvisor) Check(_ context.Context, checkCtx advisor},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type disallowCommitOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_stmt_disallow_limit.go b/backend/plugin/advisor/mysql/rule_stmt_disallow_limit.goindex 52d7dab6bd..82538b25c9 100644--- a/backend/plugin/advisor/mysql/rule_stmt_disallow_limit.go+++ b/backend/plugin/advisor/mysql/rule_stmt_disallow_limit.go@@ -41,7 +41,7 @@ func (*StatementDisallowLimitAdvisor) Check(_ context.Context, checkCtx advisor.},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type disallowLimitOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_stmt_disallow_order_by.go b/backend/plugin/advisor/mysql/rule_stmt_disallow_order_by.goindex ab8307020d..df3842d58f 100644--- a/backend/plugin/advisor/mysql/rule_stmt_disallow_order_by.go+++ b/backend/plugin/advisor/mysql/rule_stmt_disallow_order_by.go@@ -41,7 +41,7 @@ func (*DisallowOrderByAdvisor) Check(_ context.Context, checkCtx advisor.Context},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type disallowOrderByOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_stmt_no_leading_wildcard_like.go b/backend/plugin/advisor/mysql/rule_stmt_no_leading_wildcard_like.goindex 39f5ce5764..2e2aff5dff 100644--- a/backend/plugin/advisor/mysql/rule_stmt_no_leading_wildcard_like.go+++ b/backend/plugin/advisor/mysql/rule_stmt_no_leading_wildcard_like.go@@ -41,7 +41,7 @@ func (*NoLeadingWildcardLikeAdvisor) Check(_ context.Context, checkCtx advisor.C},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type noLeadingWildcardLikeOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_stmt_no_select_all.go b/backend/plugin/advisor/mysql/rule_stmt_no_select_all.goindex 66ff666678..28e466aff6 100644--- a/backend/plugin/advisor/mysql/rule_stmt_no_select_all.go+++ b/backend/plugin/advisor/mysql/rule_stmt_no_select_all.go@@ -41,7 +41,7 @@ func (*NoSelectAllAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type noSelectAllOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_stmt_require_algorithm_or_lock_options.go b/backend/plugin/advisor/mysql/rule_stmt_require_algorithm_or_lock_options.goindex 40cd9f0789..6beb04e4eb 100644--- a/backend/plugin/advisor/mysql/rule_stmt_require_algorithm_or_lock_options.go+++ b/backend/plugin/advisor/mysql/rule_stmt_require_algorithm_or_lock_options.go@@ -48,7 +48,7 @@ func (*RequireAlgorithmOrLockOptionAdvisor) Check(_ context.Context, checkCtx aderrorCode: errorCode,}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type requireAlgoLockOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_stmt_where_requirement_for_select.go b/backend/plugin/advisor/mysql/rule_stmt_where_requirement_for_select.goindex 492e409e0b..89fb103077 100644--- a/backend/plugin/advisor/mysql/rule_stmt_where_requirement_for_select.go+++ b/backend/plugin/advisor/mysql/rule_stmt_where_requirement_for_select.go@@ -41,7 +41,7 @@ func (*WhereRequirementForSelectAdvisor) Check(_ context.Context, checkCtx advis},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type whereRequirementForSelectOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_stmt_where_requirement_for_update_delete.go b/backend/plugin/advisor/mysql/rule_stmt_where_requirement_for_update_delete.goindex a789b59a3b..431f15feea 100644--- a/backend/plugin/advisor/mysql/rule_stmt_where_requirement_for_update_delete.go+++ b/backend/plugin/advisor/mysql/rule_stmt_where_requirement_for_update_delete.go@@ -41,7 +41,7 @@ func (*WhereRequirementForUpdateDeleteAdvisor) Check(_ context.Context, checkCtx},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type whereRequirementForUpdateDeleteOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_table_comment_convention.go b/backend/plugin/advisor/mysql/rule_table_comment_convention.goindex 6e3f7c8f55..c8d651d469 100644--- a/backend/plugin/advisor/mysql/rule_table_comment_convention.go+++ b/backend/plugin/advisor/mysql/rule_table_comment_convention.go@@ -42,7 +42,7 @@ func (*TableCommentConventionAdvisor) Check(_ context.Context, checkCtx advisor.payload: commentPayload,}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type tableCommentConventionOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_table_disallow_ddl.go b/backend/plugin/advisor/mysql/rule_table_disallow_ddl.goindex 645cfe475c..cd8785291c 100644--- a/backend/plugin/advisor/mysql/rule_table_disallow_ddl.go+++ b/backend/plugin/advisor/mysql/rule_table_disallow_ddl.go@@ -39,7 +39,7 @@ func (*TableDisallowDDLAdvisor) Check(_ context.Context, checkCtx advisor.ContexdisallowList: stringArrayPayload.List,}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type tableDisallowDDLOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_table_disallow_dml.go b/backend/plugin/advisor/mysql/rule_table_disallow_dml.goindex 70145d043a..fdc63e7db1 100644--- a/backend/plugin/advisor/mysql/rule_table_disallow_dml.go+++ b/backend/plugin/advisor/mysql/rule_table_disallow_dml.go@@ -39,7 +39,7 @@ func (*TableDisallowDMLAdvisor) Check(_ context.Context, checkCtx advisor.ContexdisallowList: stringArrayPayload.List,}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type tableDisallowDMLOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_table_disallow_partition.go b/backend/plugin/advisor/mysql/rule_table_disallow_partition.goindex 2e6318aaf5..bb8abfb764 100644--- a/backend/plugin/advisor/mysql/rule_table_disallow_partition.go+++ b/backend/plugin/advisor/mysql/rule_table_disallow_partition.go@@ -40,7 +40,7 @@ func (*TableDisallowPartitionAdvisor) Check(_ context.Context, checkCtx advisor.},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type tableDisallowPartitionOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_table_disallow_set_charset.go b/backend/plugin/advisor/mysql/rule_table_disallow_set_charset.goindex 8601310d81..93afcae6d8 100644--- a/backend/plugin/advisor/mysql/rule_table_disallow_set_charset.go+++ b/backend/plugin/advisor/mysql/rule_table_disallow_set_charset.go@@ -37,7 +37,7 @@ func (*TableDisallowSetCharsetAdvisor) Check(_ context.Context, checkCtx advisor},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type tableDisallowSetCharsetOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_table_disallow_trigger.go b/backend/plugin/advisor/mysql/rule_table_disallow_trigger.goindex b0618a251b..ffe17df336 100644--- a/backend/plugin/advisor/mysql/rule_table_disallow_trigger.go+++ b/backend/plugin/advisor/mysql/rule_table_disallow_trigger.go@@ -38,7 +38,7 @@ func (*TableDisallowTriggerAdvisor) Check(_ context.Context, checkCtx advisor.Co},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type tableDisallowTriggerOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_table_drop_naming_convention.go b/backend/plugin/advisor/mysql/rule_table_drop_naming_convention.goindex 92aaa4528f..d9d7cd2162 100644--- a/backend/plugin/advisor/mysql/rule_table_drop_naming_convention.go+++ b/backend/plugin/advisor/mysql/rule_table_drop_naming_convention.go@@ -52,7 +52,7 @@ func (*TableDropNamingConventionAdvisor) Check(_ context.Context, checkCtx advisformat: format,}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type tableDropNamingConventionOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_table_limit_size.go b/backend/plugin/advisor/mysql/rule_table_limit_size.goindex ffc7873296..a61bcda0f1 100644--- a/backend/plugin/advisor/mysql/rule_table_limit_size.go+++ b/backend/plugin/advisor/mysql/rule_table_limit_size.go@@ -45,7 +45,7 @@ func (*MaximumTableSizeAdvisor) Check(_ context.Context, checkCtx advisor.ContexdbMetadata: checkCtx.DBSchema,}- RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule})+ RunRules(checkCtx.ParsedStatements, []OmniRule{rule})// Generate advice based on collected table information.rule.generateAdvice()diff --git a/backend/plugin/advisor/mysql/rule_table_no_duplicate_index.go b/backend/plugin/advisor/mysql/rule_table_no_duplicate_index.goindex a9dc7df7d8..b1284bfa5f 100644--- a/backend/plugin/advisor/mysql/rule_table_no_duplicate_index.go+++ b/backend/plugin/advisor/mysql/rule_table_no_duplicate_index.go@@ -39,7 +39,7 @@ func (*TableNoDuplicateIndexAdvisor) Check(_ context.Context, checkCtx advisor.C},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type duplicateIndex struct {diff --git a/backend/plugin/advisor/mysql/rule_table_no_fk.go b/backend/plugin/advisor/mysql/rule_table_no_fk.goindex 965c8c5199..bc3674517a 100644--- a/backend/plugin/advisor/mysql/rule_table_no_fk.go+++ b/backend/plugin/advisor/mysql/rule_table_no_fk.go@@ -40,7 +40,7 @@ func (*TableNoFKAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type tableNoFKOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_table_require_charset.go b/backend/plugin/advisor/mysql/rule_table_require_charset.goindex 497a474596..191c2a1923 100644--- a/backend/plugin/advisor/mysql/rule_table_require_charset.go+++ b/backend/plugin/advisor/mysql/rule_table_require_charset.go@@ -38,7 +38,7 @@ func (*TableRequireCharsetAdvisor) Check(_ context.Context, checkCtx advisor.Con},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type tableRequireCharsetOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_table_require_collation.go b/backend/plugin/advisor/mysql/rule_table_require_collation.goindex 1d8e9714f5..12a9e19f5c 100644--- a/backend/plugin/advisor/mysql/rule_table_require_collation.go+++ b/backend/plugin/advisor/mysql/rule_table_require_collation.go@@ -38,7 +38,7 @@ func (*TableRequireCollationAdvisor) Check(_ context.Context, checkCtx advisor.C},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type tableRequireCollationOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_table_require_pk.go b/backend/plugin/advisor/mysql/rule_table_require_pk.goindex e2a6ef6707..7163c17b18 100644--- a/backend/plugin/advisor/mysql/rule_table_require_pk.go+++ b/backend/plugin/advisor/mysql/rule_table_require_pk.go@@ -50,7 +50,7 @@ func (*TableRequirePKAdvisor) Check(_ context.Context, checkCtx advisor.Context)}// Walk all statements.- RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule})+ RunRules(checkCtx.ParsedStatements, []OmniRule{rule})// Generate advice after walking all statements.rule.generateAdviceList()diff --git a/backend/plugin/advisor/mysql/rule_use_innodb.go b/backend/plugin/advisor/mysql/rule_use_innodb.goindex 5fea8b2672..73ca91ec49 100644--- a/backend/plugin/advisor/mysql/rule_use_innodb.go+++ b/backend/plugin/advisor/mysql/rule_use_innodb.go@@ -44,7 +44,7 @@ func (*UseInnoDBAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type useInnoDBOmniRule struct {diff --git a/backend/plugin/advisor/mysql/rule_view_disallow_create.go b/backend/plugin/advisor/mysql/rule_view_disallow_create.goindex 0dcd976025..944bd86d8e 100644--- a/backend/plugin/advisor/mysql/rule_view_disallow_create.go+++ b/backend/plugin/advisor/mysql/rule_view_disallow_create.go@@ -38,7 +38,7 @@ func (*ViewDisallowCreateAdvisor) Check(_ context.Context, checkCtx advisor.Cont},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type viewDisallowCreateOmniRule struct {diff --git a/backend/plugin/advisor/mysql/utils.go b/backend/plugin/advisor/mysql/utils.goindex 9e0eec731a..5a824de8ec 100644--- a/backend/plugin/advisor/mysql/utils.go+++ b/backend/plugin/advisor/mysql/utils.go@@ -6,6 +6,8 @@ import ("slices""strings"+ "github.com/bytebase/omni/mysql/ast"+mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql")@@ -71,3 +73,303 @@ func (t tableColumnTypes) delete(tableName string, columnName string) {func isKeyword(suspect string) bool {return mysqlparser.IsKeyword(suspect)}++// nolint:unused+// omniTableName extracts the table name from a TableRef.+func omniTableName(ref *ast.TableRef) string {+ if ref == nil {+ return ""+ }+ return ref.Name+}++// nolint:unused+// omniColumnNames extracts column name list from a table-level constraint.+func omniColumnNames(constraint *ast.Constraint) []string {+ if constraint == nil {+ return nil+ }+ return constraint.Columns+}++// nolint:unused+// omniIndexColumns extracts column names from an index column list.+// For expression-based index columns, it falls back to the column reference name.+func omniIndexColumns(cols []*ast.IndexColumn) []string {+ if len(cols) == 0 {+ return nil+ }+ var names []string+ for _, col := range cols {+ if ref, ok := col.Expr.(*ast.ColumnRef); ok {+ names = append(names, ref.Column)+ }+ }+ return names+}++// nolint:unused+// omniDataTypeName extracts the normalized (upper-case) type name string from a DataType.+func omniDataTypeName(dt *ast.DataType) string {+ if dt == nil {+ return ""+ }+ return strings.ToUpper(dt.Name)+}++// nolint:unused+// omniIsNullable checks if a column allows NULL.+// A column is nullable unless it has a NOT NULL constraint or is a PRIMARY KEY.+func omniIsNullable(col *ast.ColumnDef) bool {+ if col == nil {+ return true+ }+ for _, c := range col.Constraints {+ if c.Type == ast.ColConstrNotNull || c.Type == ast.ColConstrPrimaryKey {+ return false+ }+ }+ return true+}++// nolint:unused+// omniHasDefault checks if a column has a DEFAULT value.+func omniHasDefault(col *ast.ColumnDef) bool {+ if col == nil {+ return false+ }+ if col.DefaultValue != nil {+ return true+ }+ for _, c := range col.Constraints {+ if c.Type == ast.ColConstrDefault {+ return true+ }+ }+ return false+}++// nolint:unused+// omniIsAutoIncrement checks if a column has AUTO_INCREMENT.+func omniIsAutoIncrement(col *ast.ColumnDef) bool {+ if col == nil {+ return false+ }+ return col.AutoIncrement+}++// nolint:unused+// omniColumnComment extracts the COMMENT string from a column definition.+func omniColumnComment(col *ast.ColumnDef) string {+ if col == nil {+ return ""+ }+ return col.Comment+}++// nolint:unused+// omniTableOptionValue extracts a table option value by name (case-insensitive).+func omniTableOptionValue(opts []*ast.TableOption, name string) string {+ for _, opt := range opts {+ if strings.EqualFold(opt.Name, name) {+ return opt.Value+ }+ }+ return ""+}++// nolint:unused+// omniConstraintsByType filters constraints by the given type.+func omniConstraintsByType(constraints []*ast.Constraint, typ ast.ConstraintType) []*ast.Constraint {+ var result []*ast.Constraint+ for _, c := range constraints {+ if c.Type == typ {+ result = append(result, c)+ }+ }+ return result+}++// omniDataTypeNameCompact returns a compact, lowercase type name string.+func omniDataTypeNameCompact(dt *ast.DataType) string {+ if dt == nil {+ return ""+ }+ return strings.ToLower(dt.Name)+}++// omniIsIntegerType checks if the data type is an integer type.+func omniIsIntegerType(dt *ast.DataType) bool {+ if dt == nil {+ return false+ }+ switch strings.ToUpper(dt.Name) {+ case "INT", "TINYINT", "SMALLINT", "MEDIUMINT", "BIGINT", "INTEGER":+ return true+ default:+ return false+ }+}++// omniIsTimeType checks if the data type is DATETIME or TIMESTAMP.+func omniIsTimeType(dt *ast.DataType) bool {+ if dt == nil {+ return false+ }+ switch strings.ToUpper(dt.Name) {+ case "DATETIME", "TIMESTAMP":+ return true+ default:+ return false+ }+}++// omniIsDefaultCurrentTime checks if a column has DEFAULT CURRENT_TIMESTAMP / NOW().+func omniIsDefaultCurrentTime(col *ast.ColumnDef) bool {+ if col == nil {+ return false+ }+ return isCurrentTimeFuncCall(col.DefaultValue)+}++// omniIsOnUpdateCurrentTime checks if a column has ON UPDATE CURRENT_TIMESTAMP / NOW().+func omniIsOnUpdateCurrentTime(col *ast.ColumnDef) bool {+ if col == nil {+ return false+ }+ return isCurrentTimeFuncCall(col.OnUpdate)+}++// isCurrentTimeFuncCall checks if an expression is a CURRENT_TIMESTAMP/NOW() call.+func isCurrentTimeFuncCall(expr ast.ExprNode) bool {+ if expr == nil {+ return false+ }+ fc, ok := expr.(*ast.FuncCallExpr)+ if !ok {+ return false+ }+ switch strings.ToUpper(fc.Name) {+ case "NOW", "CURRENT_TIMESTAMP", "LOCALTIME", "LOCALTIMESTAMP":+ return true+ default:+ return false+ }+}++// omniGetColumnsFromCmd extracts column definitions from an AlterTableCmd.+func omniGetColumnsFromCmd(cmd *ast.AlterTableCmd) []*ast.ColumnDef {+ if cmd == nil {+ return nil+ }+ switch cmd.Type {+ case ast.ATAddColumn:+ if cmd.Column != nil {+ return []*ast.ColumnDef{cmd.Column}+ }+ return cmd.Columns+ case ast.ATModifyColumn, ast.ATChangeColumn:+ if cmd.Column != nil {+ return []*ast.ColumnDef{cmd.Column}+ }+ default:+ }+ return nil+}++// nolint:unused+// omniColumnName returns the effective column name for a command.+func omniColumnName(cmd *ast.AlterTableCmd) string {+ if cmd.Column != nil {+ return cmd.Column.Name+ }+ return cmd.Name+}++func omniRenameTableName(cmd *ast.AlterTableCmd) string {+ if cmd == nil || cmd.Type != ast.ATRenameTable {+ return ""+ }+ if cmd.NewTable != nil {+ return cmd.NewTable.Name+ }+ return cmd.NewName+}++// omniIsPrimaryKey checks if a column has a PRIMARY KEY constraint.+func omniIsPrimaryKey(col *ast.ColumnDef) bool {+ if col == nil {+ return false+ }+ for _, c := range col.Constraints {+ if c.Type == ast.ColConstrPrimaryKey {+ return true+ }+ }+ return false+}++// omniPKColumnNames returns a set of column names that are part of a primary key.+func omniPKColumnNames(columns []*ast.ColumnDef, constraints []*ast.Constraint) map[string]bool {+ result := make(map[string]bool)+ for _, col := range columns {+ if omniIsPrimaryKey(col) {+ result[col.Name] = true+ }+ }+ for _, c := range constraints {+ if c.Type == ast.ConstrPrimaryKey {+ for _, name := range c.Columns {+ result[name] = true+ }+ }+ }+ return result+}++// omniColumnNeedDefault checks if a column is NOT NULL and needs a DEFAULT.+// nolint:unused+func omniColumnNeedDefault(col *ast.ColumnDef) bool {+ if col == nil {+ return false+ }+ return !omniIsNullable(col) && !omniHasDefault(col) && !omniIsPrimaryKey(col)+}++// omniIsDefaultExemptType checks if a column type is exempt from requiring DEFAULT+// (BLOB, TEXT, JSON, GEOMETRY and spatial types).+func omniIsDefaultExemptType(col *ast.ColumnDef) bool {+ if col == nil || col.TypeName == nil {+ return false+ }+ switch strings.ToUpper(col.TypeName.Name) {+ case "BLOB", "TINYBLOB", "MEDIUMBLOB", "LONGBLOB",+ "TEXT", "TINYTEXT", "MEDIUMTEXT", "LONGTEXT",+ "JSON", "GEOMETRY", "POINT", "LINESTRING", "POLYGON",+ "MULTIPOINT", "MULTILINESTRING", "MULTIPOLYGON", "GEOMETRYCOLLECTION",+ "GEOMCOLLECTION":+ return true+ default:+ return false+ }+}++// omniColumnNeedDefaultNotNull checks if a NOT NULL column needs a DEFAULT value+// (excludes BLOB, TEXT, JSON, GEOMETRY, and AUTO_INCREMENT columns).+func omniColumnNeedDefaultNotNull(col *ast.ColumnDef) bool {+ if col == nil {+ return false+ }+ if omniIsNullable(col) || omniHasDefault(col) || omniIsPrimaryKey(col) || col.AutoIncrement {+ return false+ }+ if col.TypeName != nil {+ switch strings.ToUpper(col.TypeName.Name) {+ case "BLOB", "TINYBLOB", "MEDIUMBLOB", "LONGBLOB",+ "TEXT", "TINYTEXT", "MEDIUMTEXT", "LONGTEXT",+ "JSON", "GEOMETRY", "SERIAL":+ return false+ }+ }+ return true+}diff --git a/backend/plugin/advisor/mysql/utils_omni.go b/backend/plugin/advisor/mysql/utils_omni.godeleted file mode 100644index bec232d706..0000000000--- a/backend/plugin/advisor/mysql/utils_omni.go+++ /dev/null@@ -1,307 +0,0 @@-package mysql--import (- "strings"-- "github.com/bytebase/omni/mysql/ast"-)--// nolint:unused-// omniTableName extracts the table name from a TableRef.-func omniTableName(ref *ast.TableRef) string {- if ref == nil {- return ""- }- return ref.Name-}--// nolint:unused-// omniColumnNames extracts column name list from a table-level constraint.-func omniColumnNames(constraint *ast.Constraint) []string {- if constraint == nil {- return nil- }- return constraint.Columns-}--// nolint:unused-// omniIndexColumns extracts column names from an index column list.-// For expression-based index columns, it falls back to the column reference name.-func omniIndexColumns(cols []*ast.IndexColumn) []string {- if len(cols) == 0 {- return nil- }- var names []string- for _, col := range cols {- if ref, ok := col.Expr.(*ast.ColumnRef); ok {- names = append(names, ref.Column)- }- }- return names-}--// nolint:unused-// omniDataTypeName extracts the normalized (upper-case) type name string from a DataType.-func omniDataTypeName(dt *ast.DataType) string {- if dt == nil {- return ""- }- return strings.ToUpper(dt.Name)-}--// nolint:unused-// omniIsNullable checks if a column allows NULL.-// A column is nullable unless it has a NOT NULL constraint or is a PRIMARY KEY.-func omniIsNullable(col *ast.ColumnDef) bool {- if col == nil {- return true- }- for _, c := range col.Constraints {- if c.Type == ast.ColConstrNotNull || c.Type == ast.ColConstrPrimaryKey {- return false- }- }- return true-}--// nolint:unused-// omniHasDefault checks if a column has a DEFAULT value.-func omniHasDefault(col *ast.ColumnDef) bool {- if col == nil {- return false- }- if col.DefaultValue != nil {- return true- }- for _, c := range col.Constraints {- if c.Type == ast.ColConstrDefault {- return true- }- }- return false-}--// nolint:unused-// omniIsAutoIncrement checks if a column has AUTO_INCREMENT.-func omniIsAutoIncrement(col *ast.ColumnDef) bool {- if col == nil {- return false- }- return col.AutoIncrement-}--// nolint:unused-// omniColumnComment extracts the COMMENT string from a column definition.-func omniColumnComment(col *ast.ColumnDef) string {- if col == nil {- return ""- }- return col.Comment-}--// nolint:unused-// omniTableOptionValue extracts a table option value by name (case-insensitive).-func omniTableOptionValue(opts []*ast.TableOption, name string) string {- for _, opt := range opts {- if strings.EqualFold(opt.Name, name) {- return opt.Value- }- }- return ""-}--// nolint:unused-// omniConstraintsByType filters constraints by the given type.-func omniConstraintsByType(constraints []*ast.Constraint, typ ast.ConstraintType) []*ast.Constraint {- var result []*ast.Constraint- for _, c := range constraints {- if c.Type == typ {- result = append(result, c)- }- }- return result-}--// omniDataTypeNameCompact returns a compact, lowercase type name string.-func omniDataTypeNameCompact(dt *ast.DataType) string {- if dt == nil {- return ""- }- return strings.ToLower(dt.Name)-}--// omniIsIntegerType checks if the data type is an integer type.-func omniIsIntegerType(dt *ast.DataType) bool {- if dt == nil {- return false- }- switch strings.ToUpper(dt.Name) {- case "INT", "TINYINT", "SMALLINT", "MEDIUMINT", "BIGINT", "INTEGER":- return true- default:- return false- }-}--// omniIsTimeType checks if the data type is DATETIME or TIMESTAMP.-func omniIsTimeType(dt *ast.DataType) bool {- if dt == nil {- return false- }- switch strings.ToUpper(dt.Name) {- case "DATETIME", "TIMESTAMP":- return true- default:- return false- }-}--// omniIsDefaultCurrentTime checks if a column has DEFAULT CURRENT_TIMESTAMP / NOW().-func omniIsDefaultCurrentTime(col *ast.ColumnDef) bool {- if col == nil {- return false- }- return isCurrentTimeFuncCall(col.DefaultValue)-}--// omniIsOnUpdateCurrentTime checks if a column has ON UPDATE CURRENT_TIMESTAMP / NOW().-func omniIsOnUpdateCurrentTime(col *ast.ColumnDef) bool {- if col == nil {- return false- }- return isCurrentTimeFuncCall(col.OnUpdate)-}--// isCurrentTimeFuncCall checks if an expression is a CURRENT_TIMESTAMP/NOW() call.-func isCurrentTimeFuncCall(expr ast.ExprNode) bool {- if expr == nil {- return false- }- fc, ok := expr.(*ast.FuncCallExpr)- if !ok {- return false- }- switch strings.ToUpper(fc.Name) {- case "NOW", "CURRENT_TIMESTAMP", "LOCALTIME", "LOCALTIMESTAMP":- return true- default:- return false- }-}--// omniGetColumnsFromCmd extracts column definitions from an AlterTableCmd.-func omniGetColumnsFromCmd(cmd *ast.AlterTableCmd) []*ast.ColumnDef {- if cmd == nil {- return nil- }- switch cmd.Type {- case ast.ATAddColumn:- if cmd.Column != nil {- return []*ast.ColumnDef{cmd.Column}- }- return cmd.Columns- case ast.ATModifyColumn, ast.ATChangeColumn:- if cmd.Column != nil {- return []*ast.ColumnDef{cmd.Column}- }- default:- }- return nil-}--// nolint:unused-// omniColumnName returns the effective column name for a command.-func omniColumnName(cmd *ast.AlterTableCmd) string {- if cmd.Column != nil {- return cmd.Column.Name- }- return cmd.Name-}--func omniRenameTableName(cmd *ast.AlterTableCmd) string {- if cmd == nil || cmd.Type != ast.ATRenameTable {- return ""- }- if cmd.NewTable != nil {- return cmd.NewTable.Name- }- return cmd.NewName-}--// omniIsPrimaryKey checks if a column has a PRIMARY KEY constraint.-func omniIsPrimaryKey(col *ast.ColumnDef) bool {- if col == nil {- return false- }- for _, c := range col.Constraints {- if c.Type == ast.ColConstrPrimaryKey {- return true- }- }- return false-}--// omniPKColumnNames returns a set of column names that are part of a primary key.-func omniPKColumnNames(columns []*ast.ColumnDef, constraints []*ast.Constraint) map[string]bool {- result := make(map[string]bool)- for _, col := range columns {- if omniIsPrimaryKey(col) {- result[col.Name] = true- }- }- for _, c := range constraints {- if c.Type == ast.ConstrPrimaryKey {- for _, name := range c.Columns {- result[name] = true- }- }- }- return result-}--// omniColumnNeedDefault checks if a column is NOT NULL and needs a DEFAULT.-// nolint:unused-func omniColumnNeedDefault(col *ast.ColumnDef) bool {- if col == nil {- return false- }- return !omniIsNullable(col) && !omniHasDefault(col) && !omniIsPrimaryKey(col)-}--// omniIsDefaultExemptType checks if a column type is exempt from requiring DEFAULT-// (BLOB, TEXT, JSON, GEOMETRY and spatial types).-func omniIsDefaultExemptType(col *ast.ColumnDef) bool {- if col == nil || col.TypeName == nil {- return false- }- switch strings.ToUpper(col.TypeName.Name) {- case "BLOB", "TINYBLOB", "MEDIUMBLOB", "LONGBLOB",- "TEXT", "TINYTEXT", "MEDIUMTEXT", "LONGTEXT",- "JSON", "GEOMETRY", "POINT", "LINESTRING", "POLYGON",- "MULTIPOINT", "MULTILINESTRING", "MULTIPOLYGON", "GEOMETRYCOLLECTION",- "GEOMCOLLECTION":- return true- default:- return false- }-}--// omniColumnNeedDefaultNotNull checks if a NOT NULL column needs a DEFAULT value-// (excludes BLOB, TEXT, JSON, GEOMETRY, and AUTO_INCREMENT columns).-func omniColumnNeedDefaultNotNull(col *ast.ColumnDef) bool {- if col == nil {- return false- }- if omniIsNullable(col) || omniHasDefault(col) || omniIsPrimaryKey(col) || col.AutoIncrement {- return false- }- if col.TypeName != nil {- switch strings.ToUpper(col.TypeName.Name) {- case "BLOB", "TINYBLOB", "MEDIUMBLOB", "LONGBLOB",- "TEXT", "TINYTEXT", "MEDIUMTEXT", "LONGTEXT",- "JSON", "GEOMETRY", "SERIAL":- return false- }- }- return true-}diff --git a/backend/plugin/advisor/oracle/generic_checker.go b/backend/plugin/advisor/oracle/generic_checker.goindex d6f5b24186..cab466d818 100644--- a/backend/plugin/advisor/oracle/generic_checker.go+++ b/backend/plugin/advisor/oracle/generic_checker.go@@ -5,10 +5,10 @@ import ("github.com/bytebase/omni/oracle/ast"storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"plsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/plsql")-// BaseRule provides common functionality for Oracle advisor rules.type BaseRule struct {level storepb.Advice_Statustitle string@@ -69,3 +69,39 @@ 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) {}++// OmniRule defines the Oracle omni SQL review rule interface.+type OmniRule interface {+ OnStatement(node ast.Node)+ Name() string+ GetAdviceList() ([]*storepb.Advice, error)+}++// RunRules dispatches parsed Oracle omni AST nodes to rules.+func RunRules(stmts []base.ParsedStatement, rules []OmniRule) ([]*storepb.Advice, error) {+ for _, stmt := range stmts {+ if stmt.AST == nil {+ continue+ }+ node, ok := plsqlparser.GetOmniNode(stmt.AST)+ if !ok {+ continue+ }+ for _, rule := range rules {+ if br, ok := rule.(interface{ SetStatement(int, string) }); ok {+ br.SetStatement(stmt.BaseLine(), stmt.Text)+ }+ rule.OnStatement(node)+ }+ }++ var adviceList []*storepb.Advice+ for _, rule := range rules {+ list, err := rule.GetAdviceList()+ if err != nil {+ return nil, err+ }+ adviceList = append(adviceList, list...)+ }+ return adviceList, nil+}diff --git a/backend/plugin/advisor/oracle/generic_checker_omni.go b/backend/plugin/advisor/oracle/generic_checker_omni.godeleted file mode 100644index e4b396d766..0000000000--- a/backend/plugin/advisor/oracle/generic_checker_omni.go+++ /dev/null@@ -1,45 +0,0 @@-package oracle--import (- "github.com/bytebase/omni/oracle/ast"-- storepb "github.com/bytebase/bytebase/backend/generated-go/store"- "github.com/bytebase/bytebase/backend/plugin/parser/base"- plsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/plsql"-)--// OmniRule defines the Oracle omni SQL review rule interface.-type OmniRule interface {- OnStatement(node ast.Node)- Name() string- GetAdviceList() ([]*storepb.Advice, error)-}--// RunOmniRules dispatches parsed Oracle omni AST nodes to rules.-func RunOmniRules(stmts []base.ParsedStatement, rules []OmniRule) ([]*storepb.Advice, error) {- for _, stmt := range stmts {- if stmt.AST == nil {- continue- }- node, ok := plsqlparser.GetOmniNode(stmt.AST)- if !ok {- continue- }- for _, rule := range rules {- if br, ok := rule.(interface{ SetStatement(int, string) }); ok {- br.SetStatement(stmt.BaseLine(), stmt.Text)- }- rule.OnStatement(node)- }- }-- var adviceList []*storepb.Advice- for _, rule := range rules {- list, err := rule.GetAdviceList()- if err != nil {- return nil, err- }- adviceList = append(adviceList, list...)- }- return adviceList, nil-}diff --git a/backend/plugin/advisor/oracle/rule_builtin_prior_backup_check.go b/backend/plugin/advisor/oracle/rule_builtin_prior_backup_check.goindex d57f24fd90..d162b9a97c 100644--- a/backend/plugin/advisor/oracle/rule_builtin_prior_backup_check.go+++ b/backend/plugin/advisor/oracle/rule_builtin_prior_backup_check.go@@ -36,7 +36,7 @@ func (*StatementPriorBackupCheckAdvisor) Check(ctx context.Context, checkCtx advrule := NewStatementPriorBackupCheckRule(ctx, level, checkCtx.Rule.Type.String(), checkCtx)- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule})+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule})}type StatementType intdiff --git a/backend/plugin/advisor/oracle/rule_column_add_not_null_column_require_default.go b/backend/plugin/advisor/oracle/rule_column_add_not_null_column_require_default.goindex 06a530ee32..f2bfb85114 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@@ -34,7 +34,7 @@ func (*ColumnAddNotNullColumnRequireDefaultAdvisor) Check(_ context.Context, cherule := NewColumnAddNotNullColumnRequireDefaultRule(level, checkCtx.Rule.Type.String(), checkCtx.CurrentDatabase)- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule})+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule})}// ColumnAddNotNullColumnRequireDefaultRule is the rule implementation for adding not null column requires default.diff --git a/backend/plugin/advisor/oracle/rule_column_comment_convention.go b/backend/plugin/advisor/oracle/rule_column_comment_convention.goindex 5885807c7c..12ddf7ef31 100644--- a/backend/plugin/advisor/oracle/rule_column_comment_convention.go+++ b/backend/plugin/advisor/oracle/rule_column_comment_convention.go@@ -34,7 +34,7 @@ func (*ColumnCommentConventionAdvisor) Check(_ context.Context, checkCtx advisorrule := NewColumnCommentConventionRule(level, checkCtx.Rule.Type.String(), checkCtx.CurrentDatabase, commentPayload)- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule})+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule})}// ColumnCommentConventionRule is the rule implementation for column comment convention.diff --git a/backend/plugin/advisor/oracle/rule_column_maximum_character_length.go b/backend/plugin/advisor/oracle/rule_column_maximum_character_length.goindex 73da503540..3a164c3f20 100644--- a/backend/plugin/advisor/oracle/rule_column_maximum_character_length.go+++ b/backend/plugin/advisor/oracle/rule_column_maximum_character_length.go@@ -43,7 +43,7 @@ func (*ColumnMaximumCharacterLengthAdvisor) Check(_ context.Context, checkCtx adrule := NewColumnMaximumCharacterLengthRule(level, checkCtx.Rule.Type.String(), int(numberPayload.Number))- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule})+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule})}// ColumnMaximumCharacterLengthRule is the rule implementation for maximum character length.diff --git a/backend/plugin/advisor/oracle/rule_column_maximum_varchar_length.go b/backend/plugin/advisor/oracle/rule_column_maximum_varchar_length.goindex 2afe626989..23ef9b268c 100644--- a/backend/plugin/advisor/oracle/rule_column_maximum_varchar_length.go+++ b/backend/plugin/advisor/oracle/rule_column_maximum_varchar_length.go@@ -43,7 +43,7 @@ func (*ColumnMaximumVarcharLengthAdvisor) Check(_ context.Context, checkCtx advirule := NewColumnMaximumVarcharLengthRule(level, checkCtx.Rule.Type.String(), int(numberPayload.Number))- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule})+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule})}// ColumnMaximumVarcharLengthRule is the rule implementation for maximum varchar length.diff --git a/backend/plugin/advisor/oracle/rule_column_no_null.go b/backend/plugin/advisor/oracle/rule_column_no_null.goindex 021b5b9745..e9d1e627dc 100644--- a/backend/plugin/advisor/oracle/rule_column_no_null.go+++ b/backend/plugin/advisor/oracle/rule_column_no_null.go@@ -37,7 +37,7 @@ func (*ColumnNoNullAdvisor) Check(_ context.Context, checkCtx advisor.Context) (rule := NewColumnNoNullRule(level, checkCtx.Rule.Type.String(), checkCtx.CurrentDatabase)- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule})+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule})}// ColumnNoNullRule is the rule implementation for column no NULL value.diff --git a/backend/plugin/advisor/oracle/rule_column_require.go b/backend/plugin/advisor/oracle/rule_column_require.goindex fc647adccd..5f8b9005aa 100644--- a/backend/plugin/advisor/oracle/rule_column_require.go+++ b/backend/plugin/advisor/oracle/rule_column_require.go@@ -41,7 +41,7 @@ func (*ColumnRequireAdvisor) Check(_ context.Context, checkCtx advisor.Context)rule := NewColumnRequireRule(level, checkCtx.Rule.Type.String(), checkCtx.CurrentDatabase, stringArrayPayload.List)- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule})+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule})}type columnSet map[string]booldiff --git a/backend/plugin/advisor/oracle/rule_column_require_default.go b/backend/plugin/advisor/oracle/rule_column_require_default.goindex d15f47bd2a..b01cb5b6e0 100644--- a/backend/plugin/advisor/oracle/rule_column_require_default.go+++ b/backend/plugin/advisor/oracle/rule_column_require_default.go@@ -35,7 +35,7 @@ func (*ColumnRequireDefaultAdvisor) Check(_ context.Context, checkCtx advisor.Corule := NewColumnRequireDefaultRule(level, checkCtx.Rule.Type.String(), checkCtx.CurrentDatabase)- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule})+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule})}// ColumnRequireDefaultRule is the rule implementation for column default requirement.diff --git a/backend/plugin/advisor/oracle/rule_column_type_disallow_list.go b/backend/plugin/advisor/oracle/rule_column_type_disallow_list.goindex 1b086fffdf..cf02f9f5a0 100644--- a/backend/plugin/advisor/oracle/rule_column_type_disallow_list.go+++ b/backend/plugin/advisor/oracle/rule_column_type_disallow_list.go@@ -37,7 +37,7 @@ func (*ColumnTypeDisallowListAdvisor) Check(_ context.Context, checkCtx advisor.rule := NewColumnTypeDisallowListRule(level, checkCtx.Rule.Type.String(), checkCtx.CurrentDatabase, stringArrayPayload.List)- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule})+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule})}// ColumnTypeDisallowListRule is the rule implementation for column type disallow list.diff --git a/backend/plugin/advisor/oracle/rule_index_key_number_limit.go b/backend/plugin/advisor/oracle/rule_index_key_number_limit.goindex eaaf2812b0..27f61eb59e 100644--- a/backend/plugin/advisor/oracle/rule_index_key_number_limit.go+++ b/backend/plugin/advisor/oracle/rule_index_key_number_limit.go@@ -43,7 +43,7 @@ func (*IndexKeyNumberLimitAdvisor) Check(_ context.Context, checkCtx advisor.Conrule := NewIndexKeyNumberLimitRule(level, checkCtx.Rule.Type.String(), checkCtx.CurrentDatabase, int(numberPayload.Number))- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule})+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule})}// IndexKeyNumberLimitRule is the rule implementation for index key number limit.diff --git a/backend/plugin/advisor/oracle/rule_insert_must_specify_column.go b/backend/plugin/advisor/oracle/rule_insert_must_specify_column.goindex e8e906d5ba..83b5bf4038 100644--- a/backend/plugin/advisor/oracle/rule_insert_must_specify_column.go+++ b/backend/plugin/advisor/oracle/rule_insert_must_specify_column.go@@ -33,7 +33,7 @@ func (*InsertMustSpecifyColumnAdvisor) Check(_ context.Context, checkCtx advisorrule := NewInsertMustSpecifyColumnRule(level, checkCtx.Rule.Type.String(), checkCtx.CurrentDatabase)- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule})+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule})}// InsertMustSpecifyColumnRule is the rule implementation for enforcing column specification in INSERT.diff --git a/backend/plugin/advisor/oracle/rule_naming_identifier_case.go b/backend/plugin/advisor/oracle/rule_naming_identifier_case.goindex 31523ad6ca..6a423503a4 100644--- a/backend/plugin/advisor/oracle/rule_naming_identifier_case.go+++ b/backend/plugin/advisor/oracle/rule_naming_identifier_case.go@@ -36,7 +36,7 @@ func (*NamingIdentifierCaseAdvisor) Check(_ context.Context, checkCtx advisor.Corule := NewNamingIdentifierCaseRule(level, checkCtx.Rule.Type.String(), checkCtx.CurrentDatabase, namingCasePayload.Upper)- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule})+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule})}// NamingIdentifierCaseRule is the rule implementation for identifier case.diff --git a/backend/plugin/advisor/oracle/rule_naming_identifier_no_keyword.go b/backend/plugin/advisor/oracle/rule_naming_identifier_no_keyword.goindex 45de55ee65..97f572bc76 100644--- a/backend/plugin/advisor/oracle/rule_naming_identifier_no_keyword.go+++ b/backend/plugin/advisor/oracle/rule_naming_identifier_no_keyword.go@@ -35,7 +35,7 @@ func (*NamingIdentifierNoKeywordAdvisor) Check(_ context.Context, checkCtx advisrule := NewNamingIdentifierNoKeywordRule(level, checkCtx.Rule.Type.String(), checkCtx.CurrentDatabase)- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule})+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule})}// NamingIdentifierNoKeywordRule is the rule implementation for identifier naming convention without keyword.diff --git a/backend/plugin/advisor/oracle/rule_naming_table.go b/backend/plugin/advisor/oracle/rule_naming_table.goindex 441f67c6d1..2d0de04be3 100644--- a/backend/plugin/advisor/oracle/rule_naming_table.go+++ b/backend/plugin/advisor/oracle/rule_naming_table.go@@ -50,7 +50,7 @@ func (*NamingTableAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([rule := NewNamingTableRule(level, checkCtx.Rule.Type.String(), checkCtx.CurrentDatabase, format, maxLength)- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule})+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule})}// NamingTableRule is the rule implementation for table naming convention.diff --git a/backend/plugin/advisor/oracle/rule_naming_table_no_keyword.go b/backend/plugin/advisor/oracle/rule_naming_table_no_keyword.goindex 20cee59090..9f6e90fce2 100644--- a/backend/plugin/advisor/oracle/rule_naming_table_no_keyword.go+++ b/backend/plugin/advisor/oracle/rule_naming_table_no_keyword.go@@ -35,7 +35,7 @@ func (*NamingTableNoKeywordAdvisor) Check(_ context.Context, checkCtx advisor.Corule := NewNamingTableNoKeywordRule(level, checkCtx.Rule.Type.String(), checkCtx.CurrentDatabase)- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule})+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule})}// NamingTableNoKeywordRule is the rule implementation for table naming convention without keyword.diff --git a/backend/plugin/advisor/oracle/rule_select_no_select_all.go b/backend/plugin/advisor/oracle/rule_select_no_select_all.goindex c65f5048b1..734e80a38d 100644--- a/backend/plugin/advisor/oracle/rule_select_no_select_all.go+++ b/backend/plugin/advisor/oracle/rule_select_no_select_all.go@@ -33,7 +33,7 @@ func (*SelectNoSelectAllAdvisor) Check(_ context.Context, checkCtx advisor.Conterule := NewSelectNoSelectAllRule(level, checkCtx.Rule.Type.String(), checkCtx.CurrentDatabase)- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule})+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule})}// SelectNoSelectAllRule is the rule implementation for no select all.diff --git a/backend/plugin/advisor/oracle/rule_statement_disallow_truncate.go b/backend/plugin/advisor/oracle/rule_statement_disallow_truncate.goindex b08d7a4576..15fb376839 100644--- a/backend/plugin/advisor/oracle/rule_statement_disallow_truncate.go+++ b/backend/plugin/advisor/oracle/rule_statement_disallow_truncate.go@@ -44,7 +44,7 @@ func (*StatementDisallowTruncateAdvisor) Check(_ context.Context, checkCtx advisreturn nil, err}rule := &StatementDisallowTruncateRule{BaseRule: NewBaseRule(level, checkCtx.Rule.Type.String(), 0)}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule})+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule})}type StatementDisallowTruncateRule struct{ BaseRule }diff --git a/backend/plugin/advisor/oracle/rule_statement_dml_dry_run.go b/backend/plugin/advisor/oracle/rule_statement_dml_dry_run.goindex 35fa535270..7fc2b08f84 100644--- a/backend/plugin/advisor/oracle/rule_statement_dml_dry_run.go+++ b/backend/plugin/advisor/oracle/rule_statement_dml_dry_run.go@@ -39,7 +39,7 @@ func (*StatementDmlDryRunAdvisor) Check(ctx context.Context, checkCtx advisor.Corule := NewStatementDmlDryRunRule(ctx, level, checkCtx.Rule.Type.String(), checkCtx.Driver)if checkCtx.Driver != nil {- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule})+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule})}return rule.GetAdviceList()diff --git a/backend/plugin/advisor/oracle/rule_statement_where_disallow_functions_and_calculations.go b/backend/plugin/advisor/oracle/rule_statement_where_disallow_functions_and_calculations.goindex f13fa02d6d..5d454e6530 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@@ -48,7 +48,7 @@ func (*StatementWhereDisallowFunctionsAndCalculationsAdvisor) Check(_ context.CocheckCtx.IsObjectCaseSensitive,)rule.currentDatabase = checkCtx.CurrentDatabase- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule})+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule})}// ---- Types ---------------------------------------------------------------diff --git a/backend/plugin/advisor/oracle/rule_table_comment_convention.go b/backend/plugin/advisor/oracle/rule_table_comment_convention.goindex 31bdafaca9..3ca5db6a26 100644--- a/backend/plugin/advisor/oracle/rule_table_comment_convention.go+++ b/backend/plugin/advisor/oracle/rule_table_comment_convention.go@@ -34,7 +34,7 @@ func (*TableCommentConventionAdvisor) Check(_ context.Context, checkCtx advisor.rule := NewTableCommentConventionRule(level, checkCtx.Rule.Type.String(), checkCtx.CurrentDatabase, commentPayload)- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule})+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule})}// TableCommentConventionRule is the rule implementation for table comment convention.diff --git a/backend/plugin/advisor/oracle/rule_table_no_foreign_key.go b/backend/plugin/advisor/oracle/rule_table_no_foreign_key.goindex 790461965c..e8a3c0a173 100644--- a/backend/plugin/advisor/oracle/rule_table_no_foreign_key.go+++ b/backend/plugin/advisor/oracle/rule_table_no_foreign_key.go@@ -34,7 +34,7 @@ func (*TableNoForeignKeyAdvisor) Check(_ context.Context, checkCtx advisor.Conterule := NewTableNoForeignKeyRule(level, checkCtx.Rule.Type.String(), checkCtx.CurrentDatabase)- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule})+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule})}// TableNoForeignKeyRule is the rule implementation for table disallow foreign key.diff --git a/backend/plugin/advisor/oracle/rule_table_require_pk.go b/backend/plugin/advisor/oracle/rule_table_require_pk.goindex f425479dc4..5c963f3bd2 100644--- a/backend/plugin/advisor/oracle/rule_table_require_pk.go+++ b/backend/plugin/advisor/oracle/rule_table_require_pk.go@@ -35,7 +35,7 @@ func (*TableRequirePKAdvisor) Check(_ context.Context, checkCtx advisor.Context)rule := NewTableRequirePKRule(level, checkCtx.Rule.Type.String(), checkCtx.CurrentDatabase)- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule})+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule})}// TableRequirePKRule is the rule implementation for table requires PK.diff --git a/backend/plugin/advisor/oracle/rule_where_no_leading_wildcard_like.go b/backend/plugin/advisor/oracle/rule_where_no_leading_wildcard_like.goindex 55b577cbbb..904c2f5db4 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@@ -34,7 +34,7 @@ func (*WhereNoLeadingWildcardLikeAdvisor) Check(_ context.Context, checkCtx advirule := NewWhereNoLeadingWildcardLikeRule(level, checkCtx.Rule.Type.String(), checkCtx.CurrentDatabase)- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule})+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule})}// WhereNoLeadingWildcardLikeRule is the rule implementation for no leading wildcard LIKE.diff --git a/backend/plugin/advisor/oracle/rule_where_require_for_select.go b/backend/plugin/advisor/oracle/rule_where_require_for_select.goindex f989cc0607..347d56ef27 100644--- a/backend/plugin/advisor/oracle/rule_where_require_for_select.go+++ b/backend/plugin/advisor/oracle/rule_where_require_for_select.go@@ -34,7 +34,7 @@ func (*WhereRequireForSelectAdvisor) Check(_ context.Context, checkCtx advisor.Crule := NewWhereRequireForSelectRule(level, checkCtx.Rule.Type.String(), checkCtx.CurrentDatabase)- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule})+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule})}// WhereRequireForSelectRule is the rule implementation for WHERE clause requirement in SELECT.diff --git a/backend/plugin/advisor/oracle/rule_where_require_for_update_delete.go b/backend/plugin/advisor/oracle/rule_where_require_for_update_delete.goindex 953abf9268..8676f5f6d8 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@@ -33,7 +33,7 @@ func (*WhereRequireForUpdateDeleteAdvisor) Check(_ context.Context, checkCtx advrule := NewWhereRequireForUpdateDeleteRule(level, checkCtx.Rule.Type.String(), checkCtx.CurrentDatabase)- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule})+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule})}// WhereRequireForUpdateDeleteRule is the rule implementation for WHERE clause requirement in UPDATE/DELETE.diff --git a/backend/plugin/advisor/oracle/utils_omni.go b/backend/plugin/advisor/oracle/utils.gosimilarity index 100%rename from backend/plugin/advisor/oracle/utils_omni.gorename to backend/plugin/advisor/oracle/utils.godiff --git a/backend/plugin/advisor/pg/advisor_collation_allowlist.go b/backend/plugin/advisor/pg/advisor_collation_allowlist.goindex 8f629e03ea..a885f5c8a1 100644--- a/backend/plugin/advisor/pg/advisor_collation_allowlist.go+++ b/backend/plugin/advisor/pg/advisor_collation_allowlist.go@@ -45,7 +45,7 @@ func (*CollationAllowlistAdvisor) Check(_ context.Context, checkCtx advisor.Contallowlist: allowlist,}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type collationAllowlistRule struct {diff --git a/backend/plugin/advisor/pg/advisor_column_default_disallow_volatile.go b/backend/plugin/advisor/pg/advisor_column_default_disallow_volatile.goindex e6d17abeff..9a5cd9b2f1 100644--- a/backend/plugin/advisor/pg/advisor_column_default_disallow_volatile.go+++ b/backend/plugin/advisor/pg/advisor_column_default_disallow_volatile.go@@ -37,7 +37,7 @@ func (*ColumnDefaultDisallowVolatileAdvisor) Check(_ context.Context, checkCtx a},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type columnDefaultDisallowVolatileRule struct {diff --git a/backend/plugin/advisor/pg/advisor_column_disallow_changing_type.go b/backend/plugin/advisor/pg/advisor_column_disallow_changing_type.goindex a1f4b6ee5b..5c524f827f 100644--- a/backend/plugin/advisor/pg/advisor_column_disallow_changing_type.go+++ b/backend/plugin/advisor/pg/advisor_column_disallow_changing_type.go@@ -38,7 +38,7 @@ func (*ColumnDisallowChangingTypeAdvisor) Check(_ context.Context, checkCtx advi},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type columnDisallowChangingTypeRule struct {diff --git a/backend/plugin/advisor/pg/advisor_column_maximum_character_length.go b/backend/plugin/advisor/pg/advisor_column_maximum_character_length.goindex d35bf6bbcd..895d42e7a0 100644--- a/backend/plugin/advisor/pg/advisor_column_maximum_character_length.go+++ b/backend/plugin/advisor/pg/advisor_column_maximum_character_length.go@@ -49,7 +49,7 @@ func (*ColumnMaximumCharacterLengthAdvisor) Check(_ context.Context, checkCtx admaximum: int(numberPayload.Number),}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type columnMaximumCharacterLengthRule struct {diff --git a/backend/plugin/advisor/pg/advisor_column_no_null.go b/backend/plugin/advisor/pg/advisor_column_no_null.goindex e3c82696fc..21d8289f5c 100644--- a/backend/plugin/advisor/pg/advisor_column_no_null.go+++ b/backend/plugin/advisor/pg/advisor_column_no_null.go@@ -43,7 +43,7 @@ func (*ColumnNoNullAdvisor) Check(_ context.Context, checkCtx advisor.Context) (nullableColumns: make(columnMap),}- // Manually iterate statements instead of using RunOmniRules because+ // Manually iterate statements instead of using RunRules because// generateAdvice must be called AFTER all statements have been processed.for _, stmt := range checkCtx.ParsedStatements {if stmt.AST == nil {diff --git a/backend/plugin/advisor/pg/advisor_column_require_default.go b/backend/plugin/advisor/pg/advisor_column_require_default.goindex 1488c8b3c9..561e090269 100644--- a/backend/plugin/advisor/pg/advisor_column_require_default.go+++ b/backend/plugin/advisor/pg/advisor_column_require_default.go@@ -38,7 +38,7 @@ func (*ColumnRequireDefaultAdvisor) Check(_ context.Context, checkCtx advisor.Co},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type columnRequireDefaultRule struct {diff --git a/backend/plugin/advisor/pg/advisor_column_required.go b/backend/plugin/advisor/pg/advisor_column_required.goindex db8dfa8ea5..6a6f7b3327 100644--- a/backend/plugin/advisor/pg/advisor_column_required.go+++ b/backend/plugin/advisor/pg/advisor_column_required.go@@ -54,7 +54,7 @@ func (*ColumnRequirementAdvisor) Check(_ context.Context, checkCtx advisor.ConterequiredColumnsMap: requiredColumnsMap,}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type columnRequirementRule struct {diff --git a/backend/plugin/advisor/pg/advisor_column_type_disallow_list.go b/backend/plugin/advisor/pg/advisor_column_type_disallow_list.goindex d8a2f03d97..8da4391ede 100644--- a/backend/plugin/advisor/pg/advisor_column_type_disallow_list.go+++ b/backend/plugin/advisor/pg/advisor_column_type_disallow_list.go@@ -46,7 +46,7 @@ func (*ColumnTypeDisallowListAdvisor) Check(_ context.Context, checkCtx advisor.typeRestriction: typeRestriction,}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type columnTypeDisallowListRule struct {diff --git a/backend/plugin/advisor/pg/advisor_comment_convention.go b/backend/plugin/advisor/pg/advisor_comment_convention.goindex 874bc97d22..3b469ddf7d 100644--- a/backend/plugin/advisor/pg/advisor_comment_convention.go+++ b/backend/plugin/advisor/pg/advisor_comment_convention.go@@ -45,7 +45,7 @@ func (*CommentConventionAdvisor) Check(_ context.Context, checkCtx advisor.ContemaxLength: int(numberPayload.Number),}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type commentConventionRule struct {diff --git a/backend/plugin/advisor/pg/advisor_encoding_allowlist.go b/backend/plugin/advisor/pg/advisor_encoding_allowlist.goindex 42c3b16758..7ae7700735 100644--- a/backend/plugin/advisor/pg/advisor_encoding_allowlist.go+++ b/backend/plugin/advisor/pg/advisor_encoding_allowlist.go@@ -46,7 +46,7 @@ func (*EncodingAllowlistAdvisor) Check(_ context.Context, checkCtx advisor.Conteallowlist: allowlist,}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type encodingAllowlistRule struct {diff --git a/backend/plugin/advisor/pg/advisor_index_create_concurrently.go b/backend/plugin/advisor/pg/advisor_index_create_concurrently.goindex c7ffc1f9ea..c757beb108 100644--- a/backend/plugin/advisor/pg/advisor_index_create_concurrently.go+++ b/backend/plugin/advisor/pg/advisor_index_create_concurrently.go@@ -37,7 +37,7 @@ func (*IndexConcurrentlyAdvisor) Check(_ context.Context, checkCtx advisor.ContenewlyCreatedTables: make(map[string]bool),}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type indexCreateConcurrentlyRule struct {diff --git a/backend/plugin/advisor/pg/advisor_index_key_number_limit.go b/backend/plugin/advisor/pg/advisor_index_key_number_limit.goindex 551458e63c..3677dae3b4 100644--- a/backend/plugin/advisor/pg/advisor_index_key_number_limit.go+++ b/backend/plugin/advisor/pg/advisor_index_key_number_limit.go@@ -45,7 +45,7 @@ func (*IndexKeyNumberLimitAdvisor) Check(_ context.Context, checkCtx advisor.Conmax: int(numberPayload.Number),}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type indexKeyNumberLimitRule struct {diff --git a/backend/plugin/advisor/pg/advisor_index_no_duplicate_column.go b/backend/plugin/advisor/pg/advisor_index_no_duplicate_column.goindex 4aad7e79be..8c21fb6d90 100644--- a/backend/plugin/advisor/pg/advisor_index_no_duplicate_column.go+++ b/backend/plugin/advisor/pg/advisor_index_no_duplicate_column.go@@ -37,7 +37,7 @@ func (*IndexNoDuplicateColumnAdvisor) Check(_ context.Context, checkCtx advisor.},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type indexNoDuplicateColumnRule struct {diff --git a/backend/plugin/advisor/pg/advisor_index_primary_key_type_allowlist.go b/backend/plugin/advisor/pg/advisor_index_primary_key_type_allowlist.goindex a4e9e6bb17..b428a6ea52 100644--- a/backend/plugin/advisor/pg/advisor_index_primary_key_type_allowlist.go+++ b/backend/plugin/advisor/pg/advisor_index_primary_key_type_allowlist.go@@ -40,7 +40,7 @@ func (*IndexPrimaryKeyTypeAllowlistAdvisor) Check(_ context.Context, checkCtx adallowlist: stringArrayPayload.List,}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type indexPrimaryKeyTypeAllowlistRule struct {diff --git a/backend/plugin/advisor/pg/advisor_insert_disallow_order_by_rand.go b/backend/plugin/advisor/pg/advisor_insert_disallow_order_by_rand.goindex ea7f90066d..cd08e270b3 100644--- a/backend/plugin/advisor/pg/advisor_insert_disallow_order_by_rand.go+++ b/backend/plugin/advisor/pg/advisor_insert_disallow_order_by_rand.go@@ -38,7 +38,7 @@ func (*InsertDisallowOrderByRandAdvisor) Check(_ context.Context, checkCtx advis},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type insertDisallowOrderByRandRule struct {diff --git a/backend/plugin/advisor/pg/advisor_insert_must_specify_column.go b/backend/plugin/advisor/pg/advisor_insert_must_specify_column.goindex 573a31455b..143139b418 100644--- a/backend/plugin/advisor/pg/advisor_insert_must_specify_column.go+++ b/backend/plugin/advisor/pg/advisor_insert_must_specify_column.go@@ -37,7 +37,7 @@ func (*InsertMustSpecifyColumnAdvisor) Check(_ context.Context, checkCtx advisor},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type insertMustSpecifyColumnRule struct {diff --git a/backend/plugin/advisor/pg/advisor_insert_row_limit.go b/backend/plugin/advisor/pg/advisor_insert_row_limit.goindex ceb0dccbae..fbc561527f 100644--- a/backend/plugin/advisor/pg/advisor_insert_row_limit.go+++ b/backend/plugin/advisor/pg/advisor_insert_row_limit.go@@ -53,7 +53,7 @@ func (*InsertRowLimitAdvisor) Check(ctx context.Context, checkCtx advisor.ContexTenantMode: checkCtx.TenantMode,}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type insertRowLimitRule struct {diff --git a/backend/plugin/advisor/pg/advisor_migration_compatibility.go b/backend/plugin/advisor/pg/advisor_migration_compatibility.goindex 82a50cacbb..3c8c23b3c6 100644--- a/backend/plugin/advisor/pg/advisor_migration_compatibility.go+++ b/backend/plugin/advisor/pg/advisor_migration_compatibility.go@@ -37,7 +37,7 @@ func (*CompatibilityAdvisor) Check(_ context.Context, checkCtx advisor.Context)},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type compatibilityRule struct {diff --git a/backend/plugin/advisor/pg/advisor_naming_column.go b/backend/plugin/advisor/pg/advisor_naming_column.goindex 0bdbfc53c1..7eda100d37 100644--- a/backend/plugin/advisor/pg/advisor_naming_column.go+++ b/backend/plugin/advisor/pg/advisor_naming_column.go@@ -57,7 +57,7 @@ func (*NamingColumnConventionAdvisor) Check(_ context.Context, checkCtx advisor.maxLength: maxLength,}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type namingColumnConventionRule struct {diff --git a/backend/plugin/advisor/pg/advisor_naming_foreign_key_convention.go b/backend/plugin/advisor/pg/advisor_naming_foreign_key_convention.goindex e021031c81..c7b967e936 100644--- a/backend/plugin/advisor/pg/advisor_naming_foreign_key_convention.go+++ b/backend/plugin/advisor/pg/advisor_naming_foreign_key_convention.go@@ -62,7 +62,7 @@ func (*NamingFKConventionAdvisor) Check(_ context.Context, checkCtx advisor.ConttemplateList: templateList,}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type namingFKConventionRule struct {diff --git a/backend/plugin/advisor/pg/advisor_naming_fully_qualified.go b/backend/plugin/advisor/pg/advisor_naming_fully_qualified.goindex a9af61ee65..b51db73762 100644--- a/backend/plugin/advisor/pg/advisor_naming_fully_qualified.go+++ b/backend/plugin/advisor/pg/advisor_naming_fully_qualified.go@@ -39,7 +39,7 @@ func (*FullyQualifiedObjectNameAdvisor) Check(_ context.Context, checkCtx advisodbMetadata: checkCtx.DBSchema,}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type fullyQualifiedObjectNameRule struct {diff --git a/backend/plugin/advisor/pg/advisor_naming_index_convention.go b/backend/plugin/advisor/pg/advisor_naming_index_convention.goindex 7839088a99..435197ede1 100644--- a/backend/plugin/advisor/pg/advisor_naming_index_convention.go+++ b/backend/plugin/advisor/pg/advisor_naming_index_convention.go@@ -64,7 +64,7 @@ func (*NamingIndexConventionAdvisor) Check(_ context.Context, checkCtx advisor.CoriginalMetadata: checkCtx.OriginalMetadata,}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type namingIndexConventionRule struct {diff --git a/backend/plugin/advisor/pg/advisor_naming_primary_key_convention.go b/backend/plugin/advisor/pg/advisor_naming_primary_key_convention.goindex 7946b0a0c8..ada53597dc 100644--- a/backend/plugin/advisor/pg/advisor_naming_primary_key_convention.go+++ b/backend/plugin/advisor/pg/advisor_naming_primary_key_convention.go@@ -64,7 +64,7 @@ func (*NamingPKConventionAdvisor) Check(_ context.Context, checkCtx advisor.ContoriginalMetadata: checkCtx.OriginalMetadata,}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type namingPKConventionRule struct {diff --git a/backend/plugin/advisor/pg/advisor_naming_table.go b/backend/plugin/advisor/pg/advisor_naming_table.goindex 67f0d47c60..2e127b5454 100644--- a/backend/plugin/advisor/pg/advisor_naming_table.go+++ b/backend/plugin/advisor/pg/advisor_naming_table.go@@ -57,7 +57,7 @@ func (*NamingTableConventionAdvisor) Check(_ context.Context, checkCtx advisor.CmaxLength: maxLength,}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type namingTableConventionRule struct {diff --git a/backend/plugin/advisor/pg/advisor_naming_unique_key_convention.go b/backend/plugin/advisor/pg/advisor_naming_unique_key_convention.goindex f57f5e6659..30c56c9083 100644--- a/backend/plugin/advisor/pg/advisor_naming_unique_key_convention.go+++ b/backend/plugin/advisor/pg/advisor_naming_unique_key_convention.go@@ -64,7 +64,7 @@ func (*NamingUKConventionAdvisor) Check(_ context.Context, checkCtx advisor.ContoriginalMetadata: checkCtx.OriginalMetadata,}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type namingUKConventionRule struct {diff --git a/backend/plugin/advisor/pg/advisor_statement_add_check_not_valid.go b/backend/plugin/advisor/pg/advisor_statement_add_check_not_valid.goindex 3d446e496f..9e37a59028 100644--- a/backend/plugin/advisor/pg/advisor_statement_add_check_not_valid.go+++ b/backend/plugin/advisor/pg/advisor_statement_add_check_not_valid.go@@ -36,7 +36,7 @@ func (*StatementAddCheckNotValidAdvisor) Check(_ context.Context, checkCtx advis},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type statementAddCheckNotValidRule struct {diff --git a/backend/plugin/advisor/pg/advisor_statement_add_fk_not_valid.go b/backend/plugin/advisor/pg/advisor_statement_add_fk_not_valid.goindex 6e517fc82e..946368f14f 100644--- a/backend/plugin/advisor/pg/advisor_statement_add_fk_not_valid.go+++ b/backend/plugin/advisor/pg/advisor_statement_add_fk_not_valid.go@@ -36,7 +36,7 @@ func (*StatementAddFKNotValidAdvisor) Check(_ context.Context, checkCtx advisor.},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type statementAddFKNotValidRule struct {diff --git a/backend/plugin/advisor/pg/advisor_statement_affected_row_limit.go b/backend/plugin/advisor/pg/advisor_statement_affected_row_limit.goindex 87d4f47cdb..da898f917a 100644--- a/backend/plugin/advisor/pg/advisor_statement_affected_row_limit.go+++ b/backend/plugin/advisor/pg/advisor_statement_affected_row_limit.go@@ -54,7 +54,7 @@ func (*StatementAffectedRowLimitAdvisor) Check(ctx context.Context, checkCtx advtenantMode: checkCtx.TenantMode,}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type statementAffectedRowLimitRule struct {diff --git a/backend/plugin/advisor/pg/advisor_statement_check_set_role_variable.go b/backend/plugin/advisor/pg/advisor_statement_check_set_role_variable.goindex 6063b872f2..2641ebb79b 100644--- a/backend/plugin/advisor/pg/advisor_statement_check_set_role_variable.go+++ b/backend/plugin/advisor/pg/advisor_statement_check_set_role_variable.go@@ -34,7 +34,7 @@ func (*StatementCheckSetRoleVariable) Check(_ context.Context, checkCtx advisor.},}- advice := RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule})+ advice := RunRules(checkCtx.ParsedStatements, []OmniRule{rule})if !rule.hasSetRole {advice = append(advice, &storepb.Advice{diff --git a/backend/plugin/advisor/pg/advisor_statement_create_specify_schema.go b/backend/plugin/advisor/pg/advisor_statement_create_specify_schema.goindex 91b9f3615c..b8fea080ee 100644--- a/backend/plugin/advisor/pg/advisor_statement_create_specify_schema.go+++ b/backend/plugin/advisor/pg/advisor_statement_create_specify_schema.go@@ -34,7 +34,7 @@ func (*StatementCreateSpecifySchema) Check(_ context.Context, checkCtx advisor.C},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type statementCreateSpecifySchemaRule struct {diff --git a/backend/plugin/advisor/pg/advisor_statement_disallow_add_column_with_default.go b/backend/plugin/advisor/pg/advisor_statement_disallow_add_column_with_default.goindex 718ea86d1c..408d1e9f2f 100644--- a/backend/plugin/advisor/pg/advisor_statement_disallow_add_column_with_default.go+++ b/backend/plugin/advisor/pg/advisor_statement_disallow_add_column_with_default.go@@ -36,7 +36,7 @@ func (*StatementDisallowAddColumnWithDefaultAdvisor) Check(_ context.Context, ch},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type statementDisallowAddColumnWithDefaultRule struct {diff --git a/backend/plugin/advisor/pg/advisor_statement_disallow_add_not_null.go b/backend/plugin/advisor/pg/advisor_statement_disallow_add_not_null.goindex de9944977c..cfe096a90c 100644--- a/backend/plugin/advisor/pg/advisor_statement_disallow_add_not_null.go+++ b/backend/plugin/advisor/pg/advisor_statement_disallow_add_not_null.go@@ -37,7 +37,7 @@ func (*StatementDisallowAddNotNullAdvisor) Check(_ context.Context, checkCtx adv},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type statementDisallowAddNotNullRule struct {diff --git a/backend/plugin/advisor/pg/advisor_statement_disallow_commit.go b/backend/plugin/advisor/pg/advisor_statement_disallow_commit.goindex 94da383c79..6cfd7b842d 100644--- a/backend/plugin/advisor/pg/advisor_statement_disallow_commit.go+++ b/backend/plugin/advisor/pg/advisor_statement_disallow_commit.go@@ -37,7 +37,7 @@ func (*StatementDisallowCommitAdvisor) Check(_ context.Context, checkCtx advisor},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type statementDisallowCommitRule struct {diff --git a/backend/plugin/advisor/pg/advisor_statement_disallow_on_del_cascade.go b/backend/plugin/advisor/pg/advisor_statement_disallow_on_del_cascade.goindex 10b1b46f94..a9c539e236 100644--- a/backend/plugin/advisor/pg/advisor_statement_disallow_on_del_cascade.go+++ b/backend/plugin/advisor/pg/advisor_statement_disallow_on_del_cascade.go@@ -36,7 +36,7 @@ func (*StatementDisallowOnDelCascadeAdvisor) Check(_ context.Context, checkCtx a},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type statementDisallowOnDelCascadeRule struct {diff --git a/backend/plugin/advisor/pg/advisor_statement_disallow_rm_tbl_cascade.go b/backend/plugin/advisor/pg/advisor_statement_disallow_rm_tbl_cascade.goindex 6fe8034095..52d4790621 100644--- a/backend/plugin/advisor/pg/advisor_statement_disallow_rm_tbl_cascade.go+++ b/backend/plugin/advisor/pg/advisor_statement_disallow_rm_tbl_cascade.go@@ -36,7 +36,7 @@ func (*StatementDisallowRemoveTblCascadeAdvisor) Check(_ context.Context, checkC},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type statementDisallowRemoveTblCascadeRule struct {diff --git a/backend/plugin/advisor/pg/advisor_statement_disallow_truncate.go b/backend/plugin/advisor/pg/advisor_statement_disallow_truncate.goindex d754a8ae01..97e43b89c0 100644--- a/backend/plugin/advisor/pg/advisor_statement_disallow_truncate.go+++ b/backend/plugin/advisor/pg/advisor_statement_disallow_truncate.go@@ -27,7 +27,7 @@ func (*StatementDisallowTruncateAdvisor) Check(_ context.Context, checkCtx advisrule := &statementDisallowTruncateRule{OmniBaseRule: OmniBaseRule{Level: level, Title: checkCtx.Rule.Type.String()},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type statementDisallowTruncateRule struct {diff --git a/backend/plugin/advisor/pg/advisor_statement_dml_dry_run.go b/backend/plugin/advisor/pg/advisor_statement_dml_dry_run.goindex 315a85e785..3844ee9347 100644--- a/backend/plugin/advisor/pg/advisor_statement_dml_dry_run.go+++ b/backend/plugin/advisor/pg/advisor_statement_dml_dry_run.go@@ -53,7 +53,7 @@ func (*StatementDMLDryRunAdvisor) Check(ctx context.Context, checkCtx advisor.CotenantMode: checkCtx.TenantMode,}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type statementDMLDryRunRule struct {diff --git a/backend/plugin/advisor/pg/advisor_statement_merge_alter_table.go b/backend/plugin/advisor/pg/advisor_statement_merge_alter_table.goindex 0244b8ec43..5a293391c1 100644--- a/backend/plugin/advisor/pg/advisor_statement_merge_alter_table.go+++ b/backend/plugin/advisor/pg/advisor_statement_merge_alter_table.go@@ -39,7 +39,7 @@ func (*StatementMergeAlterTableAdvisor) Check(_ context.Context, checkCtx advisotableMap: make(tableMap),}- RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule})+ RunRules(checkCtx.ParsedStatements, []OmniRule{rule})return rule.generateAdvice(), nil}diff --git a/backend/plugin/advisor/pg/advisor_statement_no_leading_wildcard_like.go b/backend/plugin/advisor/pg/advisor_statement_no_leading_wildcard_like.goindex a25d062f80..59ce35e7ef 100644--- a/backend/plugin/advisor/pg/advisor_statement_no_leading_wildcard_like.go+++ b/backend/plugin/advisor/pg/advisor_statement_no_leading_wildcard_like.go@@ -38,7 +38,7 @@ func (*StatementNoLeadingWildcardLikeAdvisor) Check(_ context.Context, checkCtx},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type statementNoLeadingWildcardLikeRule struct {diff --git a/backend/plugin/advisor/pg/advisor_statement_no_select_all.go b/backend/plugin/advisor/pg/advisor_statement_no_select_all.goindex 94af67f950..1c10564268 100644--- a/backend/plugin/advisor/pg/advisor_statement_no_select_all.go+++ b/backend/plugin/advisor/pg/advisor_statement_no_select_all.go@@ -38,7 +38,7 @@ func (*NoSelectAllAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type noSelectAllRule struct {diff --git a/backend/plugin/advisor/pg/advisor_statement_non_transactional.go b/backend/plugin/advisor/pg/advisor_statement_non_transactional.goindex 755270140d..98d75b52f0 100644--- a/backend/plugin/advisor/pg/advisor_statement_non_transactional.go+++ b/backend/plugin/advisor/pg/advisor_statement_non_transactional.go@@ -37,7 +37,7 @@ func (*NonTransactionalAdvisor) Check(_ context.Context, checkCtx advisor.Contex},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type nonTransactionalRule struct {diff --git a/backend/plugin/advisor/pg/advisor_statement_object_owner_check.go b/backend/plugin/advisor/pg/advisor_statement_object_owner_check.goindex 142dafedcd..12226fdeee 100644--- a/backend/plugin/advisor/pg/advisor_statement_object_owner_check.go+++ b/backend/plugin/advisor/pg/advisor_statement_object_owner_check.go@@ -55,7 +55,7 @@ func (*StatementObjectOwnerCheckAdvisor) Check(ctx context.Context, checkCtx advcurrentRole: currentRole,}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type statementObjectOwnerCheckRule struct {diff --git a/backend/plugin/advisor/pg/advisor_statement_where_disallow_functions_and_calculations.go b/backend/plugin/advisor/pg/advisor_statement_where_disallow_functions_and_calculations.goindex 436b46f89a..4fdc7795c9 100644--- a/backend/plugin/advisor/pg/advisor_statement_where_disallow_functions_and_calculations.go+++ b/backend/plugin/advisor/pg/advisor_statement_where_disallow_functions_and_calculations.go@@ -52,7 +52,7 @@ func (*StatementWhereDisallowFunctionsAndCalculationsAdvisor) Check(_ context.Co// references when sync hasn't populated search_path.rule.searchPath = []string{"public"}}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type whereDisallowFuncPgRule struct {diff --git a/backend/plugin/advisor/pg/advisor_statement_where_required_select.go b/backend/plugin/advisor/pg/advisor_statement_where_required_select.goindex bd0f717c6f..27545b0978 100644--- a/backend/plugin/advisor/pg/advisor_statement_where_required_select.go+++ b/backend/plugin/advisor/pg/advisor_statement_where_required_select.go@@ -38,7 +38,7 @@ func (*StatementWhereRequiredSelectAdvisor) Check(_ context.Context, checkCtx ad},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type statementWhereRequiredSelectRule struct {diff --git a/backend/plugin/advisor/pg/advisor_statement_where_required_update_delete.go b/backend/plugin/advisor/pg/advisor_statement_where_required_update_delete.goindex 03846f48d4..81b89e78e8 100644--- a/backend/plugin/advisor/pg/advisor_statement_where_required_update_delete.go+++ b/backend/plugin/advisor/pg/advisor_statement_where_required_update_delete.go@@ -37,7 +37,7 @@ func (*StatementWhereRequiredUpdateDeleteAdvisor) Check(_ context.Context, check},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type statementWhereRequiredUpdateDeleteRule struct {diff --git a/backend/plugin/advisor/pg/advisor_table_disallow_partition.go b/backend/plugin/advisor/pg/advisor_table_disallow_partition.goindex eda8fcd40f..aba1f6f6f1 100644--- a/backend/plugin/advisor/pg/advisor_table_disallow_partition.go+++ b/backend/plugin/advisor/pg/advisor_table_disallow_partition.go@@ -37,7 +37,7 @@ func (*TableDisallowPartitionAdvisor) Check(_ context.Context, checkCtx advisor.},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type tableDisallowPartitionRule struct {diff --git a/backend/plugin/advisor/pg/advisor_table_drop_naming_convention.go b/backend/plugin/advisor/pg/advisor_table_drop_naming_convention.goindex 8f7082388e..70d3479874 100644--- a/backend/plugin/advisor/pg/advisor_table_drop_naming_convention.go+++ b/backend/plugin/advisor/pg/advisor_table_drop_naming_convention.go@@ -51,7 +51,7 @@ func (*TableDropNamingConventionAdvisor) Check(_ context.Context, checkCtx advisformat: format,}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type tableDropNamingConventionRule struct {diff --git a/backend/plugin/advisor/pg/advisor_table_no_fk.go b/backend/plugin/advisor/pg/advisor_table_no_fk.goindex 9e314829d7..f17fbb21e6 100644--- a/backend/plugin/advisor/pg/advisor_table_no_fk.go+++ b/backend/plugin/advisor/pg/advisor_table_no_fk.go@@ -37,7 +37,7 @@ func (*TableNoFKAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*},}- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil}type tableNoFKRule struct {diff --git a/backend/plugin/advisor/pg/advisor_table_require_pk.go b/backend/plugin/advisor/pg/advisor_table_require_pk.goindex 813d903254..27d31066a7 100644--- a/backend/plugin/advisor/pg/advisor_table_require_pk.go+++ b/backend/plugin/advisor/pg/advisor_table_require_pk.go@@ -51,7 +51,7 @@ func (*TableRequirePKAdvisor) Check(_ context.Context, checkCtx advisor.Context)tableMentions: make(map[string]*tableMention),}- // Manually iterate statements instead of using RunOmniRules because+ // Manually iterate statements instead of using RunRules because// validateFinalState must be called AFTER all statements have been processed.for _, stmt := range checkCtx.ParsedStatements {if stmt.AST == nil {diff --git a/backend/plugin/advisor/pg/generic_checker_omni.go b/backend/plugin/advisor/pg/generic_checker.gosimilarity index 96%rename from backend/plugin/advisor/pg/generic_checker_omni.gorename to backend/plugin/advisor/pg/generic_checker.goindex cc27413848..55d0fa5be5 100644--- a/backend/plugin/advisor/pg/generic_checker_omni.go+++ b/backend/plugin/advisor/pg/generic_checker.go@@ -124,9 +124,9 @@ func (r *OmniBaseRule) FindLineByName(name string) int32 {return pos.Line}-// RunOmniRules iterates over parsed statements and dispatches each omni AST node to all rules.+// RunRules iterates over parsed statements and dispatches each omni AST node to all rules.// Returns combined advice from all rules. Skips statements without omni AST.-func RunOmniRules(stmts []base.ParsedStatement, rules []OmniRule) []*storepb.Advice {+func RunRules(stmts []base.ParsedStatement, rules []OmniRule) []*storepb.Advice {for _, stmt := range stmts {if stmt.AST == nil {continuediff --git a/backend/plugin/advisor/pg/utils.go b/backend/plugin/advisor/pg/utils.goindex 00715f47da..76d0a0c1fd 100644--- a/backend/plugin/advisor/pg/utils.go+++ b/backend/plugin/advisor/pg/utils.go@@ -1,15 +1,15 @@package pgimport (+ "fmt""regexp""strconv""strings"+ "github.com/bytebase/omni/pg/ast""github.com/pkg/errors")-// getTemplateRegexp generates a regex pattern by replacing tokens in the template with actual values.-// Used by naming convention advisors to dynamically build patterns based on metadata.func getTemplateRegexp(template string, templateList []string, tokens map[string]string) (*regexp.Regexp, error) {for _, key := range templateList {if token, ok := tokens[key]; ok {@@ -68,3 +68,265 @@ func getAffectedRows(res []any) (int64, error) {}return value, nil}++// nolint:unused+// omniTableName extracts the table name from a RangeVar.+func omniTableName(rv *ast.RangeVar) string {+ if rv == nil {+ return ""+ }+ return rv.Relname+}++// nolint:unused+// omniSchemaName extracts the schema name from a RangeVar, defaulting to "public".+func omniSchemaName(rv *ast.RangeVar) string {+ if rv == nil || rv.Schemaname == "" {+ return "public"+ }+ return rv.Schemaname+}++// nolint:unused+// omniConstraintColumns extracts column names from a Constraint's Keys list.+func omniConstraintColumns(c *ast.Constraint) []string {+ if c == nil || c.Keys == nil {+ return nil+ }+ var cols []string+ for _, item := range c.Keys.Items {+ if s, ok := item.(*ast.String); ok {+ cols = append(cols, s.Str)+ }+ }+ return cols+}++// nolint:unused+// omniColumnConstraints iterates over a ColumnDef's constraint list.+func omniColumnConstraints(col *ast.ColumnDef) []*ast.Constraint {+ if col == nil || col.Constraints == nil {+ return nil+ }+ var result []*ast.Constraint+ for _, item := range col.Constraints.Items {+ if c, ok := item.(*ast.Constraint); ok {+ result = append(result, c)+ }+ }+ return result+}++// nolint:unused+// omniTableElements iterates over a CreateStmt's table elements,+// returning column defs and table constraints separately.+func omniTableElements(create *ast.CreateStmt) ([]*ast.ColumnDef, []*ast.Constraint) {+ if create.TableElts == nil {+ return nil, nil+ }+ var cols []*ast.ColumnDef+ var cons []*ast.Constraint+ for _, item := range create.TableElts.Items {+ switch n := item.(type) {+ case *ast.ColumnDef:+ cols = append(cols, n)+ case *ast.Constraint:+ cons = append(cons, n)+ default:+ }+ }+ return cols, cons+}++// nolint:unused+// omniAlterTableCmds extracts AlterTableCmd items from an AlterTableStmt.+func omniAlterTableCmds(alter *ast.AlterTableStmt) []*ast.AlterTableCmd {+ if alter.Cmds == nil {+ return nil+ }+ var cmds []*ast.AlterTableCmd+ for _, item := range alter.Cmds.Items {+ if cmd, ok := item.(*ast.AlterTableCmd); ok {+ cmds = append(cmds, cmd)+ }+ }+ return cmds+}++// nolint:unused+// omniIsRoleOrSearchPathSet checks if a VariableSetStmt is SET ROLE or SET search_path.+func omniIsRoleOrSearchPathSet(stmt *ast.VariableSetStmt) bool {+ if stmt == nil {+ return false+ }+ name := strings.ToLower(stmt.Name)+ return name == "role" || name == "search_path"+}++// nolint:unused+// omniTypeName extracts the type name string from a TypeName node.+func omniTypeName(tn *ast.TypeName) string {+ if tn == nil || tn.Names == nil {+ return ""+ }+ var parts []string+ for _, item := range tn.Names.Items {+ if s, ok := item.(*ast.String); ok {+ parts = append(parts, s.Str)+ }+ }+ if len(parts) > 0 {+ return parts[len(parts)-1]+ }+ return ""+}++// omniTypeNameFull extracts the full type name with modifiers from a TypeName node.+// For example, "character varying(20)" instead of just "character varying".+func omniTypeNameFull(tn *ast.TypeName) string {+ name := omniTypeName(tn)+ if name == "" {+ return ""+ }+ if tn.Typmods != nil && len(tn.Typmods.Items) > 0 {+ var mods []string+ for _, item := range tn.Typmods.Items {+ switch v := item.(type) {+ case *ast.Integer:+ mods = append(mods, fmt.Sprintf("%d", v.Ival))+ case *ast.A_Const:+ if iv, ok := v.Val.(*ast.Integer); ok {+ mods = append(mods, fmt.Sprintf("%d", iv.Ival))+ }+ default:+ }+ }+ if len(mods) > 0 {+ name += "(" + strings.Join(mods, ",") + ")"+ }+ }+ if tn.ArrayBounds != nil && len(tn.ArrayBounds.Items) > 0 {+ name += "[]"+ }+ return name+}++// omniListStrings extracts string values from an ast.List.+func omniListStrings(list *ast.List) []string {+ if list == nil {+ return nil+ }+ var result []string+ for _, item := range list.Items {+ if s, ok := item.(*ast.String); ok {+ result = append(result, s.Str)+ }+ }+ return result+}++// omniIndexColumns extracts column names from an IndexStmt's IndexParams list.+func omniIndexColumns(idx *ast.IndexStmt) []string {+ if idx == nil || idx.IndexParams == nil {+ return nil+ }+ var cols []string+ for _, item := range idx.IndexParams.Items {+ if elem, ok := item.(*ast.IndexElem); ok && elem.Name != "" {+ cols = append(cols, elem.Name)+ }+ }+ return cols+}++// omniDropObjectNames extracts object names from a DropStmt.+// Returns list of qualified name string slices.+func omniDropObjectNames(drop *ast.DropStmt) [][]string {+ if drop.Objects == nil {+ return nil+ }+ var result [][]string+ for _, item := range drop.Objects.Items {+ list, ok := item.(*ast.List)+ if !ok {+ continue+ }+ var parts []string+ for _, nameItem := range list.Items {+ if s, ok := nameItem.(*ast.String); ok {+ parts = append(parts, s.Str)+ }+ }+ if len(parts) > 0 {+ result = append(result, parts)+ }+ }+ return result+}++// omniCollectFromClauseRangeVars recursively collects RangeVar nodes from a FROM clause list.+func omniCollectFromClauseRangeVars(fromClause *ast.List) []*ast.RangeVar {+ if fromClause == nil {+ return nil+ }+ var result []*ast.RangeVar+ for _, item := range fromClause.Items {+ result = append(result, omniCollectRangeVars(item)...)+ }+ return result+}++// omniCollectRangeVars recursively collects RangeVar nodes from a node,+// including those inside subqueries.+func omniCollectRangeVars(node ast.Node) []*ast.RangeVar {+ if node == nil {+ return nil+ }+ switch n := node.(type) {+ case *ast.RangeVar:+ return []*ast.RangeVar{n}+ case *ast.JoinExpr:+ var result []*ast.RangeVar+ result = append(result, omniCollectRangeVars(n.Larg)...)+ result = append(result, omniCollectRangeVars(n.Rarg)...)+ return result+ case *ast.RangeSubselect:+ // Recurse into subquery+ if sel, ok := n.Subquery.(*ast.SelectStmt); ok {+ return omniCollectFromClauseRangeVars(sel.FromClause)+ }+ return nil+ default:+ return nil+ }+}++// nolint:unused+// omniDropObjects extracts object names from a DropStmt.+// Returns list of (schema, name) pairs.+func omniDropObjects(drop *ast.DropStmt) [][2]string {+ if drop.Objects == nil {+ return nil+ }+ var result [][2]string+ for _, item := range drop.Objects.Items {+ list, ok := item.(*ast.List)+ if !ok {+ continue+ }+ var parts []string+ for _, nameItem := range list.Items {+ if s, ok := nameItem.(*ast.String); ok {+ parts = append(parts, s.Str)+ }+ }+ switch len(parts) {+ case 1:+ result = append(result, [2]string{"public", parts[0]})+ case 2:+ result = append(result, [2]string{parts[0], parts[1]})+ default:+ }+ }+ return result+}diff --git a/backend/plugin/advisor/pg/utils_omni.go b/backend/plugin/advisor/pg/utils_omni.godeleted file mode 100644index ec3ff4986c..0000000000--- a/backend/plugin/advisor/pg/utils_omni.go+++ /dev/null@@ -1,270 +0,0 @@-package pg--import (- "fmt"- "strings"-- "github.com/bytebase/omni/pg/ast"-)--// nolint:unused-// omniTableName extracts the table name from a RangeVar.-func omniTableName(rv *ast.RangeVar) string {- if rv == nil {- return ""- }- return rv.Relname-}--// nolint:unused-// omniSchemaName extracts the schema name from a RangeVar, defaulting to "public".-func omniSchemaName(rv *ast.RangeVar) string {- if rv == nil || rv.Schemaname == "" {- return "public"- }- return rv.Schemaname-}--// nolint:unused-// omniConstraintColumns extracts column names from a Constraint's Keys list.-func omniConstraintColumns(c *ast.Constraint) []string {- if c == nil || c.Keys == nil {- return nil- }- var cols []string- for _, item := range c.Keys.Items {- if s, ok := item.(*ast.String); ok {- cols = append(cols, s.Str)- }- }- return cols-}--// nolint:unused-// omniColumnConstraints iterates over a ColumnDef's constraint list.-func omniColumnConstraints(col *ast.ColumnDef) []*ast.Constraint {- if col == nil || col.Constraints == nil {- return nil- }- var result []*ast.Constraint- for _, item := range col.Constraints.Items {- if c, ok := item.(*ast.Constraint); ok {- result = append(result, c)- }- }- return result-}--// nolint:unused-// omniTableElements iterates over a CreateStmt's table elements,-// returning column defs and table constraints separately.-func omniTableElements(create *ast.CreateStmt) ([]*ast.ColumnDef, []*ast.Constraint) {- if create.TableElts == nil {- return nil, nil- }- var cols []*ast.ColumnDef- var cons []*ast.Constraint- for _, item := range create.TableElts.Items {- switch n := item.(type) {- case *ast.ColumnDef:- cols = append(cols, n)- case *ast.Constraint:- cons = append(cons, n)- default:- }- }- return cols, cons-}--// nolint:unused-// omniAlterTableCmds extracts AlterTableCmd items from an AlterTableStmt.-func omniAlterTableCmds(alter *ast.AlterTableStmt) []*ast.AlterTableCmd {- if alter.Cmds == nil {- return nil- }- var cmds []*ast.AlterTableCmd- for _, item := range alter.Cmds.Items {- if cmd, ok := item.(*ast.AlterTableCmd); ok {- cmds = append(cmds, cmd)- }- }- return cmds-}--// nolint:unused-// omniIsRoleOrSearchPathSet checks if a VariableSetStmt is SET ROLE or SET search_path.-func omniIsRoleOrSearchPathSet(stmt *ast.VariableSetStmt) bool {- if stmt == nil {- return false- }- name := strings.ToLower(stmt.Name)- return name == "role" || name == "search_path"-}--// nolint:unused-// omniTypeName extracts the type name string from a TypeName node.-func omniTypeName(tn *ast.TypeName) string {- if tn == nil || tn.Names == nil {- return ""- }- var parts []string- for _, item := range tn.Names.Items {- if s, ok := item.(*ast.String); ok {- parts = append(parts, s.Str)- }- }- if len(parts) > 0 {- return parts[len(parts)-1]- }- return ""-}--// omniTypeNameFull extracts the full type name with modifiers from a TypeName node.-// For example, "character varying(20)" instead of just "character varying".-func omniTypeNameFull(tn *ast.TypeName) string {- name := omniTypeName(tn)- if name == "" {- return ""- }- if tn.Typmods != nil && len(tn.Typmods.Items) > 0 {- var mods []string- for _, item := range tn.Typmods.Items {- switch v := item.(type) {- case *ast.Integer:- mods = append(mods, fmt.Sprintf("%d", v.Ival))- case *ast.A_Const:- if iv, ok := v.Val.(*ast.Integer); ok {- mods = append(mods, fmt.Sprintf("%d", iv.Ival))- }- default:- }- }- if len(mods) > 0 {- name += "(" + strings.Join(mods, ",") + ")"- }- }- if tn.ArrayBounds != nil && len(tn.ArrayBounds.Items) > 0 {- name += "[]"- }- return name-}--// omniListStrings extracts string values from an ast.List.-func omniListStrings(list *ast.List) []string {- if list == nil {- return nil- }- var result []string- for _, item := range list.Items {- if s, ok := item.(*ast.String); ok {- result = append(result, s.Str)- }- }- return result-}--// omniIndexColumns extracts column names from an IndexStmt's IndexParams list.-func omniIndexColumns(idx *ast.IndexStmt) []string {- if idx == nil || idx.IndexParams == nil {- return nil- }- var cols []string- for _, item := range idx.IndexParams.Items {- if elem, ok := item.(*ast.IndexElem); ok && elem.Name != "" {- cols = append(cols, elem.Name)- }- }- return cols-}--// omniDropObjectNames extracts object names from a DropStmt.-// Returns list of qualified name string slices.-func omniDropObjectNames(drop *ast.DropStmt) [][]string {- if drop.Objects == nil {- return nil- }- var result [][]string- for _, item := range drop.Objects.Items {- list, ok := item.(*ast.List)- if !ok {- continue- }- var parts []string- for _, nameItem := range list.Items {- if s, ok := nameItem.(*ast.String); ok {- parts = append(parts, s.Str)- }- }- if len(parts) > 0 {- result = append(result, parts)- }- }- return result-}--// omniCollectFromClauseRangeVars recursively collects RangeVar nodes from a FROM clause list.-func omniCollectFromClauseRangeVars(fromClause *ast.List) []*ast.RangeVar {- if fromClause == nil {- return nil- }- var result []*ast.RangeVar- for _, item := range fromClause.Items {- result = append(result, omniCollectRangeVars(item)...)- }- return result-}--// omniCollectRangeVars recursively collects RangeVar nodes from a node,-// including those inside subqueries.-func omniCollectRangeVars(node ast.Node) []*ast.RangeVar {- if node == nil {- return nil- }- switch n := node.(type) {- case *ast.RangeVar:- return []*ast.RangeVar{n}- case *ast.JoinExpr:- var result []*ast.RangeVar- result = append(result, omniCollectRangeVars(n.Larg)...)- result = append(result, omniCollectRangeVars(n.Rarg)...)- return result- case *ast.RangeSubselect:- // Recurse into subquery- if sel, ok := n.Subquery.(*ast.SelectStmt); ok {- return omniCollectFromClauseRangeVars(sel.FromClause)- }- return nil- default:- return nil- }-}--// nolint:unused-// omniDropObjects extracts object names from a DropStmt.-// Returns list of (schema, name) pairs.-func omniDropObjects(drop *ast.DropStmt) [][2]string {- if drop.Objects == nil {- return nil- }- var result [][2]string- for _, item := range drop.Objects.Items {- list, ok := item.(*ast.List)- if !ok {- continue- }- var parts []string- for _, nameItem := range list.Items {- if s, ok := nameItem.(*ast.String); ok {- parts = append(parts, s.Str)- }- }- switch len(parts) {- case 1:- result = append(result, [2]string{"public", parts[0]})- case 2:- result = append(result, [2]string{parts[0], parts[1]})- default:- }- }- return result-}diff --git a/backend/plugin/advisor/tidb/utils.go b/backend/plugin/advisor/tidb/utils.goindex cd3ade5872..b779991dc5 100644--- a/backend/plugin/advisor/tidb/utils.go+++ b/backend/plugin/advisor/tidb/utils.go@@ -484,7 +484,7 @@ func omniCharLength(dt *omniast.DataType) int {// defensive alias even though omni pre-normalizes INTEGER → INT per// cumulative #7). Cumulative #20 documents the TINYINT/BOOLEAN split.//-// NOTE: this diverges from `mysql/utils_omni.go`'s `omniIsIntegerType`,+// NOTE: this diverges from `mysql/utils.go`'s `omniIsIntegerType`,// which currently omits "BOOLEAN". Pre-omni mysql ANTLR did not treat// BOOL as TINYINT — that's a long-standing mysql behavior gap, NOT a// regression introduced by mysql's omni migration. Out of scope here.@@ -527,7 +527,7 @@ func omniConstraintAdviceName(c *omniast.Constraint) string {// omniDataTypeNameCompact returns a compact, lowercase type-name string// for use in advice content + allowlist comparisons. Mirrors the mysql-// helper of the same name (mysql/utils_omni.go). Length/scale info is+// helper of the same name (mysql/utils.go). Length/scale info is// intentionally omitted — pingcap's `tidbparser.TypeString` and the// canonical fixture rendering both elide it (e.g. `varchar(5)` → "varchar").func omniDataTypeNameCompact(dt *omniast.DataType) string {diff --git a/backend/plugin/db/mssql/stmt_type.go b/backend/plugin/db/mssql/stmt_type.goindex 28716ca6fe..37b9653799 100644--- a/backend/plugin/db/mssql/stmt_type.go+++ b/backend/plugin/db/mssql/stmt_type.go@@ -16,7 +16,7 @@ const ()func getStmtType(stmt string) (stmtType, error) {- stmts, err := parser.ParseTSQLOmni(stmt)+ stmts, err := parser.ParseTSQL(stmt)if err != nil {return stmtTypeUnknown, err}diff --git a/backend/plugin/db/mysql/query.go b/backend/plugin/db/mysql/query.goindex ab2558c114..3efcd65371 100644--- a/backend/plugin/db/mysql/query.go+++ b/backend/plugin/db/mysql/query.go@@ -102,7 +102,7 @@ func getStatementWithResultLimitInline(statement string, limitCount int) (stringreturn "", errors.New("empty statement")}- list, err := mysqlparser.ParseMySQLOmni(statement)+ list, err := mysqlparser.ParseMySQL(statement)if err != nil {if stmt, procedureErr := rewriteMySQLSelectProcedureLimit(statement, limitCount); procedureErr == nil {return stmt, nildiff --git a/backend/plugin/db/mysql/stats.go b/backend/plugin/db/mysql/stats.goindex 2c74228aa8..afe6db5da7 100644--- a/backend/plugin/db/mysql/stats.go+++ b/backend/plugin/db/mysql/stats.go@@ -111,7 +111,7 @@ func capAffectedRowsByLimit(count int64, statement string) int64 {}func affectedRowsLimit(statement string) (int64, bool) {- list, err := mysqlparser.ParseMySQLOmni(statement)+ list, err := mysqlparser.ParseMySQL(statement)if err != nil || list == nil || len(list.Items) != 1 {return 0, false}diff --git a/backend/plugin/db/oracle/query.go b/backend/plugin/db/oracle/query.goindex 718d9b8d1f..bc9586df95 100644--- a/backend/plugin/db/oracle/query.go+++ b/backend/plugin/db/oracle/query.go@@ -223,7 +223,7 @@ func addLimitFor12cAndLater(statement string, limit int) string {// addFetchNextClause adds a FETCH NEXT clause to a SELECT statement using AST parsing.// This provides more precise placement of the limit clause compared to simple string wrapping.func addFetchNextClause(statement string, limitCount int) (string, error) {- list, err := plsqlparser.ParsePLSQLOmni(statement)+ list, err := plsqlparser.ParsePLSQL(statement)if err != nil {return "", err}@@ -346,7 +346,7 @@ func trimOracleLocSpace(sql string, loc oracleast.Loc) oracleast.Loc {// For Oracle, we think the statement like "SELECT xxx FROM DUAL" does not need a limit clause.// More details, xxx can not be a subquery.func skipAddLimit(stmt string) (bool, error) {- list, err := plsqlparser.ParsePLSQLOmni(stmt)+ list, err := plsqlparser.ParsePLSQL(stmt)if err != nil {return false, err}diff --git a/backend/plugin/db/oracle/query_test.go b/backend/plugin/db/oracle/query_test.goindex 6f3b1b315e..c3bd7ccfe1 100644--- a/backend/plugin/db/oracle/query_test.go+++ b/backend/plugin/db/oracle/query_test.go@@ -157,7 +157,7 @@ func TestAddLimitFor12cAndLaterRegressionClauseOrder(t *testing.T) {require.Equal(t, tc.want, got)assertSubstringsInOrder(t, got, tc.clausesInOrder)if tc.validateParse {- _, err := plsqlparser.ParsePLSQLOmni(got)+ _, err := plsqlparser.ParsePLSQL(got)require.NoError(t, err, "rewritten SQL should remain parseable: %s", got)}})diff --git a/backend/plugin/parser/mariadb/diagnose.go b/backend/plugin/parser/mariadb/diagnose.goindex efc7a82cf2..6bcf474c9d 100644--- a/backend/plugin/parser/mariadb/diagnose.go+++ b/backend/plugin/parser/mariadb/diagnose.go@@ -34,7 +34,7 @@ func parseMariaDBStatement(statement string) *base.SyntaxError {statement += ";"}- _, err := ParseMariaDBOmni(statement)+ _, err := ParseMariaDB(statement)if err == nil {return nil}diff --git a/backend/plugin/parser/mariadb/omni.go b/backend/plugin/parser/mariadb/omni.goindex 40aaa956d4..d076a3d567 100644--- a/backend/plugin/parser/mariadb/omni.go+++ b/backend/plugin/parser/mariadb/omni.go@@ -9,8 +9,8 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store")-// ParseMariaDBOmni parses SQL using omni's MariaDB parser and returns an ast.List.-func ParseMariaDBOmni(sql string) (*ast.List, error) {+// ParseMariaDB parses SQL using omni's MariaDB parser and returns an ast.List.+func ParseMariaDB(sql string) (*ast.List, error) {return mariadbparser.Parse(sql)}diff --git a/backend/plugin/parser/mysql/backup.go b/backend/plugin/parser/mysql/backup.goindex 31f01cc264..431d80eb1a 100644--- a/backend/plugin/parser/mysql/backup.go+++ b/backend/plugin/parser/mysql/backup.go@@ -81,7 +81,7 @@ func prepareTransformation(databaseName, statement string, dbMetadata *model.Datcontinue}- parsed, err := ParseMySQLOmni(item.Text)+ parsed, err := ParseMySQL(item.Text)if err != nil {return nil, errors.Wrap(err, "failed to parse sql")}@@ -308,7 +308,7 @@ func parseCTEPrefix(fullSQL string, stmtLoc ast.Loc) []*ast.CommonTableExpr {return nil}// Wrap the prefix with a dummy SELECT to make it parseable.- parsed, err := ParseMySQLOmni(prefix + " SELECT 1")+ parsed, err := ParseMySQL(prefix + " SELECT 1")if err != nil || parsed == nil {return nil}diff --git a/backend/plugin/parser/mysql/completion.go b/backend/plugin/parser/mysql/completion.goindex c49ebedc78..fcda9dece0 100644--- a/backend/plugin/parser/mysql/completion.go+++ b/backend/plugin/parser/mysql/completion.go@@ -623,7 +623,7 @@ func (c *Completer) extractCTETables(pos int) []*base.VirtualTableReference {} else {wrappedSQL = followingText + suffix}- parsed, err := ParseMySQLOmni(wrappedSQL)+ parsed, err := ParseMySQL(wrappedSQL)if err != nil || parsed == nil || len(parsed.Items) == 0 {continue}@@ -956,7 +956,7 @@ func (c *Completer) parseTableReferences(fromClause string) {} else {wrappedSQL = prefix + fromClause}- parsed, err := ParseMySQLOmni(wrappedSQL)+ parsed, err := ParseMySQL(wrappedSQL)if err != nil || parsed == nil || len(parsed.Items) == 0 {continue}diff --git a/backend/plugin/parser/mysql/diagnose.go b/backend/plugin/parser/mysql/diagnose.goindex e3c791cefe..23f96480a2 100644--- a/backend/plugin/parser/mysql/diagnose.go+++ b/backend/plugin/parser/mysql/diagnose.go@@ -36,7 +36,7 @@ func parseMySQLStatement(statement string) *base.SyntaxError {statement += ";"}- _, err := ParseMySQLOmni(statement)+ _, err := ParseMySQL(statement)if err == nil {return nil}diff --git a/backend/plugin/parser/mysql/mysql.go b/backend/plugin/parser/mysql/mysql.goindex 33627387d2..e6f261b100 100644--- a/backend/plugin/parser/mysql/mysql.go+++ b/backend/plugin/parser/mysql/mysql.go@@ -34,7 +34,7 @@ func parseMySQLStatements(statement string) ([]base.ParsedStatement, error) {continue}- list, omniErr := ParseMySQLOmni(stmt.Text)+ list, omniErr := ParseMySQL(stmt.Text)if omniErr != nil {return nil, convertOmniError(omniErr, stmt)}diff --git a/backend/plugin/parser/mysql/omni.go b/backend/plugin/parser/mysql/omni.goindex d229651276..fb0312dde6 100644--- a/backend/plugin/parser/mysql/omni.go+++ b/backend/plugin/parser/mysql/omni.go@@ -25,9 +25,9 @@ func (a *OmniAST) ASTStartPosition() *storepb.Position {return a.StartPosition}-// ParseMySQLOmni parses SQL using omni's parser and returns an ast.List.+// ParseMySQL parses SQL using omni's parser and returns an ast.List.// This is the recommended entry point for new code that needs omni AST nodes.-func ParseMySQLOmni(sql string) (*ast.List, error) {+func ParseMySQL(sql string) (*ast.List, error) {return mysqlparser.Parse(sql)}diff --git a/backend/plugin/parser/mysql/query.go b/backend/plugin/parser/mysql/query.goindex ad825301a9..749ee1a2f7 100644--- a/backend/plugin/parser/mysql/query.go+++ b/backend/plugin/parser/mysql/query.go@@ -17,7 +17,7 @@ func init() {// Only SELECT, EXPLAIN, SHOW, SET, and DESCRIBE are allowed in read-only mode.// EXPLAIN ANALYZE is treated as non-read-only since it actually executes the query.func validateQuery(statement string) (bool, bool, error) {- stmts, err := ParseMySQLOmni(statement)+ stmts, err := ParseMySQL(statement)if err != nil {return false, false, convertOmniError(err, base.Statement{Text: statement})}diff --git a/backend/plugin/parser/mysql/query_span_extractor.go b/backend/plugin/parser/mysql/query_span_extractor.goindex 0b902424d1..2300671117 100644--- a/backend/plugin/parser/mysql/query_span_extractor.go+++ b/backend/plugin/parser/mysql/query_span_extractor.go@@ -2,8 +2,10 @@ package mysqlimport ("context"+ "strconv""strings"+ "github.com/bytebase/omni/mysql/ast""github.com/pkg/errors"storepb "github.com/bytebase/bytebase/backend/generated-go/store"@@ -11,8 +13,6 @@ import ("github.com/bytebase/bytebase/backend/store/model")-// querySpanExtractor contains shared query-span state and metadata helpers.-// MySQL query-span extraction itself is omni-backed in query_span_extractor_omni.go.type querySpanExtractor struct {ctx context.ContextdefaultDatabase string@@ -381,3 +381,1451 @@ func isSystemResource(resource base.ColumnResource, ignoreCaseSensitive bool) bo}return onDiskSystemDatabases[database]}++// omniQuerySpanExtractor extracts query span information from omni MySQL AST.+// It embeds querySpanExtractor so shared metadata and identifier-resolution+// helpers can be reused as the omni implementation grows.+type omniQuerySpanExtractor struct {+ *querySpanExtractor+ source string+}++func newOmniQuerySpanExtractor(defaultDatabase string, gCtx base.GetQuerySpanContext, ignoreCaseSensitive bool) *omniQuerySpanExtractor {+ return &omniQuerySpanExtractor{+ querySpanExtractor: newQuerySpanExtractor(defaultDatabase, gCtx, ignoreCaseSensitive),+ }+}++// getOmniQuerySpan is the package-internal omni entry point used by migration+// tests and the production MySQL query-span path after cutover.+func (q *omniQuerySpanExtractor) getOmniQuerySpan(ctx context.Context, statement string) (*base.QuerySpan, error) {+ q.ctx = ctx+ q.source = statement++ stmts, err := ParseMySQL(statement)+ if err != nil {+ return nil, err+ }+ if stmts == nil || len(stmts.Items) == 0 {+ return &base.QuerySpan{+ Type: base.Select,+ SourceColumns: base.SourceColumnSet{},+ Results: []base.QuerySpanResult{},+ PredicateColumns: base.SourceColumnSet{},+ }, nil+ }+ if len(stmts.Items) != 1 {+ return nil, errors.Errorf("expected exactly 1 statement, got %d", len(stmts.Items))+ }++ root := stmts.Items[0]+ accessTables := collectOmniAccessTables(root, q.defaultDatabase, q.gCtx.Engine == storepb.Engine_STARROCKS)+ allSystems, mixed := isMixedQuery(accessTables, q.ignoreCaseSensitive)+ if mixed {+ return nil, base.MixUserSystemTablesError+ }++ queryType := classifyOmniQueryType(root, allSystems, q.source)+ if allSystems {+ accessTables = base.SourceColumnSet{}+ }+ resultSourceColumns := accessTables+ if queryType != base.Select {+ resultSourceColumns = base.SourceColumnSet{}+ }++ var results []base.QuerySpanResult+ if queryType == base.Select {+ tableSource, err := q.extractOmniSelectRoot(root)+ if err != nil {+ var resourceNotFound *base.ResourceNotFoundError+ if errors.As(err, &resourceNotFound) {+ return &base.QuerySpan{+ Type: base.Select,+ SourceColumns: accessTables,+ Results: []base.QuerySpanResult{},+ PredicateColumns: base.SourceColumnSet{},+ NotFoundError: resourceNotFound,+ }, nil+ }+ return nil, err+ }+ results = tableSource.GetQuerySpanResult()+ }+ return &base.QuerySpan{+ Type: queryType,+ SourceColumns: resultSourceColumns,+ Results: results,+ PredicateColumns: base.SourceColumnSet{},+ }, nil+}++func (q *omniQuerySpanExtractor) extractOmniSelectRoot(root ast.Node) (*base.PseudoTable, error) {+ switch n := root.(type) {+ case *ast.SelectStmt:+ return q.extractOmniSelectStmt(n)+ case *ast.ExplainStmt:+ return &base.PseudoTable{}, nil+ case *ast.TableStmt:+ return q.extractOmniTableStmt(n)+ case *ast.ValuesStmt:+ return q.extractOmniValuesStmt(n)+ default:+ return &base.PseudoTable{}, nil+ }+}++func (q *omniQuerySpanExtractor) extractOmniSelectStmt(stmt *ast.SelectStmt) (*base.PseudoTable, error) {+ if stmt == nil {+ return &base.PseudoTable{}, nil+ }+ if stmt.Into != nil {+ return nil, errors.New("meet unsupported select statement with into")+ }++ originalTableSourceFrom := q.tableSourceFrom+ originalPriorLength := len(q.priorTableInFrom)+ originalCTELength := len(q.ctes)+ defer func() {+ q.tableSourceFrom = originalTableSourceFrom+ q.priorTableInFrom = q.priorTableInFrom[:originalPriorLength]+ q.ctes = q.ctes[:originalCTELength]+ }()++ if err := q.processOmniCTEs(stmt.CTEs); err != nil {+ return nil, err+ }+ if inner := stmt.ParenSource; inner != nil {+ return q.extractOmniSelectStmt(inner)+ }+ if tableStmt := stmt.TableSource; tableStmt != nil {+ return q.extractOmniTableStmt(tableStmt)+ }+ if valuesStmt := stmt.ValuesSource; valuesStmt != nil {+ return q.extractOmniValuesStmt(valuesStmt)+ }+ if stmt.SetOp != ast.SetOpNone {+ return q.extractOmniSetOp(stmt)+ }++ fromSources, err := q.extractOmniTableSources(stmt.From)+ if err != nil {+ return nil, err+ }+ q.tableSourceFrom = append(q.tableSourceFrom, fromSources...)++ results, err := q.extractOmniTargetList(stmt.TargetList, fromSources)+ if err != nil {+ return nil, err+ }+ return &base.PseudoTable{+ Columns: results,+ }, nil+}++func (q *omniQuerySpanExtractor) extractOmniTableStmt(stmt *ast.TableStmt) (*base.PseudoTable, error) {+ if stmt == nil || stmt.Table == nil {+ return &base.PseudoTable{}, nil+ }+ if stmt.Into != nil {+ return nil, errors.New("meet unsupported table statement with into")+ }+ tableSource, err := q.findTableSchema(stmt.Table.Schema, stmt.Table.Name)+ if err != nil {+ return nil, err+ }+ return &base.PseudoTable{Columns: tableSource.GetQuerySpanResult()}, nil+}++func (q *omniQuerySpanExtractor) extractOmniValuesStmt(stmt *ast.ValuesStmt) (*base.PseudoTable, error) {+ if stmt == nil || len(stmt.Rows) == 0 {+ return &base.PseudoTable{}, nil+ }+ var columns []base.QuerySpanResult+ for _, expr := range stmt.Rows[0] {+ field, err := q.extractOmniExpr(expr)+ if err != nil {+ return nil, err+ }+ columns = append(columns, field)+ }+ return &base.PseudoTable{Columns: columns}, nil+}++func (q *omniQuerySpanExtractor) extractOmniSetOp(stmt *ast.SelectStmt) (*base.PseudoTable, error) {+ if stmt == nil || stmt.SetOp == ast.SetOpNone {+ return q.extractOmniSelectStmt(stmt)+ }+ left, err := q.extractOmniSelectStmt(stmt.Left)+ if err != nil {+ return nil, err+ }+ right, err := q.extractOmniSelectStmt(stmt.Right)+ if err != nil {+ return nil, err+ }+ leftResults := left.GetQuerySpanResult()+ rightResults := right.GetQuerySpanResult()+ if len(leftResults) != len(rightResults) {+ return nil, errors.Errorf("MySQL UNION operator left has %d fields, right has %d fields", len(leftResults), len(rightResults))+ }+ results := make([]base.QuerySpanResult, 0, len(leftResults))+ for i := range leftResults {+ sourceColumns, _ := base.MergeSourceColumnSet(leftResults[i].SourceColumns, rightResults[i].SourceColumns)+ results = append(results, base.QuerySpanResult{+ Name: leftResults[i].Name,+ SourceColumns: sourceColumns,+ IsPlainField: false,+ })+ }+ return &base.PseudoTable{Columns: results}, nil+}++func (q *omniQuerySpanExtractor) processOmniCTEs(ctes []*ast.CommonTableExpr) error {+ for _, cte := range ctes {+ tableSource, err := q.extractOmniCTE(cte)+ if err != nil {+ return err+ }+ if tableSource != nil {+ q.ctes = append(q.ctes, tableSource)+ }+ }+ return nil+}++func (q *omniQuerySpanExtractor) extractOmniCTE(cte *ast.CommonTableExpr) (*base.PseudoTable, error) {+ if cte == nil {+ return nil, nil+ }+ if cte.Recursive {+ return q.extractOmniRecursiveCTE(cte)+ }+ return q.extractOmniNonRecursiveCTE(cte)+}++func (q *omniQuerySpanExtractor) extractOmniNonRecursiveCTE(cte *ast.CommonTableExpr) (*base.PseudoTable, error) {+ tableSource, err := q.extractOmniSelectStmt(cte.Select)+ if err != nil {+ return nil, err+ }+ results := cloneOmniQuerySpanResults(tableSource.GetQuerySpanResult())+ if len(cte.Columns) > 0 {+ if len(cte.Columns) != len(results) {+ return nil, errors.Errorf("MySQL CTE column list should have the same length, but got %d and %d", len(cte.Columns), len(results))+ }+ for i := range cte.Columns {+ results[i].Name = cte.Columns[i]+ }+ }+ return &base.PseudoTable{Name: cte.Name, Columns: results}, nil+}++func (q *omniQuerySpanExtractor) extractOmniRecursiveCTE(cte *ast.CommonTableExpr) (*base.PseudoTable, error) {+ selectStmt := ast.UnwrapParenSource(cte.Select)+ if selectStmt == nil || selectStmt.SetOp == ast.SetOpNone {+ return q.extractOmniNonRecursiveCTE(cte)+ }+ initialTable, err := q.extractOmniRecursiveCTEAnchor(selectStmt)+ if err != nil {+ return nil, err+ }+ results := cloneOmniQuerySpanResults(initialTable.GetQuerySpanResult())+ if len(cte.Columns) > 0 {+ if len(cte.Columns) != len(results) {+ return nil, errors.Errorf("The common table expression and column names list have different column counts")+ }+ for i := range cte.Columns {+ results[i].Name = cte.Columns[i]+ }+ }+ cteInfo := &base.PseudoTable{Name: cte.Name, Columns: results}+ q.ctes = append(q.ctes, cteInfo)+ defer func() {+ q.ctes = q.ctes[:len(q.ctes)-1]+ }()++ for {+ recursiveTable, err := q.extractOmniSelectStmt(cte.Select)+ if err != nil {+ return nil, err+ }+ recursiveResults := recursiveTable.GetQuerySpanResult()+ if len(recursiveResults) != len(cteInfo.Columns) {+ return nil, errors.Errorf("The common table expression and column names list have different column counts")+ }+ changed := false+ for i := range recursiveResults {+ var ok bool+ cteInfo.Columns[i].SourceColumns, ok = base.MergeSourceColumnSet(cteInfo.Columns[i].SourceColumns, recursiveResults[i].SourceColumns)+ cteInfo.Columns[i].IsPlainField = false+ changed = changed || ok+ }+ if !changed {+ break+ }+ }+ return cteInfo, nil+}++func (q *omniQuerySpanExtractor) extractOmniRecursiveCTEAnchor(stmt *ast.SelectStmt) (*base.PseudoTable, error) {+ stmt = ast.UnwrapParenSource(stmt)+ if stmt == nil || stmt.SetOp == ast.SetOpNone {+ return q.extractOmniSelectStmt(stmt)+ }+ if stmt.Left != nil {+ return q.extractOmniRecursiveCTEAnchor(stmt.Left)+ }+ return q.extractOmniRecursiveCTEAnchor(stmt.Right)+}++func cloneOmniQuerySpanResults(results []base.QuerySpanResult) []base.QuerySpanResult {+ clone := make([]base.QuerySpanResult, len(results))+ copy(clone, results)+ return clone+}++func (q *omniQuerySpanExtractor) extractOmniTableSources(tableExprs []ast.TableExpr) ([]base.TableSource, error) {+ var result []base.TableSource+ for _, tableExpr := range tableExprs {+ tableSource, err := q.extractOmniTableSource(tableExpr)+ if err != nil {+ return nil, err+ }+ if tableSource == nil {+ continue+ }+ q.priorTableInFrom = append(q.priorTableInFrom, tableSource)+ result = append(result, tableSource)+ }+ return result, nil+}++func (q *omniQuerySpanExtractor) extractOmniTableSource(tableExpr ast.TableExpr) (base.TableSource, error) {+ switch t := tableExpr.(type) {+ case nil:+ return nil, nil+ case *ast.TableRef:+ if isOmniDualTable(t) {+ return &base.PseudoTable{Name: t.Name}, nil+ }+ tableSource, err := q.findTableSchema(t.Schema, t.Name)+ if err != nil {+ return nil, err+ }+ if t.Alias == "" {+ return tableSource, nil+ }+ return &base.PseudoTable{+ Name: t.Alias,+ Columns: tableSource.GetQuerySpanResult(),+ }, nil+ case *ast.SubqueryExpr:+ return q.extractOmniSubquery(t)+ case *ast.JoinClause:+ return q.extractOmniJoin(t)+ case *ast.JsonTableExpr:+ return q.extractOmniJSONTable(t)+ default:+ return nil, errors.Errorf("unsupported omni MySQL table source %T", tableExpr)+ }+}++func (q *omniQuerySpanExtractor) extractOmniJSONTable(expr *ast.JsonTableExpr) (base.TableSource, error) {+ if expr == nil {+ return nil, nil+ }+ name := expr.Alias+ if name == "" {+ name = q.omniExprName(expr.Expr)+ }+ field, err := q.extractOmniExpr(expr.Expr)+ if err != nil {+ return nil, err+ }+ var columns []base.QuerySpanResult+ for _, column := range flattenOmniJSONTableColumns(expr.Columns) {+ columns = append(columns, base.QuerySpanResult{+ Name: column.Name,+ SourceColumns: field.SourceColumns,+ IsPlainField: field.IsPlainField,+ })+ }+ return &base.PseudoTable{Name: name, Columns: columns}, nil+}++func flattenOmniJSONTableColumns(columns []*ast.JsonTableColumn) []*ast.JsonTableColumn {+ var result []*ast.JsonTableColumn+ for _, column := range columns {+ if column == nil {+ continue+ }+ if column.Nested {+ result = append(result, flattenOmniJSONTableColumns(column.NestedCols)...)+ continue+ }+ result = append(result, column)+ }+ return result+}++func (q *omniQuerySpanExtractor) extractOmniJoin(join *ast.JoinClause) (base.TableSource, error) {+ if join == nil {+ return nil, nil+ }+ left, err := q.extractOmniTableSource(join.Left)+ if err != nil {+ return nil, err+ }+ if left != nil {+ q.tableSourceFrom = append(q.tableSourceFrom, left)+ }+ right, err := q.extractOmniTableSource(join.Right)+ if err != nil {+ return nil, err+ }+ if right != nil {+ q.tableSourceFrom = append(q.tableSourceFrom, right)+ }++ var using []string+ if condition, ok := join.Condition.(*ast.UsingCondition); ok && condition != nil {+ using = condition.Columns+ }+ return joinTableSources(left, right, omniJoinType(join.Type), using), nil+}++func omniJoinType(joinType ast.JoinType) joinType {+ switch joinType {+ case ast.JoinInner:+ return InnerJoin+ case ast.JoinLeft:+ return LeftOuterJoin+ case ast.JoinRight:+ return RightOuterJoin+ case ast.JoinCross:+ return CrossJoin+ case ast.JoinNatural:+ return NaturalInnerJoin+ case ast.JoinStraight:+ return StraightJoin+ case ast.JoinNaturalLeft:+ return NaturalLeftOuterJoin+ case ast.JoinNaturalRight:+ return NaturalRightOuterJoin+ default:+ return Join+ }+}++func (q *omniQuerySpanExtractor) extractOmniSubquery(expr *ast.SubqueryExpr) (*base.PseudoTable, error) {+ if expr == nil {+ return &base.PseudoTable{}, nil+ }+ subqueryExtractor := q.cloneOmniForSubquery()+ if expr.Lateral {+ subqueryExtractor.outerTableSources = append(subqueryExtractor.outerTableSources, q.priorTableInFrom...)+ }+ tableSource, err := subqueryExtractor.extractOmniSelectStmt(expr.Select)+ if err != nil {+ return nil, err+ }+ results := cloneOmniQuerySpanResults(tableSource.GetQuerySpanResult())+ if len(expr.Columns) > 0 {+ if len(expr.Columns) != len(results) {+ return nil, errors.Errorf("derived table column list length %d doesn't match result column length %d", len(expr.Columns), len(results))+ }+ for i := range expr.Columns {+ results[i].Name = expr.Columns[i]+ }+ }+ if expr.Alias == "" {+ return &base.PseudoTable{Name: tableSource.Name, Columns: results}, nil+ }+ return &base.PseudoTable{+ Name: expr.Alias,+ Columns: results,+ }, nil+}++func (q *omniQuerySpanExtractor) cloneOmniForSubquery() *omniQuerySpanExtractor {+ return &omniQuerySpanExtractor{+ querySpanExtractor: &querySpanExtractor{+ ctx: q.ctx,+ defaultDatabase: q.defaultDatabase,+ gCtx: q.gCtx,+ ctes: q.ctes,+ outerTableSources: append(q.outerTableSources, q.tableSourceFrom...),+ tableSourceFrom: []base.TableSource{},+ ignoreCaseSensitive: q.ignoreCaseSensitive,+ viewResolutionStack: cloneViewResolutionStack(q.viewResolutionStack),+ },+ source: q.source,+ }+}++func (q *omniQuerySpanExtractor) extractOmniTargetList(targets []ast.ExprNode, fromSources []base.TableSource) ([]base.QuerySpanResult, error) {+ var result []base.QuerySpanResult+ for _, target := range targets {+ switch t := target.(type) {+ case *ast.ResTarget:+ if _, ok := t.Val.(*ast.StarExpr); ok {+ fields, err := q.extractOmniTableWild("", "", fromSources)+ if err != nil {+ return nil, err+ }+ result = append(result, fields...)+ continue+ }+ if columnRef, ok := t.Val.(*ast.ColumnRef); ok && columnRef.Star {+ fields, err := q.extractOmniColumnWild(columnRef, fromSources)+ if err != nil {+ return nil, err+ }+ result = append(result, fields...)+ continue+ }+ case *ast.StarExpr:+ fields, err := q.extractOmniTableWild("", "", fromSources)+ if err != nil {+ return nil, err+ }+ result = append(result, fields...)+ continue+ case *ast.ColumnRef:+ if t.Star {+ fields, err := q.extractOmniColumnWild(t, fromSources)+ if err != nil {+ return nil, err+ }+ result = append(result, fields...)+ continue+ }+ default:+ }++ field, err := q.extractOmniTarget(target)+ if err != nil {+ return nil, err+ }+ result = append(result, field)+ }+ return result, nil+}++func (q *omniQuerySpanExtractor) extractOmniTarget(target ast.ExprNode) (base.QuerySpanResult, error) {+ switch t := target.(type) {+ case *ast.ResTarget:+ field, err := q.extractOmniExpr(t.Val)+ if err != nil {+ return base.QuerySpanResult{}, err+ }+ if t.Name != "" {+ field.Name = t.Name+ }+ return field, nil+ default:+ return q.extractOmniExpr(target)+ }+}++func (q *omniQuerySpanExtractor) extractOmniExpr(expr ast.ExprNode) (base.QuerySpanResult, error) {+ switch e := expr.(type) {+ case nil:+ return base.QuerySpanResult{+ SourceColumns: base.SourceColumnSet{},+ IsPlainField: true,+ }, nil+ case *ast.ColumnRef:+ if e.Star {+ return base.QuerySpanResult{}, errors.Errorf("asterisk is not a scalar expression")+ }+ sourceColumns, err := q.getFieldColumnSource(e.Schema, e.Table, e.Column)+ if err != nil {+ return base.QuerySpanResult{}, err+ }+ return base.QuerySpanResult{+ Name: e.Column,+ SourceColumns: sourceColumns,+ IsPlainField: true,+ }, nil+ case *ast.StarExpr:+ return base.QuerySpanResult{}, errors.Errorf("asterisk is not a scalar expression")+ case *ast.IntLit, *ast.FloatLit, *ast.StringLit, *ast.BoolLit, *ast.NullLit, *ast.HexLit, *ast.BitLit, *ast.TemporalLit:+ return base.QuerySpanResult{+ Name: q.omniExprName(e),+ SourceColumns: base.SourceColumnSet{},+ IsPlainField: true,+ }, nil+ case *ast.VariableRef:+ return base.QuerySpanResult{+ Name: q.omniExprName(e),+ SourceColumns: base.SourceColumnSet{},+ IsPlainField: true,+ }, nil+ case *ast.ParenExpr:+ field, err := q.extractOmniExpr(e.Expr)+ if err != nil {+ return base.QuerySpanResult{}, err+ }+ field.Name = q.omniExprName(e)+ field.IsPlainField = false+ return field, nil+ case *ast.BinaryExpr:+ sourceColumns, err := q.mergeOmniExprSources(e.Left, e.Right)+ if err != nil {+ return base.QuerySpanResult{}, err+ }+ return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil+ case *ast.UnaryExpr:+ sourceColumns, err := q.mergeOmniExprSources(e.Operand)+ if err != nil {+ return base.QuerySpanResult{}, err+ }+ return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil+ case *ast.FuncCallExpr:+ exprs := append([]ast.ExprNode{}, e.Args...)+ exprs = append(exprs, e.Separator)+ for _, item := range e.OrderBy {+ if item != nil {+ exprs = append(exprs, item.Expr)+ }+ }+ if e.Over != nil {+ exprs = append(exprs, e.Over.PartitionBy...)+ for _, item := range e.Over.OrderBy {+ if item != nil {+ exprs = append(exprs, item.Expr)+ }+ }+ }+ sourceColumns, err := q.mergeOmniExprSources(exprs...)+ if err != nil {+ return base.QuerySpanResult{}, err+ }+ return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil+ case *ast.SubqueryExpr:+ sourceColumns, isPlain, err := q.extractOmniSelectSourceColumns(e.Select)+ if err != nil {+ return base.QuerySpanResult{}, err+ }+ return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: isPlain}, nil+ case *ast.ExistsExpr:+ sourceColumns, _, err := q.extractOmniSelectSourceColumns(e.Select)+ if err != nil {+ return base.QuerySpanResult{}, err+ }+ return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil+ case *ast.CaseExpr:+ var exprs []ast.ExprNode+ exprs = append(exprs, e.Operand)+ for _, when := range e.Whens {+ if when == nil {+ continue+ }+ exprs = append(exprs, when.Cond, when.Result)+ }+ exprs = append(exprs, e.Default)+ sourceColumns, err := q.mergeOmniExprSources(exprs...)+ if err != nil {+ return base.QuerySpanResult{}, err+ }+ return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil+ case *ast.BetweenExpr:+ sourceColumns, err := q.mergeOmniExprSources(e.Expr, e.Low, e.High)+ if err != nil {+ return base.QuerySpanResult{}, err+ }+ return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil+ case *ast.InExpr:+ exprs := append([]ast.ExprNode{e.Expr}, e.List...)+ sourceColumns, err := q.mergeOmniExprSources(exprs...)+ if err != nil {+ return base.QuerySpanResult{}, err+ }+ if e.Select != nil {+ selectSourceColumns, _, err := q.extractOmniSelectSourceColumns(e.Select)+ if err != nil {+ return base.QuerySpanResult{}, err+ }+ sourceColumns, _ = base.MergeSourceColumnSet(sourceColumns, selectSourceColumns)+ }+ return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil+ case *ast.LikeExpr:+ sourceColumns, err := q.mergeOmniExprSources(e.Expr, e.Pattern, e.Escape)+ if err != nil {+ return base.QuerySpanResult{}, err+ }+ return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil+ case *ast.IsExpr:+ sourceColumns, err := q.mergeOmniExprSources(e.Expr)+ if err != nil {+ return base.QuerySpanResult{}, err+ }+ return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil+ case *ast.CastExpr:+ sourceColumns, err := q.mergeOmniExprSources(e.Expr)+ if err != nil {+ return base.QuerySpanResult{}, err+ }+ return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil+ case *ast.ExtractExpr:+ sourceColumns, err := q.mergeOmniExprSources(e.Expr)+ if err != nil {+ return base.QuerySpanResult{}, err+ }+ return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil+ case *ast.IntervalExpr:+ sourceColumns, err := q.mergeOmniExprSources(e.Value)+ if err != nil {+ return base.QuerySpanResult{}, err+ }+ return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil+ case *ast.CollateExpr:+ sourceColumns, err := q.mergeOmniExprSources(e.Expr)+ if err != nil {+ return base.QuerySpanResult{}, err+ }+ return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil+ case *ast.MatchExpr:+ exprs := make([]ast.ExprNode, 0, len(e.Columns)+1)+ for _, column := range e.Columns {+ exprs = append(exprs, column)+ }+ exprs = append(exprs, e.Against)+ sourceColumns, err := q.mergeOmniExprSources(exprs...)+ if err != nil {+ return base.QuerySpanResult{}, err+ }+ return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil+ case *ast.ConvertExpr:+ sourceColumns, err := q.mergeOmniExprSources(e.Expr)+ if err != nil {+ return base.QuerySpanResult{}, err+ }+ return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil+ case *ast.DefaultExpr:+ return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: base.SourceColumnSet{}, IsPlainField: true}, nil+ case *ast.RowExpr:+ sourceColumns, err := q.mergeOmniExprSources(e.Items...)+ if err != nil {+ return base.QuerySpanResult{}, err+ }+ return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil+ case *ast.MemberOfExpr:+ sourceColumns, err := q.mergeOmniExprSources(e.Value, e.Array)+ if err != nil {+ return base.QuerySpanResult{}, err+ }+ return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil+ case *ast.KeywordArg:+ // Keyword arguments (TIMESTAMPDIFF(SECOND, ...), GET_FORMAT(DATE, ...))+ // are unit selectors, not column references — no lineage.+ return base.QuerySpanResult{Name: e.Keyword, SourceColumns: base.SourceColumnSet{}, IsPlainField: false}, nil+ case *ast.WeightStringExpr:+ sourceColumns, err := q.mergeOmniExprSources(e.Expr)+ if err != nil {+ return base.QuerySpanResult{}, err+ }+ return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil+ default:+ return base.QuerySpanResult{}, errors.Errorf("unsupported omni MySQL expression %T", expr)+ }+}++func (q *omniQuerySpanExtractor) extractOmniSelectSourceColumns(selectStmt *ast.SelectStmt) (base.SourceColumnSet, bool, error) {+ subqueryExtractor := q.cloneOmniForSubquery()+ tableSource, err := subqueryExtractor.extractOmniSelectStmt(selectStmt)+ if err != nil {+ return nil, false, err+ }+ spanResults := tableSource.GetQuerySpanResult()+ sourceColumns := make(base.SourceColumnSet)+ for _, field := range spanResults {+ sourceColumns, _ = base.MergeSourceColumnSet(sourceColumns, field.SourceColumns)+ }+ isPlain := false+ if len(spanResults) == 1 {+ isPlain = spanResults[0].IsPlainField+ }+ return sourceColumns, isPlain, nil+}++func (q *omniQuerySpanExtractor) mergeOmniExprSources(exprs ...ast.ExprNode) (base.SourceColumnSet, error) {+ result := make(base.SourceColumnSet)+ for _, expr := range exprs {+ if expr == nil {+ continue+ }+ field, err := q.extractOmniExpr(expr)+ if err != nil {+ return nil, err+ }+ result, _ = base.MergeSourceColumnSet(result, field.SourceColumns)+ }+ return result, nil+}++func (q *omniQuerySpanExtractor) extractOmniColumnWild(columnRef *ast.ColumnRef, fromSources []base.TableSource) ([]base.QuerySpanResult, error) {+ if columnRef == nil {+ return nil, nil+ }+ return q.extractOmniTableWild(columnRef.Schema, columnRef.Table, fromSources)+}++func (q *omniQuerySpanExtractor) extractOmniTableWild(databaseName, tableName string, fromSources []base.TableSource) ([]base.QuerySpanResult, error) {+ if databaseName == "" && tableName == "" {+ var result []base.QuerySpanResult+ for _, fromSource := range fromSources {+ result = append(result, fromSource.GetQuerySpanResult()...)+ }+ return result, nil+ }++ result, ok := q.getAllTableColumnSources(databaseName, tableName)+ if !ok {+ return nil, &base.ResourceNotFoundError{+ Database: &databaseName,+ Table: &tableName,+ }+ }+ return result, nil+}++func (q *omniQuerySpanExtractor) omniExprName(expr ast.ExprNode) string {+ switch e := expr.(type) {+ case *ast.ColumnRef:+ var parts []string+ if e.Schema != "" {+ parts = append(parts, e.Schema)+ }+ if e.Table != "" {+ parts = append(parts, e.Table)+ }+ if e.Star {+ parts = append(parts, "*")+ } else {+ parts = append(parts, e.Column)+ }+ return strings.Join(parts, ".")+ case *ast.BinaryExpr:+ return q.omniExprName(e.Left) + omniBinaryOpName(e) + q.omniExprName(e.Right)+ case *ast.InExpr:+ var list []string+ for _, expr := range e.List {+ list = append(list, q.omniExprName(expr))+ }+ operator := " in "+ if e.Not {+ operator = " not in "+ }+ return q.omniExprName(e.Expr) + operator + "(" + strings.Join(list, ", ") + ")"+ case *ast.IntLit:+ if name := q.omniSlice(e.Loc); name != "" {+ return name+ }+ return strconv.FormatInt(e.Value, 10)+ case *ast.FloatLit:+ if name := q.omniSlice(e.Loc); name != "" {+ return name+ }+ return e.Value+ case *ast.StringLit:+ if name := q.omniSlice(e.Loc); name != "" {+ return name+ }+ return e.Value+ case *ast.BoolLit:+ if name := q.omniSlice(e.Loc); name != "" {+ return name+ }+ return strconv.FormatBool(e.Value)+ case *ast.NullLit:+ if name := q.omniSlice(e.Loc); name != "" {+ return name+ }+ return "NULL"+ case *ast.HexLit:+ if name := q.omniSlice(e.Loc); name != "" {+ return name+ }+ return e.Value+ case *ast.BitLit:+ if name := q.omniSlice(e.Loc); name != "" {+ return name+ }+ return e.Value+ case *ast.TemporalLit:+ if name := q.omniSlice(e.Loc); name != "" {+ return name+ }+ return e.Value+ default:+ if loc, ok := omniNodeLoc(e); ok {+ return q.omniSlice(loc)+ }+ return ""+ }+}++func omniBinaryOpName(expr *ast.BinaryExpr) string {+ if expr == nil {+ return ""+ }+ if expr.OriginalOp != "" {+ return expr.OriginalOp+ }+ return omniBinaryOpNames[expr.Op]+}++var omniBinaryOpNames = map[ast.BinaryOp]string{+ ast.BinOpAdd: "+",+ ast.BinOpSub: "-",+ ast.BinOpMul: "*",+ ast.BinOpDiv: "/",+ ast.BinOpMod: "%",+ ast.BinOpEq: "=",+ ast.BinOpNe: "!=",+ ast.BinOpLt: "<",+ ast.BinOpGt: ">",+ ast.BinOpLe: "<=",+ ast.BinOpGe: ">=",+ ast.BinOpAnd: " and ",+ ast.BinOpOr: " or ",+ ast.BinOpXor: " xor ",+ ast.BinOpBitAnd: "&",+ ast.BinOpBitOr: "|",+ ast.BinOpBitXor: "^",+ ast.BinOpShiftLeft: "<<",+ ast.BinOpShiftRight: ">>",+ ast.BinOpDivInt: " div ",+ ast.BinOpRegexp: " regexp ",+ ast.BinOpLikeEscape: " like ",+ ast.BinOpNullSafeEq: "<=>",+ ast.BinOpAssign: ":=",+ ast.BinOpJsonExtract: "->",+ ast.BinOpJsonUnquote: "->>",+ ast.BinOpSoundsLike: " sounds like ",+}++func (q *omniQuerySpanExtractor) omniSlice(loc ast.Loc) string {+ if loc.Start < 0 || loc.End <= loc.Start || loc.End > len(q.source) {+ return ""+ }+ return strings.TrimSpace(q.source[loc.Start:loc.End])+}++func omniNodeLoc(node ast.Node) (ast.Loc, bool) {+ if loc, ok := omniExprNodeLoc(node); ok {+ return loc, true+ }+ return omniLiteralNodeLoc(node)+}++func omniExprNodeLoc(node ast.Node) (ast.Loc, bool) {+ switch n := node.(type) {+ case *ast.ResTarget:+ return n.Loc, true+ case *ast.ColumnRef:+ return n.Loc, true+ case *ast.BinaryExpr:+ return n.Loc, true+ case *ast.UnaryExpr:+ return n.Loc, true+ case *ast.FuncCallExpr:+ return n.Loc, true+ case *ast.SubqueryExpr:+ return n.Loc, true+ case *ast.CaseExpr:+ return n.Loc, true+ case *ast.BetweenExpr:+ return n.Loc, true+ case *ast.InExpr:+ return n.Loc, true+ case *ast.LikeExpr:+ return n.Loc, true+ case *ast.IsExpr:+ return n.Loc, true+ case *ast.ExistsExpr:+ return n.Loc, true+ case *ast.CastExpr:+ return n.Loc, true+ case *ast.ExtractExpr:+ return n.Loc, true+ case *ast.IntervalExpr:+ return n.Loc, true+ case *ast.CollateExpr:+ return n.Loc, true+ case *ast.MatchExpr:+ return n.Loc, true+ case *ast.ConvertExpr:+ return n.Loc, true+ case *ast.DefaultExpr:+ return n.Loc, true+ case *ast.RowExpr:+ return n.Loc, true+ case *ast.MemberOfExpr:+ return n.Loc, true+ case *ast.ParenExpr:+ return n.Loc, true+ case *ast.StarExpr:+ return n.Loc, true+ default:+ return ast.Loc{}, false+ }+}++func omniLiteralNodeLoc(node ast.Node) (ast.Loc, bool) {+ switch n := node.(type) {+ case *ast.IntLit:+ return n.Loc, true+ case *ast.FloatLit:+ return n.Loc, true+ case *ast.StringLit:+ return n.Loc, true+ case *ast.BoolLit:+ return n.Loc, true+ case *ast.NullLit:+ return n.Loc, true+ case *ast.HexLit:+ return n.Loc, true+ case *ast.BitLit:+ return n.Loc, true+ case *ast.TemporalLit:+ return n.Loc, true+ case *ast.VariableRef:+ return n.Loc, true+ default:+ return ast.Loc{}, false+ }+}++func classifyOmniQueryType(node ast.Node, allSystems bool, source string) base.QueryType {+ switch n := node.(type) {+ case *ast.SelectStmt, *ast.TableStmt, *ast.ValuesStmt:+ if allSystems {+ return base.SelectInfoSchema+ }+ return base.Select+ case *ast.ExplainStmt:+ if isOmniDescribeStatement(source, n.Loc) {+ return base.SelectInfoSchema+ }+ if n.Analyze {+ switch n.Stmt.(type) {+ case *ast.SelectStmt, *ast.TableStmt, *ast.ValuesStmt:+ return base.Select+ default:+ return base.DML+ }+ }+ return base.Explain+ case *ast.ShowStmt:+ return base.SelectInfoSchema+ case *ast.SetStmt, *ast.SetDefaultRoleStmt, *ast.SetResourceGroupStmt, *ast.SetRoleStmt, *ast.SetTransactionStmt:+ return base.Select+ case *ast.SetPasswordStmt, *ast.HelpStmt:+ return base.QueryTypeUnknown+ case *ast.CreateDatabaseStmt, *ast.CreateTableStmt, *ast.CreateIndexStmt, *ast.CreateViewStmt,+ *ast.CreateEventStmt, *ast.CreateTriggerStmt, *ast.CreateFunctionStmt,+ *ast.CreateUserStmt, *ast.CreateRoleStmt, *ast.CreateTablespaceStmt, *ast.CreateServerStmt,+ *ast.CreateLogfileGroupStmt, *ast.CreateSpatialRefSysStmt, *ast.CreateResourceGroupStmt,+ *ast.AlterDatabaseStmt, *ast.AlterTableStmt, *ast.AlterViewStmt, *ast.AlterEventStmt,+ *ast.AlterUserStmt, *ast.AlterRoutineStmt, *ast.AlterTablespaceStmt, *ast.AlterServerStmt,+ *ast.AlterLogfileGroupStmt, *ast.AlterResourceGroupStmt, *ast.AlterInstanceStmt,+ *ast.DropDatabaseStmt, *ast.DropTableStmt, *ast.DropIndexStmt, *ast.DropViewStmt,+ *ast.DropEventStmt, *ast.DropTriggerStmt, *ast.DropRoutineStmt,+ *ast.DropUserStmt, *ast.DropRoleStmt, *ast.DropTablespaceStmt, *ast.DropServerStmt,+ *ast.DropLogfileGroupStmt, *ast.DropSpatialRefSysStmt, *ast.DropResourceGroupStmt,+ *ast.RenameTableStmt, *ast.RenameUserStmt, *ast.TruncateStmt, *ast.ImportTableStmt,+ *ast.GrantStmt, *ast.RevokeStmt, *ast.GrantRoleStmt, *ast.RevokeRoleStmt,+ *ast.InstallPluginStmt, *ast.UninstallPluginStmt, *ast.InstallComponentStmt,+ *ast.UninstallComponentStmt, *ast.CloneStmt:+ return base.DDL+ case *ast.InsertStmt, *ast.UpdateStmt, *ast.DeleteStmt, *ast.BeginStmt, *ast.CommitStmt,+ *ast.RollbackStmt, *ast.SavepointStmt, *ast.LockTablesStmt, *ast.UnlockTablesStmt,+ *ast.LoadDataStmt, *ast.PrepareStmt, *ast.ExecuteStmt, *ast.DeallocateStmt,+ *ast.CallStmt, *ast.DoStmt, *ast.HandlerOpenStmt, *ast.HandlerReadStmt, *ast.HandlerCloseStmt,+ *ast.AnalyzeTableStmt, *ast.OptimizeTableStmt, *ast.CheckTableStmt, *ast.RepairTableStmt,+ *ast.FlushStmt, *ast.KillStmt, *ast.ShutdownStmt, *ast.RestartStmt, *ast.XAStmt,+ *ast.SignalStmt, *ast.ResignalStmt, *ast.GetDiagnosticsStmt, *ast.DeclareVarStmt,+ *ast.DeclareConditionStmt, *ast.DeclareHandlerStmt, *ast.DeclareCursorStmt,+ *ast.IfStmt, *ast.WhileStmt, *ast.RepeatStmt, *ast.LoopStmt, *ast.LeaveStmt,+ *ast.IterateStmt, *ast.ReturnStmt, *ast.OpenCursorStmt, *ast.FetchCursorStmt,+ *ast.CloseCursorStmt, *ast.LockInstanceStmt, *ast.UnlockInstanceStmt, *ast.BinlogStmt,+ *ast.CacheIndexStmt, *ast.LoadIndexIntoCacheStmt, *ast.ResetPersistStmt,+ *ast.ChangeReplicationSourceStmt, *ast.ChangeReplicationFilterStmt,+ *ast.StartReplicaStmt, *ast.StopReplicaStmt, *ast.ResetReplicaStmt,+ *ast.PurgeBinaryLogsStmt, *ast.ResetMasterStmt,+ *ast.StartGroupReplicationStmt, *ast.StopGroupReplicationStmt:+ return base.DML+ default:+ return base.QueryTypeUnknown+ }+}++func isOmniDescribeStatement(source string, loc ast.Loc) bool {+ statement := strings.TrimSpace(source)+ if loc.Start >= 0 && loc.End > loc.Start && loc.End <= len(source) {+ statement = strings.TrimSpace(source[loc.Start:loc.End])+ }+ upper := strings.ToUpper(statement)+ fields := strings.Fields(upper)+ return len(fields) > 0 && (fields[0] == "DESCRIBE" || fields[0] == "DESC")+}++func collectOmniAccessTables(root ast.Node, defaultDatabase string, normalizeStarRocksCluster bool) base.SourceColumnSet {+ result := make(base.SourceColumnSet)+ collectOmniAccessTablesFromNode(result, root, defaultDatabase, normalizeStarRocksCluster)+ return result+}++func collectOmniAccessTablesFromNode(result base.SourceColumnSet, node ast.Node, defaultDatabase string, normalizeStarRocksCluster bool) {+ switch n := node.(type) {+ case nil:+ case *ast.SelectStmt:+ if n == nil {+ return+ }+ for _, cte := range n.CTEs {+ if cte != nil {+ collectOmniAccessTablesFromNode(result, cte.Select, defaultDatabase, normalizeStarRocksCluster)+ }+ }+ if n.Left != nil {+ collectOmniAccessTablesFromNode(result, n.Left, defaultDatabase, normalizeStarRocksCluster)+ }+ if n.Right != nil {+ collectOmniAccessTablesFromNode(result, n.Right, defaultDatabase, normalizeStarRocksCluster)+ }+ if inner := n.ParenSource; inner != nil {+ collectOmniAccessTablesFromNode(result, inner, defaultDatabase, normalizeStarRocksCluster)+ }+ if tableStmt := n.TableSource; tableStmt != nil {+ collectOmniAccessTablesFromNode(result, tableStmt, defaultDatabase, normalizeStarRocksCluster)+ }+ if valuesStmt := n.ValuesSource; valuesStmt != nil {+ collectOmniAccessTablesFromNode(result, valuesStmt, defaultDatabase, normalizeStarRocksCluster)+ }+ for _, target := range n.TargetList {+ collectOmniAccessTablesFromExpr(result, target, defaultDatabase, normalizeStarRocksCluster)+ }+ for _, tableExpr := range n.From {+ collectOmniAccessTablesFromTableExpr(result, tableExpr, defaultDatabase, normalizeStarRocksCluster)+ }+ collectOmniAccessTablesFromExpr(result, n.Where, defaultDatabase, normalizeStarRocksCluster)+ for _, groupBy := range n.GroupBy {+ collectOmniAccessTablesFromExpr(result, groupBy, defaultDatabase, normalizeStarRocksCluster)+ }+ collectOmniAccessTablesFromExpr(result, n.Having, defaultDatabase, normalizeStarRocksCluster)+ for _, orderBy := range n.OrderBy {+ if orderBy != nil {+ collectOmniAccessTablesFromExpr(result, orderBy.Expr, defaultDatabase, normalizeStarRocksCluster)+ }+ }+ case *ast.ExplainStmt:+ collectOmniAccessTablesFromNode(result, n.Stmt, defaultDatabase, normalizeStarRocksCluster)+ case *ast.InsertStmt:+ collectOmniAccessTablesFromTableRef(result, n.Table, defaultDatabase, normalizeStarRocksCluster)+ for _, row := range n.Values {+ for _, expr := range row {+ collectOmniAccessTablesFromExpr(result, expr, defaultDatabase, normalizeStarRocksCluster)+ }+ }+ collectOmniAccessTablesFromNode(result, n.Select, defaultDatabase, normalizeStarRocksCluster)+ collectOmniAccessTablesFromNode(result, n.TableSource, defaultDatabase, normalizeStarRocksCluster)+ for _, assignment := range n.SetList {+ if assignment != nil {+ collectOmniAccessTablesFromExpr(result, assignment.Value, defaultDatabase, normalizeStarRocksCluster)+ }+ }+ for _, assignment := range n.OnDuplicateKey {+ if assignment != nil {+ collectOmniAccessTablesFromExpr(result, assignment.Value, defaultDatabase, normalizeStarRocksCluster)+ }+ }+ case *ast.UpdateStmt:+ for _, tableExpr := range n.Tables {+ collectOmniAccessTablesFromTableExpr(result, tableExpr, defaultDatabase, normalizeStarRocksCluster)+ }+ for _, assignment := range n.SetList {+ if assignment != nil {+ collectOmniAccessTablesFromExpr(result, assignment.Value, defaultDatabase, normalizeStarRocksCluster)+ }+ }+ collectOmniAccessTablesFromExpr(result, n.Where, defaultDatabase, normalizeStarRocksCluster)+ for _, orderBy := range n.OrderBy {+ if orderBy != nil {+ collectOmniAccessTablesFromExpr(result, orderBy.Expr, defaultDatabase, normalizeStarRocksCluster)+ }+ }+ case *ast.DeleteStmt:+ for _, tableExpr := range n.Tables {+ collectOmniAccessTablesFromTableExpr(result, tableExpr, defaultDatabase, normalizeStarRocksCluster)+ }+ for _, tableExpr := range n.Using {+ collectOmniAccessTablesFromTableExpr(result, tableExpr, defaultDatabase, normalizeStarRocksCluster)+ }+ collectOmniAccessTablesFromExpr(result, n.Where, defaultDatabase, normalizeStarRocksCluster)+ for _, orderBy := range n.OrderBy {+ if orderBy != nil {+ collectOmniAccessTablesFromExpr(result, orderBy.Expr, defaultDatabase, normalizeStarRocksCluster)+ }+ }+ case *ast.CreateTableStmt:+ collectOmniAccessTablesFromTableRef(result, n.Table, defaultDatabase, normalizeStarRocksCluster)+ collectOmniAccessTablesFromTableRef(result, n.Like, defaultDatabase, normalizeStarRocksCluster)+ collectOmniAccessTablesFromNode(result, n.Select, defaultDatabase, normalizeStarRocksCluster)+ case *ast.CreateIndexStmt:+ collectOmniAccessTablesFromTableRef(result, n.Table, defaultDatabase, normalizeStarRocksCluster)+ for _, column := range n.Columns {+ if column != nil {+ collectOmniAccessTablesFromExpr(result, column.Expr, defaultDatabase, normalizeStarRocksCluster)+ }+ }+ case *ast.CreateViewStmt:+ collectOmniAccessTablesFromTableRef(result, n.Name, defaultDatabase, normalizeStarRocksCluster)+ collectOmniAccessTablesFromNode(result, n.Select, defaultDatabase, normalizeStarRocksCluster)+ case *ast.AlterTableStmt:+ collectOmniAccessTablesFromTableRef(result, n.Table, defaultDatabase, normalizeStarRocksCluster)+ for _, command := range n.Commands {+ if command == nil {+ continue+ }+ collectOmniAccessTablesFromExpr(result, command.DefaultExpr, defaultDatabase, normalizeStarRocksCluster)+ collectOmniAccessTablesFromTableRef(result, command.ExchangeTable, defaultDatabase, normalizeStarRocksCluster)+ collectOmniAccessTablesFromOrderBy(result, command.OrderByItems, defaultDatabase, normalizeStarRocksCluster)+ }+ case *ast.DropTableStmt:+ collectOmniAccessTablesFromTableRefs(result, n.Tables, defaultDatabase, normalizeStarRocksCluster)+ case *ast.DropIndexStmt:+ collectOmniAccessTablesFromTableRef(result, n.Table, defaultDatabase, normalizeStarRocksCluster)+ case *ast.DropViewStmt:+ collectOmniAccessTablesFromTableRefs(result, n.Views, defaultDatabase, normalizeStarRocksCluster)+ case *ast.RenameTableStmt:+ for _, pair := range n.Pairs {+ if pair == nil {+ continue+ }+ collectOmniAccessTablesFromTableRef(result, pair.Old, defaultDatabase, normalizeStarRocksCluster)+ collectOmniAccessTablesFromTableRef(result, pair.New, defaultDatabase, normalizeStarRocksCluster)+ }+ case *ast.TruncateStmt:+ collectOmniAccessTablesFromTableRefs(result, n.Tables, defaultDatabase, normalizeStarRocksCluster)+ case *ast.AnalyzeTableStmt:+ collectOmniAccessTablesFromTableRefs(result, n.Tables, defaultDatabase, normalizeStarRocksCluster)+ case *ast.OptimizeTableStmt:+ collectOmniAccessTablesFromTableRefs(result, n.Tables, defaultDatabase, normalizeStarRocksCluster)+ case *ast.CheckTableStmt:+ collectOmniAccessTablesFromTableRefs(result, n.Tables, defaultDatabase, normalizeStarRocksCluster)+ case *ast.RepairTableStmt:+ collectOmniAccessTablesFromTableRefs(result, n.Tables, defaultDatabase, normalizeStarRocksCluster)+ case *ast.TableStmt:+ if n == nil {+ return+ }+ collectOmniAccessTablesFromTableRef(result, n.Table, defaultDatabase, normalizeStarRocksCluster)+ collectOmniAccessTablesFromOrderBy(result, n.OrderBy, defaultDatabase, normalizeStarRocksCluster)+ collectOmniAccessTablesFromLimit(result, n.Limit, defaultDatabase, normalizeStarRocksCluster)+ case *ast.ValuesStmt:+ for _, row := range n.Rows {+ for _, expr := range row {+ collectOmniAccessTablesFromExpr(result, expr, defaultDatabase, normalizeStarRocksCluster)+ }+ }+ collectOmniAccessTablesFromOrderBy(result, n.OrderBy, defaultDatabase, normalizeStarRocksCluster)+ collectOmniAccessTablesFromLimit(result, n.Limit, defaultDatabase, normalizeStarRocksCluster)+ case *ast.CallStmt:+ for _, arg := range n.Args {+ collectOmniAccessTablesFromExpr(result, arg, defaultDatabase, normalizeStarRocksCluster)+ }+ case *ast.SetStmt:+ for _, assignment := range n.Assignments {+ if assignment != nil {+ collectOmniAccessTablesFromExpr(result, assignment.Value, defaultDatabase, normalizeStarRocksCluster)+ }+ }+ case *ast.DoStmt:+ for _, expr := range n.Exprs {+ collectOmniAccessTablesFromExpr(result, expr, defaultDatabase, normalizeStarRocksCluster)+ }+ case *ast.HandlerOpenStmt:+ collectOmniAccessTablesFromTableRef(result, n.Table, defaultDatabase, normalizeStarRocksCluster)+ case *ast.HandlerReadStmt:+ collectOmniAccessTablesFromTableRef(result, n.Table, defaultDatabase, normalizeStarRocksCluster)+ collectOmniAccessTablesFromExpr(result, n.Where, defaultDatabase, normalizeStarRocksCluster)+ case *ast.HandlerCloseStmt:+ collectOmniAccessTablesFromTableRef(result, n.Table, defaultDatabase, normalizeStarRocksCluster)+ case *ast.LockTablesStmt:+ for _, table := range n.Tables {+ if table != nil {+ collectOmniAccessTablesFromTableRef(result, table.Table, defaultDatabase, normalizeStarRocksCluster)+ }+ }+ default:+ }+}++func collectOmniAccessTablesFromOrderBy(result base.SourceColumnSet, orderByItems []*ast.OrderByItem, defaultDatabase string, normalizeStarRocksCluster bool) {+ for _, orderBy := range orderByItems {+ if orderBy != nil {+ collectOmniAccessTablesFromExpr(result, orderBy.Expr, defaultDatabase, normalizeStarRocksCluster)+ }+ }+}++func collectOmniAccessTablesFromLimit(result base.SourceColumnSet, limit *ast.Limit, defaultDatabase string, normalizeStarRocksCluster bool) {+ if limit == nil {+ return+ }+ collectOmniAccessTablesFromExpr(result, limit.Count, defaultDatabase, normalizeStarRocksCluster)+ collectOmniAccessTablesFromExpr(result, limit.Offset, defaultDatabase, normalizeStarRocksCluster)+}++func collectOmniAccessTablesFromTableRefs(result base.SourceColumnSet, tableRefs []*ast.TableRef, defaultDatabase string, normalizeStarRocksCluster bool) {+ for _, tableRef := range tableRefs {+ collectOmniAccessTablesFromTableRef(result, tableRef, defaultDatabase, normalizeStarRocksCluster)+ }+}++func collectOmniAccessTablesFromTableRef(result base.SourceColumnSet, tableRef *ast.TableRef, defaultDatabase string, normalizeStarRocksCluster bool) {+ if tableRef == nil {+ return+ }+ if isOmniDualTable(tableRef) {+ return+ }+ database := tableRef.Schema+ if database == "" {+ database = defaultDatabase+ } else if normalizeStarRocksCluster {+ database = filterStarRocksClusterName(database)+ }+ result[base.ColumnResource{+ Database: database,+ Table: tableRef.Name,+ }] = true+}++func isOmniDualTable(tableRef *ast.TableRef) bool {+ return tableRef != nil && tableRef.Schema == "" && strings.EqualFold(tableRef.Name, "dual")+}++func collectOmniAccessTablesFromTableExpr(result base.SourceColumnSet, tableExpr ast.TableExpr, defaultDatabase string, normalizeStarRocksCluster bool) {+ switch n := tableExpr.(type) {+ case *ast.TableRef:+ collectOmniAccessTablesFromTableRef(result, n, defaultDatabase, normalizeStarRocksCluster)+ case *ast.JoinClause:+ collectOmniAccessTablesFromTableExpr(result, n.Left, defaultDatabase, normalizeStarRocksCluster)+ collectOmniAccessTablesFromTableExpr(result, n.Right, defaultDatabase, normalizeStarRocksCluster)+ switch condition := n.Condition.(type) {+ case *ast.OnCondition:+ collectOmniAccessTablesFromExpr(result, condition.Expr, defaultDatabase, normalizeStarRocksCluster)+ default:+ }+ case *ast.SubqueryExpr:+ collectOmniAccessTablesFromNode(result, n.Select, defaultDatabase, normalizeStarRocksCluster)+ case *ast.JsonTableExpr:+ collectOmniAccessTablesFromExpr(result, n.Expr, defaultDatabase, normalizeStarRocksCluster)+ collectOmniAccessTablesFromExpr(result, n.Path, defaultDatabase, normalizeStarRocksCluster)+ default:+ }+}++func collectOmniAccessTablesFromExpr(result base.SourceColumnSet, expr ast.ExprNode, defaultDatabase string, normalizeStarRocksCluster bool) {+ switch e := expr.(type) {+ case nil:+ case *ast.ResTarget:+ collectOmniAccessTablesFromExpr(result, e.Val, defaultDatabase, normalizeStarRocksCluster)+ case *ast.BinaryExpr:+ collectOmniAccessTablesFromExpr(result, e.Left, defaultDatabase, normalizeStarRocksCluster)+ collectOmniAccessTablesFromExpr(result, e.Right, defaultDatabase, normalizeStarRocksCluster)+ case *ast.UnaryExpr:+ collectOmniAccessTablesFromExpr(result, e.Operand, defaultDatabase, normalizeStarRocksCluster)+ case *ast.FuncCallExpr:+ for _, arg := range e.Args {+ collectOmniAccessTablesFromExpr(result, arg, defaultDatabase, normalizeStarRocksCluster)+ }+ collectOmniAccessTablesFromExpr(result, e.Separator, defaultDatabase, normalizeStarRocksCluster)+ for _, orderBy := range e.OrderBy {+ if orderBy != nil {+ collectOmniAccessTablesFromExpr(result, orderBy.Expr, defaultDatabase, normalizeStarRocksCluster)+ }+ }+ if e.Over != nil {+ for _, partitionBy := range e.Over.PartitionBy {+ collectOmniAccessTablesFromExpr(result, partitionBy, defaultDatabase, normalizeStarRocksCluster)+ }+ for _, orderBy := range e.Over.OrderBy {+ if orderBy != nil {+ collectOmniAccessTablesFromExpr(result, orderBy.Expr, defaultDatabase, normalizeStarRocksCluster)+ }+ }+ }+ case *ast.SubqueryExpr:+ collectOmniAccessTablesFromNode(result, e.Select, defaultDatabase, normalizeStarRocksCluster)+ case *ast.CaseExpr:+ collectOmniAccessTablesFromExpr(result, e.Operand, defaultDatabase, normalizeStarRocksCluster)+ for _, when := range e.Whens {+ if when == nil {+ continue+ }+ collectOmniAccessTablesFromExpr(result, when.Cond, defaultDatabase, normalizeStarRocksCluster)+ collectOmniAccessTablesFromExpr(result, when.Result, defaultDatabase, normalizeStarRocksCluster)+ }+ collectOmniAccessTablesFromExpr(result, e.Default, defaultDatabase, normalizeStarRocksCluster)+ case *ast.BetweenExpr:+ collectOmniAccessTablesFromExpr(result, e.Expr, defaultDatabase, normalizeStarRocksCluster)+ collectOmniAccessTablesFromExpr(result, e.Low, defaultDatabase, normalizeStarRocksCluster)+ collectOmniAccessTablesFromExpr(result, e.High, defaultDatabase, normalizeStarRocksCluster)+ case *ast.InExpr:+ collectOmniAccessTablesFromExpr(result, e.Expr, defaultDatabase, normalizeStarRocksCluster)+ for _, item := range e.List {+ collectOmniAccessTablesFromExpr(result, item, defaultDatabase, normalizeStarRocksCluster)+ }+ collectOmniAccessTablesFromNode(result, e.Select, defaultDatabase, normalizeStarRocksCluster)+ case *ast.LikeExpr:+ collectOmniAccessTablesFromExpr(result, e.Expr, defaultDatabase, normalizeStarRocksCluster)+ collectOmniAccessTablesFromExpr(result, e.Pattern, defaultDatabase, normalizeStarRocksCluster)+ collectOmniAccessTablesFromExpr(result, e.Escape, defaultDatabase, normalizeStarRocksCluster)+ case *ast.IsExpr:+ collectOmniAccessTablesFromExpr(result, e.Expr, defaultDatabase, normalizeStarRocksCluster)+ case *ast.ExistsExpr:+ collectOmniAccessTablesFromNode(result, e.Select, defaultDatabase, normalizeStarRocksCluster)+ case *ast.CastExpr:+ collectOmniAccessTablesFromExpr(result, e.Expr, defaultDatabase, normalizeStarRocksCluster)+ case *ast.ExtractExpr:+ collectOmniAccessTablesFromExpr(result, e.Expr, defaultDatabase, normalizeStarRocksCluster)+ case *ast.IntervalExpr:+ collectOmniAccessTablesFromExpr(result, e.Value, defaultDatabase, normalizeStarRocksCluster)+ case *ast.CollateExpr:+ collectOmniAccessTablesFromExpr(result, e.Expr, defaultDatabase, normalizeStarRocksCluster)+ case *ast.MatchExpr:+ for _, column := range e.Columns {+ collectOmniAccessTablesFromExpr(result, column, defaultDatabase, normalizeStarRocksCluster)+ }+ collectOmniAccessTablesFromExpr(result, e.Against, defaultDatabase, normalizeStarRocksCluster)+ case *ast.ConvertExpr:+ collectOmniAccessTablesFromExpr(result, e.Expr, defaultDatabase, normalizeStarRocksCluster)+ case *ast.RowExpr:+ for _, item := range e.Items {+ collectOmniAccessTablesFromExpr(result, item, defaultDatabase, normalizeStarRocksCluster)+ }+ case *ast.MemberOfExpr:+ collectOmniAccessTablesFromExpr(result, e.Value, defaultDatabase, normalizeStarRocksCluster)+ collectOmniAccessTablesFromExpr(result, e.Array, defaultDatabase, normalizeStarRocksCluster)+ case *ast.ParenExpr:+ collectOmniAccessTablesFromExpr(result, e.Expr, defaultDatabase, normalizeStarRocksCluster)+ case *ast.WeightStringExpr:+ collectOmniAccessTablesFromExpr(result, e.Expr, defaultDatabase, normalizeStarRocksCluster)+ default:+ }+}++func filterStarRocksClusterName(databaseName string) string {+ list := strings.Split(databaseName, ":")+ if len(list) > 1 {+ return list[len(list)-1]+ }+ return databaseName+}diff --git a/backend/plugin/parser/mysql/query_span_extractor_omni.go b/backend/plugin/parser/mysql/query_span_extractor_omni.godeleted file mode 100644index 7fc0a9f3e0..0000000000--- a/backend/plugin/parser/mysql/query_span_extractor_omni.go+++ /dev/null@@ -1,1461 +0,0 @@-package mysql--import (- "context"- "strconv"- "strings"-- "github.com/bytebase/omni/mysql/ast"- "github.com/pkg/errors"-- storepb "github.com/bytebase/bytebase/backend/generated-go/store"- "github.com/bytebase/bytebase/backend/plugin/parser/base"-)--// omniQuerySpanExtractor extracts query span information from omni MySQL AST.-// It embeds querySpanExtractor so shared metadata and identifier-resolution-// helpers can be reused as the omni implementation grows.-type omniQuerySpanExtractor struct {- *querySpanExtractor- source string-}--func newOmniQuerySpanExtractor(defaultDatabase string, gCtx base.GetQuerySpanContext, ignoreCaseSensitive bool) *omniQuerySpanExtractor {- return &omniQuerySpanExtractor{- querySpanExtractor: newQuerySpanExtractor(defaultDatabase, gCtx, ignoreCaseSensitive),- }-}--// getOmniQuerySpan is the package-internal omni entry point used by migration-// tests and the production MySQL query-span path after cutover.-func (q *omniQuerySpanExtractor) getOmniQuerySpan(ctx context.Context, statement string) (*base.QuerySpan, error) {- q.ctx = ctx- q.source = statement-- stmts, err := ParseMySQLOmni(statement)- if err != nil {- return nil, err- }- if stmts == nil || len(stmts.Items) == 0 {- return &base.QuerySpan{- Type: base.Select,- SourceColumns: base.SourceColumnSet{},- Results: []base.QuerySpanResult{},- PredicateColumns: base.SourceColumnSet{},- }, nil- }- if len(stmts.Items) != 1 {- return nil, errors.Errorf("expected exactly 1 statement, got %d", len(stmts.Items))- }-- root := stmts.Items[0]- accessTables := collectOmniAccessTables(root, q.defaultDatabase, q.gCtx.Engine == storepb.Engine_STARROCKS)- allSystems, mixed := isMixedQuery(accessTables, q.ignoreCaseSensitive)- if mixed {- return nil, base.MixUserSystemTablesError- }-- queryType := classifyOmniQueryType(root, allSystems, q.source)- if allSystems {- accessTables = base.SourceColumnSet{}- }- resultSourceColumns := accessTables- if queryType != base.Select {- resultSourceColumns = base.SourceColumnSet{}- }-- var results []base.QuerySpanResult- if queryType == base.Select {- tableSource, err := q.extractOmniSelectRoot(root)- if err != nil {- var resourceNotFound *base.ResourceNotFoundError- if errors.As(err, &resourceNotFound) {- return &base.QuerySpan{- Type: base.Select,- SourceColumns: accessTables,- Results: []base.QuerySpanResult{},- PredicateColumns: base.SourceColumnSet{},- NotFoundError: resourceNotFound,- }, nil- }- return nil, err- }- results = tableSource.GetQuerySpanResult()- }- return &base.QuerySpan{- Type: queryType,- SourceColumns: resultSourceColumns,- Results: results,- PredicateColumns: base.SourceColumnSet{},- }, nil-}--func (q *omniQuerySpanExtractor) extractOmniSelectRoot(root ast.Node) (*base.PseudoTable, error) {- switch n := root.(type) {- case *ast.SelectStmt:- return q.extractOmniSelectStmt(n)- case *ast.ExplainStmt:- return &base.PseudoTable{}, nil- case *ast.TableStmt:- return q.extractOmniTableStmt(n)- case *ast.ValuesStmt:- return q.extractOmniValuesStmt(n)- default:- return &base.PseudoTable{}, nil- }-}--func (q *omniQuerySpanExtractor) extractOmniSelectStmt(stmt *ast.SelectStmt) (*base.PseudoTable, error) {- if stmt == nil {- return &base.PseudoTable{}, nil- }- if stmt.Into != nil {- return nil, errors.New("meet unsupported select statement with into")- }-- originalTableSourceFrom := q.tableSourceFrom- originalPriorLength := len(q.priorTableInFrom)- originalCTELength := len(q.ctes)- defer func() {- q.tableSourceFrom = originalTableSourceFrom- q.priorTableInFrom = q.priorTableInFrom[:originalPriorLength]- q.ctes = q.ctes[:originalCTELength]- }()-- if err := q.processOmniCTEs(stmt.CTEs); err != nil {- return nil, err- }- if inner := stmt.ParenSource; inner != nil {- return q.extractOmniSelectStmt(inner)- }- if tableStmt := stmt.TableSource; tableStmt != nil {- return q.extractOmniTableStmt(tableStmt)- }- if valuesStmt := stmt.ValuesSource; valuesStmt != nil {- return q.extractOmniValuesStmt(valuesStmt)- }- if stmt.SetOp != ast.SetOpNone {- return q.extractOmniSetOp(stmt)- }-- fromSources, err := q.extractOmniTableSources(stmt.From)- if err != nil {- return nil, err- }- q.tableSourceFrom = append(q.tableSourceFrom, fromSources...)-- results, err := q.extractOmniTargetList(stmt.TargetList, fromSources)- if err != nil {- return nil, err- }- return &base.PseudoTable{- Columns: results,- }, nil-}--func (q *omniQuerySpanExtractor) extractOmniTableStmt(stmt *ast.TableStmt) (*base.PseudoTable, error) {- if stmt == nil || stmt.Table == nil {- return &base.PseudoTable{}, nil- }- if stmt.Into != nil {- return nil, errors.New("meet unsupported table statement with into")- }- tableSource, err := q.findTableSchema(stmt.Table.Schema, stmt.Table.Name)- if err != nil {- return nil, err- }- return &base.PseudoTable{Columns: tableSource.GetQuerySpanResult()}, nil-}--func (q *omniQuerySpanExtractor) extractOmniValuesStmt(stmt *ast.ValuesStmt) (*base.PseudoTable, error) {- if stmt == nil || len(stmt.Rows) == 0 {- return &base.PseudoTable{}, nil- }- var columns []base.QuerySpanResult- for _, expr := range stmt.Rows[0] {- field, err := q.extractOmniExpr(expr)- if err != nil {- return nil, err- }- columns = append(columns, field)- }- return &base.PseudoTable{Columns: columns}, nil-}--func (q *omniQuerySpanExtractor) extractOmniSetOp(stmt *ast.SelectStmt) (*base.PseudoTable, error) {- if stmt == nil || stmt.SetOp == ast.SetOpNone {- return q.extractOmniSelectStmt(stmt)- }- left, err := q.extractOmniSelectStmt(stmt.Left)- if err != nil {- return nil, err- }- right, err := q.extractOmniSelectStmt(stmt.Right)- if err != nil {- return nil, err- }- leftResults := left.GetQuerySpanResult()- rightResults := right.GetQuerySpanResult()- if len(leftResults) != len(rightResults) {- return nil, errors.Errorf("MySQL UNION operator left has %d fields, right has %d fields", len(leftResults), len(rightResults))- }- results := make([]base.QuerySpanResult, 0, len(leftResults))- for i := range leftResults {- sourceColumns, _ := base.MergeSourceColumnSet(leftResults[i].SourceColumns, rightResults[i].SourceColumns)- results = append(results, base.QuerySpanResult{- Name: leftResults[i].Name,- SourceColumns: sourceColumns,- IsPlainField: false,- })- }- return &base.PseudoTable{Columns: results}, nil-}--func (q *omniQuerySpanExtractor) processOmniCTEs(ctes []*ast.CommonTableExpr) error {- for _, cte := range ctes {- tableSource, err := q.extractOmniCTE(cte)- if err != nil {- return err- }- if tableSource != nil {- q.ctes = append(q.ctes, tableSource)- }- }- return nil-}--func (q *omniQuerySpanExtractor) extractOmniCTE(cte *ast.CommonTableExpr) (*base.PseudoTable, error) {- if cte == nil {- return nil, nil- }- if cte.Recursive {- return q.extractOmniRecursiveCTE(cte)- }- return q.extractOmniNonRecursiveCTE(cte)-}--func (q *omniQuerySpanExtractor) extractOmniNonRecursiveCTE(cte *ast.CommonTableExpr) (*base.PseudoTable, error) {- tableSource, err := q.extractOmniSelectStmt(cte.Select)- if err != nil {- return nil, err- }- results := cloneOmniQuerySpanResults(tableSource.GetQuerySpanResult())- if len(cte.Columns) > 0 {- if len(cte.Columns) != len(results) {- return nil, errors.Errorf("MySQL CTE column list should have the same length, but got %d and %d", len(cte.Columns), len(results))- }- for i := range cte.Columns {- results[i].Name = cte.Columns[i]- }- }- return &base.PseudoTable{Name: cte.Name, Columns: results}, nil-}--func (q *omniQuerySpanExtractor) extractOmniRecursiveCTE(cte *ast.CommonTableExpr) (*base.PseudoTable, error) {- selectStmt := ast.UnwrapParenSource(cte.Select)- if selectStmt == nil || selectStmt.SetOp == ast.SetOpNone {- return q.extractOmniNonRecursiveCTE(cte)- }- initialTable, err := q.extractOmniRecursiveCTEAnchor(selectStmt)- if err != nil {- return nil, err- }- results := cloneOmniQuerySpanResults(initialTable.GetQuerySpanResult())- if len(cte.Columns) > 0 {- if len(cte.Columns) != len(results) {- return nil, errors.Errorf("The common table expression and column names list have different column counts")- }- for i := range cte.Columns {- results[i].Name = cte.Columns[i]- }- }- cteInfo := &base.PseudoTable{Name: cte.Name, Columns: results}- q.ctes = append(q.ctes, cteInfo)- defer func() {- q.ctes = q.ctes[:len(q.ctes)-1]- }()-- for {- recursiveTable, err := q.extractOmniSelectStmt(cte.Select)- if err != nil {- return nil, err- }- recursiveResults := recursiveTable.GetQuerySpanResult()- if len(recursiveResults) != len(cteInfo.Columns) {- return nil, errors.Errorf("The common table expression and column names list have different column counts")- }- changed := false- for i := range recursiveResults {- var ok bool- cteInfo.Columns[i].SourceColumns, ok = base.MergeSourceColumnSet(cteInfo.Columns[i].SourceColumns, recursiveResults[i].SourceColumns)- cteInfo.Columns[i].IsPlainField = false- changed = changed || ok- }- if !changed {- break- }- }- return cteInfo, nil-}--func (q *omniQuerySpanExtractor) extractOmniRecursiveCTEAnchor(stmt *ast.SelectStmt) (*base.PseudoTable, error) {- stmt = ast.UnwrapParenSource(stmt)- if stmt == nil || stmt.SetOp == ast.SetOpNone {- return q.extractOmniSelectStmt(stmt)- }- if stmt.Left != nil {- return q.extractOmniRecursiveCTEAnchor(stmt.Left)- }- return q.extractOmniRecursiveCTEAnchor(stmt.Right)-}--func cloneOmniQuerySpanResults(results []base.QuerySpanResult) []base.QuerySpanResult {- clone := make([]base.QuerySpanResult, len(results))- copy(clone, results)- return clone-}--func (q *omniQuerySpanExtractor) extractOmniTableSources(tableExprs []ast.TableExpr) ([]base.TableSource, error) {- var result []base.TableSource- for _, tableExpr := range tableExprs {- tableSource, err := q.extractOmniTableSource(tableExpr)- if err != nil {- return nil, err- }- if tableSource == nil {- continue- }- q.priorTableInFrom = append(q.priorTableInFrom, tableSource)- result = append(result, tableSource)- }- return result, nil-}--func (q *omniQuerySpanExtractor) extractOmniTableSource(tableExpr ast.TableExpr) (base.TableSource, error) {- switch t := tableExpr.(type) {- case nil:- return nil, nil- case *ast.TableRef:- if isOmniDualTable(t) {- return &base.PseudoTable{Name: t.Name}, nil- }- tableSource, err := q.findTableSchema(t.Schema, t.Name)- if err != nil {- return nil, err- }- if t.Alias == "" {- return tableSource, nil- }- return &base.PseudoTable{- Name: t.Alias,- Columns: tableSource.GetQuerySpanResult(),- }, nil- case *ast.SubqueryExpr:- return q.extractOmniSubquery(t)- case *ast.JoinClause:- return q.extractOmniJoin(t)- case *ast.JsonTableExpr:- return q.extractOmniJSONTable(t)- default:- return nil, errors.Errorf("unsupported omni MySQL table source %T", tableExpr)- }-}--func (q *omniQuerySpanExtractor) extractOmniJSONTable(expr *ast.JsonTableExpr) (base.TableSource, error) {- if expr == nil {- return nil, nil- }- name := expr.Alias- if name == "" {- name = q.omniExprName(expr.Expr)- }- field, err := q.extractOmniExpr(expr.Expr)- if err != nil {- return nil, err- }- var columns []base.QuerySpanResult- for _, column := range flattenOmniJSONTableColumns(expr.Columns) {- columns = append(columns, base.QuerySpanResult{- Name: column.Name,- SourceColumns: field.SourceColumns,- IsPlainField: field.IsPlainField,- })- }- return &base.PseudoTable{Name: name, Columns: columns}, nil-}--func flattenOmniJSONTableColumns(columns []*ast.JsonTableColumn) []*ast.JsonTableColumn {- var result []*ast.JsonTableColumn- for _, column := range columns {- if column == nil {- continue- }- if column.Nested {- result = append(result, flattenOmniJSONTableColumns(column.NestedCols)...)- continue- }- result = append(result, column)- }- return result-}--func (q *omniQuerySpanExtractor) extractOmniJoin(join *ast.JoinClause) (base.TableSource, error) {- if join == nil {- return nil, nil- }- left, err := q.extractOmniTableSource(join.Left)- if err != nil {- return nil, err- }- if left != nil {- q.tableSourceFrom = append(q.tableSourceFrom, left)- }- right, err := q.extractOmniTableSource(join.Right)- if err != nil {- return nil, err- }- if right != nil {- q.tableSourceFrom = append(q.tableSourceFrom, right)- }-- var using []string- if condition, ok := join.Condition.(*ast.UsingCondition); ok && condition != nil {- using = condition.Columns- }- return joinTableSources(left, right, omniJoinType(join.Type), using), nil-}--func omniJoinType(joinType ast.JoinType) joinType {- switch joinType {- case ast.JoinInner:- return InnerJoin- case ast.JoinLeft:- return LeftOuterJoin- case ast.JoinRight:- return RightOuterJoin- case ast.JoinCross:- return CrossJoin- case ast.JoinNatural:- return NaturalInnerJoin- case ast.JoinStraight:- return StraightJoin- case ast.JoinNaturalLeft:- return NaturalLeftOuterJoin- case ast.JoinNaturalRight:- return NaturalRightOuterJoin- default:- return Join- }-}--func (q *omniQuerySpanExtractor) extractOmniSubquery(expr *ast.SubqueryExpr) (*base.PseudoTable, error) {- if expr == nil {- return &base.PseudoTable{}, nil- }- subqueryExtractor := q.cloneOmniForSubquery()- if expr.Lateral {- subqueryExtractor.outerTableSources = append(subqueryExtractor.outerTableSources, q.priorTableInFrom...)- }- tableSource, err := subqueryExtractor.extractOmniSelectStmt(expr.Select)- if err != nil {- return nil, err- }- results := cloneOmniQuerySpanResults(tableSource.GetQuerySpanResult())- if len(expr.Columns) > 0 {- if len(expr.Columns) != len(results) {- return nil, errors.Errorf("derived table column list length %d doesn't match result column length %d", len(expr.Columns), len(results))- }- for i := range expr.Columns {- results[i].Name = expr.Columns[i]- }- }- if expr.Alias == "" {- return &base.PseudoTable{Name: tableSource.Name, Columns: results}, nil- }- return &base.PseudoTable{- Name: expr.Alias,- Columns: results,- }, nil-}--func (q *omniQuerySpanExtractor) cloneOmniForSubquery() *omniQuerySpanExtractor {- return &omniQuerySpanExtractor{- querySpanExtractor: &querySpanExtractor{- ctx: q.ctx,- defaultDatabase: q.defaultDatabase,- gCtx: q.gCtx,- ctes: q.ctes,- outerTableSources: append(q.outerTableSources, q.tableSourceFrom...),- tableSourceFrom: []base.TableSource{},- ignoreCaseSensitive: q.ignoreCaseSensitive,- viewResolutionStack: cloneViewResolutionStack(q.viewResolutionStack),- },- source: q.source,- }-}--func (q *omniQuerySpanExtractor) extractOmniTargetList(targets []ast.ExprNode, fromSources []base.TableSource) ([]base.QuerySpanResult, error) {- var result []base.QuerySpanResult- for _, target := range targets {- switch t := target.(type) {- case *ast.ResTarget:- if _, ok := t.Val.(*ast.StarExpr); ok {- fields, err := q.extractOmniTableWild("", "", fromSources)- if err != nil {- return nil, err- }- result = append(result, fields...)- continue- }- if columnRef, ok := t.Val.(*ast.ColumnRef); ok && columnRef.Star {- fields, err := q.extractOmniColumnWild(columnRef, fromSources)- if err != nil {- return nil, err- }- result = append(result, fields...)- continue- }- case *ast.StarExpr:- fields, err := q.extractOmniTableWild("", "", fromSources)- if err != nil {- return nil, err- }- result = append(result, fields...)- continue- case *ast.ColumnRef:- if t.Star {- fields, err := q.extractOmniColumnWild(t, fromSources)- if err != nil {- return nil, err- }- result = append(result, fields...)- continue- }- default:- }-- field, err := q.extractOmniTarget(target)- if err != nil {- return nil, err- }- result = append(result, field)- }- return result, nil-}--func (q *omniQuerySpanExtractor) extractOmniTarget(target ast.ExprNode) (base.QuerySpanResult, error) {- switch t := target.(type) {- case *ast.ResTarget:- field, err := q.extractOmniExpr(t.Val)- if err != nil {- return base.QuerySpanResult{}, err- }- if t.Name != "" {- field.Name = t.Name- }- return field, nil- default:- return q.extractOmniExpr(target)- }-}--func (q *omniQuerySpanExtractor) extractOmniExpr(expr ast.ExprNode) (base.QuerySpanResult, error) {- switch e := expr.(type) {- case nil:- return base.QuerySpanResult{- SourceColumns: base.SourceColumnSet{},- IsPlainField: true,- }, nil- case *ast.ColumnRef:- if e.Star {- return base.QuerySpanResult{}, errors.Errorf("asterisk is not a scalar expression")- }- sourceColumns, err := q.getFieldColumnSource(e.Schema, e.Table, e.Column)- if err != nil {- return base.QuerySpanResult{}, err- }- return base.QuerySpanResult{- Name: e.Column,- SourceColumns: sourceColumns,- IsPlainField: true,- }, nil- case *ast.StarExpr:- return base.QuerySpanResult{}, errors.Errorf("asterisk is not a scalar expression")- case *ast.IntLit, *ast.FloatLit, *ast.StringLit, *ast.BoolLit, *ast.NullLit, *ast.HexLit, *ast.BitLit, *ast.TemporalLit:- return base.QuerySpanResult{- Name: q.omniExprName(e),- SourceColumns: base.SourceColumnSet{},- IsPlainField: true,- }, nil- case *ast.VariableRef:- return base.QuerySpanResult{- Name: q.omniExprName(e),- SourceColumns: base.SourceColumnSet{},- IsPlainField: true,- }, nil- case *ast.ParenExpr:- field, err := q.extractOmniExpr(e.Expr)- if err != nil {- return base.QuerySpanResult{}, err- }- field.Name = q.omniExprName(e)- field.IsPlainField = false- return field, nil- case *ast.BinaryExpr:- sourceColumns, err := q.mergeOmniExprSources(e.Left, e.Right)- if err != nil {- return base.QuerySpanResult{}, err- }- return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil- case *ast.UnaryExpr:- sourceColumns, err := q.mergeOmniExprSources(e.Operand)- if err != nil {- return base.QuerySpanResult{}, err- }- return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil- case *ast.FuncCallExpr:- exprs := append([]ast.ExprNode{}, e.Args...)- exprs = append(exprs, e.Separator)- for _, item := range e.OrderBy {- if item != nil {- exprs = append(exprs, item.Expr)- }- }- if e.Over != nil {- exprs = append(exprs, e.Over.PartitionBy...)- for _, item := range e.Over.OrderBy {- if item != nil {- exprs = append(exprs, item.Expr)- }- }- }- sourceColumns, err := q.mergeOmniExprSources(exprs...)- if err != nil {- return base.QuerySpanResult{}, err- }- return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil- case *ast.SubqueryExpr:- sourceColumns, isPlain, err := q.extractOmniSelectSourceColumns(e.Select)- if err != nil {- return base.QuerySpanResult{}, err- }- return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: isPlain}, nil- case *ast.ExistsExpr:- sourceColumns, _, err := q.extractOmniSelectSourceColumns(e.Select)- if err != nil {- return base.QuerySpanResult{}, err- }- return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil- case *ast.CaseExpr:- var exprs []ast.ExprNode- exprs = append(exprs, e.Operand)- for _, when := range e.Whens {- if when == nil {- continue- }- exprs = append(exprs, when.Cond, when.Result)- }- exprs = append(exprs, e.Default)- sourceColumns, err := q.mergeOmniExprSources(exprs...)- if err != nil {- return base.QuerySpanResult{}, err- }- return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil- case *ast.BetweenExpr:- sourceColumns, err := q.mergeOmniExprSources(e.Expr, e.Low, e.High)- if err != nil {- return base.QuerySpanResult{}, err- }- return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil- case *ast.InExpr:- exprs := append([]ast.ExprNode{e.Expr}, e.List...)- sourceColumns, err := q.mergeOmniExprSources(exprs...)- if err != nil {- return base.QuerySpanResult{}, err- }- if e.Select != nil {- selectSourceColumns, _, err := q.extractOmniSelectSourceColumns(e.Select)- if err != nil {- return base.QuerySpanResult{}, err- }- sourceColumns, _ = base.MergeSourceColumnSet(sourceColumns, selectSourceColumns)- }- return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil- case *ast.LikeExpr:- sourceColumns, err := q.mergeOmniExprSources(e.Expr, e.Pattern, e.Escape)- if err != nil {- return base.QuerySpanResult{}, err- }- return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil- case *ast.IsExpr:- sourceColumns, err := q.mergeOmniExprSources(e.Expr)- if err != nil {- return base.QuerySpanResult{}, err- }- return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil- case *ast.CastExpr:- sourceColumns, err := q.mergeOmniExprSources(e.Expr)- if err != nil {- return base.QuerySpanResult{}, err- }- return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil- case *ast.ExtractExpr:- sourceColumns, err := q.mergeOmniExprSources(e.Expr)- if err != nil {- return base.QuerySpanResult{}, err- }- return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil- case *ast.IntervalExpr:- sourceColumns, err := q.mergeOmniExprSources(e.Value)- if err != nil {- return base.QuerySpanResult{}, err- }- return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil- case *ast.CollateExpr:- sourceColumns, err := q.mergeOmniExprSources(e.Expr)- if err != nil {- return base.QuerySpanResult{}, err- }- return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil- case *ast.MatchExpr:- exprs := make([]ast.ExprNode, 0, len(e.Columns)+1)- for _, column := range e.Columns {- exprs = append(exprs, column)- }- exprs = append(exprs, e.Against)- sourceColumns, err := q.mergeOmniExprSources(exprs...)- if err != nil {- return base.QuerySpanResult{}, err- }- return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil- case *ast.ConvertExpr:- sourceColumns, err := q.mergeOmniExprSources(e.Expr)- if err != nil {- return base.QuerySpanResult{}, err- }- return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil- case *ast.DefaultExpr:- return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: base.SourceColumnSet{}, IsPlainField: true}, nil- case *ast.RowExpr:- sourceColumns, err := q.mergeOmniExprSources(e.Items...)- if err != nil {- return base.QuerySpanResult{}, err- }- return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil- case *ast.MemberOfExpr:- sourceColumns, err := q.mergeOmniExprSources(e.Value, e.Array)- if err != nil {- return base.QuerySpanResult{}, err- }- return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil- case *ast.KeywordArg:- // Keyword arguments (TIMESTAMPDIFF(SECOND, ...), GET_FORMAT(DATE, ...))- // are unit selectors, not column references — no lineage.- return base.QuerySpanResult{Name: e.Keyword, SourceColumns: base.SourceColumnSet{}, IsPlainField: false}, nil- case *ast.WeightStringExpr:- sourceColumns, err := q.mergeOmniExprSources(e.Expr)- if err != nil {- return base.QuerySpanResult{}, err- }- return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil- default:- return base.QuerySpanResult{}, errors.Errorf("unsupported omni MySQL expression %T", expr)- }-}--func (q *omniQuerySpanExtractor) extractOmniSelectSourceColumns(selectStmt *ast.SelectStmt) (base.SourceColumnSet, bool, error) {- subqueryExtractor := q.cloneOmniForSubquery()- tableSource, err := subqueryExtractor.extractOmniSelectStmt(selectStmt)- if err != nil {- return nil, false, err- }- spanResults := tableSource.GetQuerySpanResult()- sourceColumns := make(base.SourceColumnSet)- for _, field := range spanResults {- sourceColumns, _ = base.MergeSourceColumnSet(sourceColumns, field.SourceColumns)- }- isPlain := false- if len(spanResults) == 1 {- isPlain = spanResults[0].IsPlainField- }- return sourceColumns, isPlain, nil-}--func (q *omniQuerySpanExtractor) mergeOmniExprSources(exprs ...ast.ExprNode) (base.SourceColumnSet, error) {- result := make(base.SourceColumnSet)- for _, expr := range exprs {- if expr == nil {- continue- }- field, err := q.extractOmniExpr(expr)- if err != nil {- return nil, err- }- result, _ = base.MergeSourceColumnSet(result, field.SourceColumns)- }- return result, nil-}--func (q *omniQuerySpanExtractor) extractOmniColumnWild(columnRef *ast.ColumnRef, fromSources []base.TableSource) ([]base.QuerySpanResult, error) {- if columnRef == nil {- return nil, nil- }- return q.extractOmniTableWild(columnRef.Schema, columnRef.Table, fromSources)-}--func (q *omniQuerySpanExtractor) extractOmniTableWild(databaseName, tableName string, fromSources []base.TableSource) ([]base.QuerySpanResult, error) {- if databaseName == "" && tableName == "" {- var result []base.QuerySpanResult- for _, fromSource := range fromSources {- result = append(result, fromSource.GetQuerySpanResult()...)- }- return result, nil- }-- result, ok := q.getAllTableColumnSources(databaseName, tableName)- if !ok {- return nil, &base.ResourceNotFoundError{- Database: &databaseName,- Table: &tableName,- }- }- return result, nil-}--func (q *omniQuerySpanExtractor) omniExprName(expr ast.ExprNode) string {- switch e := expr.(type) {- case *ast.ColumnRef:- var parts []string- if e.Schema != "" {- parts = append(parts, e.Schema)- }- if e.Table != "" {- parts = append(parts, e.Table)- }- if e.Star {- parts = append(parts, "*")- } else {- parts = append(parts, e.Column)- }- return strings.Join(parts, ".")- case *ast.BinaryExpr:- return q.omniExprName(e.Left) + omniBinaryOpName(e) + q.omniExprName(e.Right)- case *ast.InExpr:- var list []string- for _, expr := range e.List {- list = append(list, q.omniExprName(expr))- }- operator := " in "- if e.Not {- operator = " not in "- }- return q.omniExprName(e.Expr) + operator + "(" + strings.Join(list, ", ") + ")"- case *ast.IntLit:- if name := q.omniSlice(e.Loc); name != "" {- return name- }- return strconv.FormatInt(e.Value, 10)- case *ast.FloatLit:- if name := q.omniSlice(e.Loc); name != "" {- return name- }- return e.Value- case *ast.StringLit:- if name := q.omniSlice(e.Loc); name != "" {- return name- }- return e.Value- case *ast.BoolLit:- if name := q.omniSlice(e.Loc); name != "" {- return name- }- return strconv.FormatBool(e.Value)- case *ast.NullLit:- if name := q.omniSlice(e.Loc); name != "" {- return name- }- return "NULL"- case *ast.HexLit:- if name := q.omniSlice(e.Loc); name != "" {- return name- }- return e.Value- case *ast.BitLit:- if name := q.omniSlice(e.Loc); name != "" {- return name- }- return e.Value- case *ast.TemporalLit:- if name := q.omniSlice(e.Loc); name != "" {- return name- }- return e.Value- default:- if loc, ok := omniNodeLoc(e); ok {- return q.omniSlice(loc)- }- return ""- }-}--func omniBinaryOpName(expr *ast.BinaryExpr) string {- if expr == nil {- return ""- }- if expr.OriginalOp != "" {- return expr.OriginalOp- }- return omniBinaryOpNames[expr.Op]-}--var omniBinaryOpNames = map[ast.BinaryOp]string{- ast.BinOpAdd: "+",- ast.BinOpSub: "-",- ast.BinOpMul: "*",- ast.BinOpDiv: "/",- ast.BinOpMod: "%",- ast.BinOpEq: "=",- ast.BinOpNe: "!=",- ast.BinOpLt: "<",- ast.BinOpGt: ">",- ast.BinOpLe: "<=",- ast.BinOpGe: ">=",- ast.BinOpAnd: " and ",- ast.BinOpOr: " or ",- ast.BinOpXor: " xor ",- ast.BinOpBitAnd: "&",- ast.BinOpBitOr: "|",- ast.BinOpBitXor: "^",- ast.BinOpShiftLeft: "<<",- ast.BinOpShiftRight: ">>",- ast.BinOpDivInt: " div ",- ast.BinOpRegexp: " regexp ",- ast.BinOpLikeEscape: " like ",- ast.BinOpNullSafeEq: "<=>",- ast.BinOpAssign: ":=",- ast.BinOpJsonExtract: "->",- ast.BinOpJsonUnquote: "->>",- ast.BinOpSoundsLike: " sounds like ",-}--func (q *omniQuerySpanExtractor) omniSlice(loc ast.Loc) string {- if loc.Start < 0 || loc.End <= loc.Start || loc.End > len(q.source) {- return ""- }- return strings.TrimSpace(q.source[loc.Start:loc.End])-}--func omniNodeLoc(node ast.Node) (ast.Loc, bool) {- if loc, ok := omniExprNodeLoc(node); ok {- return loc, true- }- return omniLiteralNodeLoc(node)-}--func omniExprNodeLoc(node ast.Node) (ast.Loc, bool) {- switch n := node.(type) {- case *ast.ResTarget:- return n.Loc, true- case *ast.ColumnRef:- return n.Loc, true- case *ast.BinaryExpr:- return n.Loc, true- case *ast.UnaryExpr:- return n.Loc, true- case *ast.FuncCallExpr:- return n.Loc, true- case *ast.SubqueryExpr:- return n.Loc, true- case *ast.CaseExpr:- return n.Loc, true- case *ast.BetweenExpr:- return n.Loc, true- case *ast.InExpr:- return n.Loc, true- case *ast.LikeExpr:- return n.Loc, true- case *ast.IsExpr:- return n.Loc, true- case *ast.ExistsExpr:- return n.Loc, true- case *ast.CastExpr:- return n.Loc, true- case *ast.ExtractExpr:- return n.Loc, true- case *ast.IntervalExpr:- return n.Loc, true- case *ast.CollateExpr:- return n.Loc, true- case *ast.MatchExpr:- return n.Loc, true- case *ast.ConvertExpr:- return n.Loc, true- case *ast.DefaultExpr:- return n.Loc, true- case *ast.RowExpr:- return n.Loc, true- case *ast.MemberOfExpr:- return n.Loc, true- case *ast.ParenExpr:- return n.Loc, true- case *ast.StarExpr:- return n.Loc, true- default:- return ast.Loc{}, false- }-}--func omniLiteralNodeLoc(node ast.Node) (ast.Loc, bool) {- switch n := node.(type) {- case *ast.IntLit:- return n.Loc, true- case *ast.FloatLit:- return n.Loc, true- case *ast.StringLit:- return n.Loc, true- case *ast.BoolLit:- return n.Loc, true- case *ast.NullLit:- return n.Loc, true- case *ast.HexLit:- return n.Loc, true- case *ast.BitLit:- return n.Loc, true- case *ast.TemporalLit:- return n.Loc, true- case *ast.VariableRef:- return n.Loc, true- default:- return ast.Loc{}, false- }-}--func classifyOmniQueryType(node ast.Node, allSystems bool, source string) base.QueryType {- switch n := node.(type) {- case *ast.SelectStmt, *ast.TableStmt, *ast.ValuesStmt:- if allSystems {- return base.SelectInfoSchema- }- return base.Select- case *ast.ExplainStmt:- if isOmniDescribeStatement(source, n.Loc) {- return base.SelectInfoSchema- }- if n.Analyze {- switch n.Stmt.(type) {- case *ast.SelectStmt, *ast.TableStmt, *ast.ValuesStmt:- return base.Select- default:- return base.DML- }- }- return base.Explain- case *ast.ShowStmt:- return base.SelectInfoSchema- case *ast.SetStmt, *ast.SetDefaultRoleStmt, *ast.SetResourceGroupStmt, *ast.SetRoleStmt, *ast.SetTransactionStmt:- return base.Select- case *ast.SetPasswordStmt, *ast.HelpStmt:- return base.QueryTypeUnknown- case *ast.CreateDatabaseStmt, *ast.CreateTableStmt, *ast.CreateIndexStmt, *ast.CreateViewStmt,- *ast.CreateEventStmt, *ast.CreateTriggerStmt, *ast.CreateFunctionStmt,- *ast.CreateUserStmt, *ast.CreateRoleStmt, *ast.CreateTablespaceStmt, *ast.CreateServerStmt,- *ast.CreateLogfileGroupStmt, *ast.CreateSpatialRefSysStmt, *ast.CreateResourceGroupStmt,- *ast.AlterDatabaseStmt, *ast.AlterTableStmt, *ast.AlterViewStmt, *ast.AlterEventStmt,- *ast.AlterUserStmt, *ast.AlterRoutineStmt, *ast.AlterTablespaceStmt, *ast.AlterServerStmt,- *ast.AlterLogfileGroupStmt, *ast.AlterResourceGroupStmt, *ast.AlterInstanceStmt,- *ast.DropDatabaseStmt, *ast.DropTableStmt, *ast.DropIndexStmt, *ast.DropViewStmt,- *ast.DropEventStmt, *ast.DropTriggerStmt, *ast.DropRoutineStmt,- *ast.DropUserStmt, *ast.DropRoleStmt, *ast.DropTablespaceStmt, *ast.DropServerStmt,- *ast.DropLogfileGroupStmt, *ast.DropSpatialRefSysStmt, *ast.DropResourceGroupStmt,- *ast.RenameTableStmt, *ast.RenameUserStmt, *ast.TruncateStmt, *ast.ImportTableStmt,- *ast.GrantStmt, *ast.RevokeStmt, *ast.GrantRoleStmt, *ast.RevokeRoleStmt,- *ast.InstallPluginStmt, *ast.UninstallPluginStmt, *ast.InstallComponentStmt,- *ast.UninstallComponentStmt, *ast.CloneStmt:- return base.DDL- case *ast.InsertStmt, *ast.UpdateStmt, *ast.DeleteStmt, *ast.BeginStmt, *ast.CommitStmt,- *ast.RollbackStmt, *ast.SavepointStmt, *ast.LockTablesStmt, *ast.UnlockTablesStmt,- *ast.LoadDataStmt, *ast.PrepareStmt, *ast.ExecuteStmt, *ast.DeallocateStmt,- *ast.CallStmt, *ast.DoStmt, *ast.HandlerOpenStmt, *ast.HandlerReadStmt, *ast.HandlerCloseStmt,- *ast.AnalyzeTableStmt, *ast.OptimizeTableStmt, *ast.CheckTableStmt, *ast.RepairTableStmt,- *ast.FlushStmt, *ast.KillStmt, *ast.ShutdownStmt, *ast.RestartStmt, *ast.XAStmt,- *ast.SignalStmt, *ast.ResignalStmt, *ast.GetDiagnosticsStmt, *ast.DeclareVarStmt,- *ast.DeclareConditionStmt, *ast.DeclareHandlerStmt, *ast.DeclareCursorStmt,- *ast.IfStmt, *ast.WhileStmt, *ast.RepeatStmt, *ast.LoopStmt, *ast.LeaveStmt,- *ast.IterateStmt, *ast.ReturnStmt, *ast.OpenCursorStmt, *ast.FetchCursorStmt,- *ast.CloseCursorStmt, *ast.LockInstanceStmt, *ast.UnlockInstanceStmt, *ast.BinlogStmt,- *ast.CacheIndexStmt, *ast.LoadIndexIntoCacheStmt, *ast.ResetPersistStmt,- *ast.ChangeReplicationSourceStmt, *ast.ChangeReplicationFilterStmt,- *ast.StartReplicaStmt, *ast.StopReplicaStmt, *ast.ResetReplicaStmt,- *ast.PurgeBinaryLogsStmt, *ast.ResetMasterStmt,- *ast.StartGroupReplicationStmt, *ast.StopGroupReplicationStmt:- return base.DML- default:- return base.QueryTypeUnknown- }-}--func isOmniDescribeStatement(source string, loc ast.Loc) bool {- statement := strings.TrimSpace(source)- if loc.Start >= 0 && loc.End > loc.Start && loc.End <= len(source) {- statement = strings.TrimSpace(source[loc.Start:loc.End])- }- upper := strings.ToUpper(statement)- fields := strings.Fields(upper)- return len(fields) > 0 && (fields[0] == "DESCRIBE" || fields[0] == "DESC")-}--func collectOmniAccessTables(root ast.Node, defaultDatabase string, normalizeStarRocksCluster bool) base.SourceColumnSet {- result := make(base.SourceColumnSet)- collectOmniAccessTablesFromNode(result, root, defaultDatabase, normalizeStarRocksCluster)- return result-}--func collectOmniAccessTablesFromNode(result base.SourceColumnSet, node ast.Node, defaultDatabase string, normalizeStarRocksCluster bool) {- switch n := node.(type) {- case nil:- case *ast.SelectStmt:- if n == nil {- return- }- for _, cte := range n.CTEs {- if cte != nil {- collectOmniAccessTablesFromNode(result, cte.Select, defaultDatabase, normalizeStarRocksCluster)- }- }- if n.Left != nil {- collectOmniAccessTablesFromNode(result, n.Left, defaultDatabase, normalizeStarRocksCluster)- }- if n.Right != nil {- collectOmniAccessTablesFromNode(result, n.Right, defaultDatabase, normalizeStarRocksCluster)- }- if inner := n.ParenSource; inner != nil {- collectOmniAccessTablesFromNode(result, inner, defaultDatabase, normalizeStarRocksCluster)- }- if tableStmt := n.TableSource; tableStmt != nil {- collectOmniAccessTablesFromNode(result, tableStmt, defaultDatabase, normalizeStarRocksCluster)- }- if valuesStmt := n.ValuesSource; valuesStmt != nil {- collectOmniAccessTablesFromNode(result, valuesStmt, defaultDatabase, normalizeStarRocksCluster)- }- for _, target := range n.TargetList {- collectOmniAccessTablesFromExpr(result, target, defaultDatabase, normalizeStarRocksCluster)- }- for _, tableExpr := range n.From {- collectOmniAccessTablesFromTableExpr(result, tableExpr, defaultDatabase, normalizeStarRocksCluster)- }- collectOmniAccessTablesFromExpr(result, n.Where, defaultDatabase, normalizeStarRocksCluster)- for _, groupBy := range n.GroupBy {- collectOmniAccessTablesFromExpr(result, groupBy, defaultDatabase, normalizeStarRocksCluster)- }- collectOmniAccessTablesFromExpr(result, n.Having, defaultDatabase, normalizeStarRocksCluster)- for _, orderBy := range n.OrderBy {- if orderBy != nil {- collectOmniAccessTablesFromExpr(result, orderBy.Expr, defaultDatabase, normalizeStarRocksCluster)- }- }- case *ast.ExplainStmt:- collectOmniAccessTablesFromNode(result, n.Stmt, defaultDatabase, normalizeStarRocksCluster)- case *ast.InsertStmt:- collectOmniAccessTablesFromTableRef(result, n.Table, defaultDatabase, normalizeStarRocksCluster)- for _, row := range n.Values {- for _, expr := range row {- collectOmniAccessTablesFromExpr(result, expr, defaultDatabase, normalizeStarRocksCluster)- }- }- collectOmniAccessTablesFromNode(result, n.Select, defaultDatabase, normalizeStarRocksCluster)- collectOmniAccessTablesFromNode(result, n.TableSource, defaultDatabase, normalizeStarRocksCluster)- for _, assignment := range n.SetList {- if assignment != nil {- collectOmniAccessTablesFromExpr(result, assignment.Value, defaultDatabase, normalizeStarRocksCluster)- }- }- for _, assignment := range n.OnDuplicateKey {- if assignment != nil {- collectOmniAccessTablesFromExpr(result, assignment.Value, defaultDatabase, normalizeStarRocksCluster)- }- }- case *ast.UpdateStmt:- for _, tableExpr := range n.Tables {- collectOmniAccessTablesFromTableExpr(result, tableExpr, defaultDatabase, normalizeStarRocksCluster)- }- for _, assignment := range n.SetList {- if assignment != nil {- collectOmniAccessTablesFromExpr(result, assignment.Value, defaultDatabase, normalizeStarRocksCluster)- }- }- collectOmniAccessTablesFromExpr(result, n.Where, defaultDatabase, normalizeStarRocksCluster)- for _, orderBy := range n.OrderBy {- if orderBy != nil {- collectOmniAccessTablesFromExpr(result, orderBy.Expr, defaultDatabase, normalizeStarRocksCluster)- }- }- case *ast.DeleteStmt:- for _, tableExpr := range n.Tables {- collectOmniAccessTablesFromTableExpr(result, tableExpr, defaultDatabase, normalizeStarRocksCluster)- }- for _, tableExpr := range n.Using {- collectOmniAccessTablesFromTableExpr(result, tableExpr, defaultDatabase, normalizeStarRocksCluster)- }- collectOmniAccessTablesFromExpr(result, n.Where, defaultDatabase, normalizeStarRocksCluster)- for _, orderBy := range n.OrderBy {- if orderBy != nil {- collectOmniAccessTablesFromExpr(result, orderBy.Expr, defaultDatabase, normalizeStarRocksCluster)- }- }- case *ast.CreateTableStmt:- collectOmniAccessTablesFromTableRef(result, n.Table, defaultDatabase, normalizeStarRocksCluster)- collectOmniAccessTablesFromTableRef(result, n.Like, defaultDatabase, normalizeStarRocksCluster)- collectOmniAccessTablesFromNode(result, n.Select, defaultDatabase, normalizeStarRocksCluster)- case *ast.CreateIndexStmt:- collectOmniAccessTablesFromTableRef(result, n.Table, defaultDatabase, normalizeStarRocksCluster)- for _, column := range n.Columns {- if column != nil {- collectOmniAccessTablesFromExpr(result, column.Expr, defaultDatabase, normalizeStarRocksCluster)- }- }- case *ast.CreateViewStmt:- collectOmniAccessTablesFromTableRef(result, n.Name, defaultDatabase, normalizeStarRocksCluster)- collectOmniAccessTablesFromNode(result, n.Select, defaultDatabase, normalizeStarRocksCluster)- case *ast.AlterTableStmt:- collectOmniAccessTablesFromTableRef(result, n.Table, defaultDatabase, normalizeStarRocksCluster)- for _, command := range n.Commands {- if command == nil {- continue- }- collectOmniAccessTablesFromExpr(result, command.DefaultExpr, defaultDatabase, normalizeStarRocksCluster)- collectOmniAccessTablesFromTableRef(result, command.ExchangeTable, defaultDatabase, normalizeStarRocksCluster)- collectOmniAccessTablesFromOrderBy(result, command.OrderByItems, defaultDatabase, normalizeStarRocksCluster)- }- case *ast.DropTableStmt:- collectOmniAccessTablesFromTableRefs(result, n.Tables, defaultDatabase, normalizeStarRocksCluster)- case *ast.DropIndexStmt:- collectOmniAccessTablesFromTableRef(result, n.Table, defaultDatabase, normalizeStarRocksCluster)- case *ast.DropViewStmt:- collectOmniAccessTablesFromTableRefs(result, n.Views, defaultDatabase, normalizeStarRocksCluster)- case *ast.RenameTableStmt:- for _, pair := range n.Pairs {- if pair == nil {- continue- }- collectOmniAccessTablesFromTableRef(result, pair.Old, defaultDatabase, normalizeStarRocksCluster)- collectOmniAccessTablesFromTableRef(result, pair.New, defaultDatabase, normalizeStarRocksCluster)- }- case *ast.TruncateStmt:- collectOmniAccessTablesFromTableRefs(result, n.Tables, defaultDatabase, normalizeStarRocksCluster)- case *ast.AnalyzeTableStmt:- collectOmniAccessTablesFromTableRefs(result, n.Tables, defaultDatabase, normalizeStarRocksCluster)- case *ast.OptimizeTableStmt:- collectOmniAccessTablesFromTableRefs(result, n.Tables, defaultDatabase, normalizeStarRocksCluster)- case *ast.CheckTableStmt:- collectOmniAccessTablesFromTableRefs(result, n.Tables, defaultDatabase, normalizeStarRocksCluster)- case *ast.RepairTableStmt:- collectOmniAccessTablesFromTableRefs(result, n.Tables, defaultDatabase, normalizeStarRocksCluster)- case *ast.TableStmt:- if n == nil {- return- }- collectOmniAccessTablesFromTableRef(result, n.Table, defaultDatabase, normalizeStarRocksCluster)- collectOmniAccessTablesFromOrderBy(result, n.OrderBy, defaultDatabase, normalizeStarRocksCluster)- collectOmniAccessTablesFromLimit(result, n.Limit, defaultDatabase, normalizeStarRocksCluster)- case *ast.ValuesStmt:- for _, row := range n.Rows {- for _, expr := range row {- collectOmniAccessTablesFromExpr(result, expr, defaultDatabase, normalizeStarRocksCluster)- }- }- collectOmniAccessTablesFromOrderBy(result, n.OrderBy, defaultDatabase, normalizeStarRocksCluster)- collectOmniAccessTablesFromLimit(result, n.Limit, defaultDatabase, normalizeStarRocksCluster)- case *ast.CallStmt:- for _, arg := range n.Args {- collectOmniAccessTablesFromExpr(result, arg, defaultDatabase, normalizeStarRocksCluster)- }- case *ast.SetStmt:- for _, assignment := range n.Assignments {- if assignment != nil {- collectOmniAccessTablesFromExpr(result, assignment.Value, defaultDatabase, normalizeStarRocksCluster)- }- }- case *ast.DoStmt:- for _, expr := range n.Exprs {- collectOmniAccessTablesFromExpr(result, expr, defaultDatabase, normalizeStarRocksCluster)- }- case *ast.HandlerOpenStmt:- collectOmniAccessTablesFromTableRef(result, n.Table, defaultDatabase, normalizeStarRocksCluster)- case *ast.HandlerReadStmt:- collectOmniAccessTablesFromTableRef(result, n.Table, defaultDatabase, normalizeStarRocksCluster)- collectOmniAccessTablesFromExpr(result, n.Where, defaultDatabase, normalizeStarRocksCluster)- case *ast.HandlerCloseStmt:- collectOmniAccessTablesFromTableRef(result, n.Table, defaultDatabase, normalizeStarRocksCluster)- case *ast.LockTablesStmt:- for _, table := range n.Tables {- if table != nil {- collectOmniAccessTablesFromTableRef(result, table.Table, defaultDatabase, normalizeStarRocksCluster)- }- }- default:- }-}--func collectOmniAccessTablesFromOrderBy(result base.SourceColumnSet, orderByItems []*ast.OrderByItem, defaultDatabase string, normalizeStarRocksCluster bool) {- for _, orderBy := range orderByItems {- if orderBy != nil {- collectOmniAccessTablesFromExpr(result, orderBy.Expr, defaultDatabase, normalizeStarRocksCluster)- }- }-}--func collectOmniAccessTablesFromLimit(result base.SourceColumnSet, limit *ast.Limit, defaultDatabase string, normalizeStarRocksCluster bool) {- if limit == nil {- return- }- collectOmniAccessTablesFromExpr(result, limit.Count, defaultDatabase, normalizeStarRocksCluster)- collectOmniAccessTablesFromExpr(result, limit.Offset, defaultDatabase, normalizeStarRocksCluster)-}--func collectOmniAccessTablesFromTableRefs(result base.SourceColumnSet, tableRefs []*ast.TableRef, defaultDatabase string, normalizeStarRocksCluster bool) {- for _, tableRef := range tableRefs {- collectOmniAccessTablesFromTableRef(result, tableRef, defaultDatabase, normalizeStarRocksCluster)- }-}--func collectOmniAccessTablesFromTableRef(result base.SourceColumnSet, tableRef *ast.TableRef, defaultDatabase string, normalizeStarRocksCluster bool) {- if tableRef == nil {- return- }- if isOmniDualTable(tableRef) {- return- }- database := tableRef.Schema- if database == "" {- database = defaultDatabase- } else if normalizeStarRocksCluster {- database = filterStarRocksClusterName(database)- }- result[base.ColumnResource{- Database: database,- Table: tableRef.Name,- }] = true-}--func isOmniDualTable(tableRef *ast.TableRef) bool {- return tableRef != nil && tableRef.Schema == "" && strings.EqualFold(tableRef.Name, "dual")-}--func collectOmniAccessTablesFromTableExpr(result base.SourceColumnSet, tableExpr ast.TableExpr, defaultDatabase string, normalizeStarRocksCluster bool) {- switch n := tableExpr.(type) {- case *ast.TableRef:- collectOmniAccessTablesFromTableRef(result, n, defaultDatabase, normalizeStarRocksCluster)- case *ast.JoinClause:- collectOmniAccessTablesFromTableExpr(result, n.Left, defaultDatabase, normalizeStarRocksCluster)- collectOmniAccessTablesFromTableExpr(result, n.Right, defaultDatabase, normalizeStarRocksCluster)- switch condition := n.Condition.(type) {- case *ast.OnCondition:- collectOmniAccessTablesFromExpr(result, condition.Expr, defaultDatabase, normalizeStarRocksCluster)- default:- }- case *ast.SubqueryExpr:- collectOmniAccessTablesFromNode(result, n.Select, defaultDatabase, normalizeStarRocksCluster)- case *ast.JsonTableExpr:- collectOmniAccessTablesFromExpr(result, n.Expr, defaultDatabase, normalizeStarRocksCluster)- collectOmniAccessTablesFromExpr(result, n.Path, defaultDatabase, normalizeStarRocksCluster)- default:- }-}--func collectOmniAccessTablesFromExpr(result base.SourceColumnSet, expr ast.ExprNode, defaultDatabase string, normalizeStarRocksCluster bool) {- switch e := expr.(type) {- case nil:- case *ast.ResTarget:- collectOmniAccessTablesFromExpr(result, e.Val, defaultDatabase, normalizeStarRocksCluster)- case *ast.BinaryExpr:- collectOmniAccessTablesFromExpr(result, e.Left, defaultDatabase, normalizeStarRocksCluster)- collectOmniAccessTablesFromExpr(result, e.Right, defaultDatabase, normalizeStarRocksCluster)- case *ast.UnaryExpr:- collectOmniAccessTablesFromExpr(result, e.Operand, defaultDatabase, normalizeStarRocksCluster)- case *ast.FuncCallExpr:- for _, arg := range e.Args {- collectOmniAccessTablesFromExpr(result, arg, defaultDatabase, normalizeStarRocksCluster)- }- collectOmniAccessTablesFromExpr(result, e.Separator, defaultDatabase, normalizeStarRocksCluster)- for _, orderBy := range e.OrderBy {- if orderBy != nil {- collectOmniAccessTablesFromExpr(result, orderBy.Expr, defaultDatabase, normalizeStarRocksCluster)- }- }- if e.Over != nil {- for _, partitionBy := range e.Over.PartitionBy {- collectOmniAccessTablesFromExpr(result, partitionBy, defaultDatabase, normalizeStarRocksCluster)- }- for _, orderBy := range e.Over.OrderBy {- if orderBy != nil {- collectOmniAccessTablesFromExpr(result, orderBy.Expr, defaultDatabase, normalizeStarRocksCluster)- }- }- }- case *ast.SubqueryExpr:- collectOmniAccessTablesFromNode(result, e.Select, defaultDatabase, normalizeStarRocksCluster)- case *ast.CaseExpr:- collectOmniAccessTablesFromExpr(result, e.Operand, defaultDatabase, normalizeStarRocksCluster)- for _, when := range e.Whens {- if when == nil {- continue- }- collectOmniAccessTablesFromExpr(result, when.Cond, defaultDatabase, normalizeStarRocksCluster)- collectOmniAccessTablesFromExpr(result, when.Result, defaultDatabase, normalizeStarRocksCluster)- }- collectOmniAccessTablesFromExpr(result, e.Default, defaultDatabase, normalizeStarRocksCluster)- case *ast.BetweenExpr:- collectOmniAccessTablesFromExpr(result, e.Expr, defaultDatabase, normalizeStarRocksCluster)- collectOmniAccessTablesFromExpr(result, e.Low, defaultDatabase, normalizeStarRocksCluster)- collectOmniAccessTablesFromExpr(result, e.High, defaultDatabase, normalizeStarRocksCluster)- case *ast.InExpr:- collectOmniAccessTablesFromExpr(result, e.Expr, defaultDatabase, normalizeStarRocksCluster)- for _, item := range e.List {- collectOmniAccessTablesFromExpr(result, item, defaultDatabase, normalizeStarRocksCluster)- }- collectOmniAccessTablesFromNode(result, e.Select, defaultDatabase, normalizeStarRocksCluster)- case *ast.LikeExpr:- collectOmniAccessTablesFromExpr(result, e.Expr, defaultDatabase, normalizeStarRocksCluster)- collectOmniAccessTablesFromExpr(result, e.Pattern, defaultDatabase, normalizeStarRocksCluster)- collectOmniAccessTablesFromExpr(result, e.Escape, defaultDatabase, normalizeStarRocksCluster)- case *ast.IsExpr:- collectOmniAccessTablesFromExpr(result, e.Expr, defaultDatabase, normalizeStarRocksCluster)- case *ast.ExistsExpr:- collectOmniAccessTablesFromNode(result, e.Select, defaultDatabase, normalizeStarRocksCluster)- case *ast.CastExpr:- collectOmniAccessTablesFromExpr(result, e.Expr, defaultDatabase, normalizeStarRocksCluster)- case *ast.ExtractExpr:- collectOmniAccessTablesFromExpr(result, e.Expr, defaultDatabase, normalizeStarRocksCluster)- case *ast.IntervalExpr:- collectOmniAccessTablesFromExpr(result, e.Value, defaultDatabase, normalizeStarRocksCluster)- case *ast.CollateExpr:- collectOmniAccessTablesFromExpr(result, e.Expr, defaultDatabase, normalizeStarRocksCluster)- case *ast.MatchExpr:- for _, column := range e.Columns {- collectOmniAccessTablesFromExpr(result, column, defaultDatabase, normalizeStarRocksCluster)- }- collectOmniAccessTablesFromExpr(result, e.Against, defaultDatabase, normalizeStarRocksCluster)- case *ast.ConvertExpr:- collectOmniAccessTablesFromExpr(result, e.Expr, defaultDatabase, normalizeStarRocksCluster)- case *ast.RowExpr:- for _, item := range e.Items {- collectOmniAccessTablesFromExpr(result, item, defaultDatabase, normalizeStarRocksCluster)- }- case *ast.MemberOfExpr:- collectOmniAccessTablesFromExpr(result, e.Value, defaultDatabase, normalizeStarRocksCluster)- collectOmniAccessTablesFromExpr(result, e.Array, defaultDatabase, normalizeStarRocksCluster)- case *ast.ParenExpr:- collectOmniAccessTablesFromExpr(result, e.Expr, defaultDatabase, normalizeStarRocksCluster)- case *ast.WeightStringExpr:- collectOmniAccessTablesFromExpr(result, e.Expr, defaultDatabase, normalizeStarRocksCluster)- default:- }-}--func filterStarRocksClusterName(databaseName string) string {- list := strings.Split(databaseName, ":")- if len(list) > 1 {- return list[len(list)-1]- }- return databaseName-}diff --git a/backend/plugin/parser/mysql/query_span_extractor_omni_test.go b/backend/plugin/parser/mysql/query_span_extractor_test.gosimilarity index 100%rename from backend/plugin/parser/mysql/query_span_extractor_omni_test.gorename to backend/plugin/parser/mysql/query_span_extractor_test.godiff --git a/backend/plugin/parser/mysql/query_span_omni_parity_test.go b/backend/plugin/parser/mysql/query_span_parity_test.gosimilarity index 100%rename from backend/plugin/parser/mysql/query_span_omni_parity_test.gorename to backend/plugin/parser/mysql/query_span_parity_test.godiff --git a/backend/plugin/parser/mysql/query_span_omni_probe_test.go b/backend/plugin/parser/mysql/query_span_probe_test.gosimilarity index 98%rename from backend/plugin/parser/mysql/query_span_omni_probe_test.gorename to backend/plugin/parser/mysql/query_span_probe_test.goindex 1a2f201c44..a95c34e2fa 100644--- a/backend/plugin/parser/mysql/query_span_omni_probe_test.go+++ b/backend/plugin/parser/mysql/query_span_probe_test.go@@ -60,7 +60,7 @@ func probeMySQLOmniFixtureParseCoverage(t *testing.T) {continue}total++- list, err := ParseMySQLOmni(entry.Statement)+ list, err := ParseMySQL(entry.Statement)if err != nil {failures = append(failures, failure{fixture: path,@@ -218,7 +218,7 @@ func probeMySQLOmniStructuralInvariants(t *testing.T) {func mustMySQLOmniNode(t *testing.T, sql string) ast.Node {t.Helper()- list, err := ParseMySQLOmni(sql)+ list, err := ParseMySQL(sql)require.NoError(t, err)require.NotNil(t, list)require.Len(t, list.Items, 1)diff --git a/backend/plugin/parser/mysql/query_span_test.go b/backend/plugin/parser/mysql/query_span_test.goindex 5b96181794..19a2381ad6 100644--- a/backend/plugin/parser/mysql/query_span_test.go+++ b/backend/plugin/parser/mysql/query_span_test.go@@ -170,7 +170,7 @@ func TestExtractTableRefs(t *testing.T) {}for _, test := range tests {- parseResult, err := ParseMySQLOmni(test.statement)+ parseResult, err := ParseMySQL(test.statement)require.NoError(t, err, "failed to parse statement: %s", test.statement)require.Len(t, parseResult.Items, 1, "expected one parse result for statement: %s", test.statement)diff --git a/backend/plugin/parser/mysql/restore.go b/backend/plugin/parser/mysql/restore.goindex 5d5193cf78..1e812f932d 100644--- a/backend/plugin/parser/mysql/restore.go+++ b/backend/plugin/parser/mysql/restore.go@@ -46,7 +46,7 @@ func GenerateRestoreSQL(ctx context.Context, rCtx base.RestoreContext, statement}func findFirstDML(statement string) (ast.Node, error) {- stmtList, err := ParseMySQLOmni(statement)+ stmtList, err := ParseMySQL(statement)if err != nil {return nil, errors.Wrap(err, "failed to parse statement")}@@ -302,7 +302,7 @@ func extractStatement(statement string, backupItem *storepb.PriorBackupDetail_Itvar result []stringfor i := start; i <= end; i++ {- stmtList, err := ParseMySQLOmni(list[i].Text)+ stmtList, err := ParseMySQL(list[i].Text)if err != nil {return "", errors.Wrap(err, "failed to parse sql")}diff --git a/backend/plugin/parser/pg/query_span.go b/backend/plugin/parser/pg/query_span.goindex d5a34a5eb9..9dfc978677 100644--- a/backend/plugin/parser/pg/query_span.go+++ b/backend/plugin/parser/pg/query_span.go@@ -2,11 +2,17 @@ package pgimport ("context"+ "log/slog"+ "strings"+ "github.com/bytebase/omni/pg/ast"+ "github.com/bytebase/omni/pg/catalog"+ omniparser "github.com/bytebase/omni/pg/parser""github.com/pkg/errors"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/parser/base"+ "github.com/bytebase/bytebase/backend/store/model")func init() {@@ -38,3 +44,1786 @@ func GetQuerySpan(ctx context.Context, gCtx base.GetQuerySpanContext, stmt base.}return querySpan, nil}++// omniQuerySpanExtractor extracts query span information using the omni parser+// and catalog.+type omniQuerySpanExtractor struct {+ ctx context.Context+ gCtx base.GetQuerySpanContext+ defaultDatabase string+ searchPath []string+ // metaCache is a lazy-load cache for database metadata.+ // Use getDatabaseMetadata() instead of accessing directly.+ metaCache map[string]*model.DatabaseMetadata+ cat *catalog.Catalog+ funcBodyCache map[uint32]*funcBodyAnalysis+ // funcOrigDefs stores the original (non-stubbed) function definitions keyed+ // by lowercase function name. Used by analyzeFunctionBody to get the real+ // body when it was stubbed during catalog loading.+ funcOrigDefs map[string]string+ // funcSourceColumns accumulates table-level access (column="") discovered inside+ // function bodies. Merged into the top-level QuerySpan.SourceColumns.+ funcSourceColumns base.SourceColumnSet+ // funcPredicateColumns accumulates columns used in fallback WHERE/JOIN+ // conditions. Function body analysis records predicates separately so callers+ // can decide whether they enter the top-level QuerySpan.PredicateColumns.+ funcPredicateColumns base.SourceColumnSet+ // fallbackCTEMap holds CTE definitions during fallback column extraction.+ // Set by extractFallbackColumns and used by extractColumnsFromRangeVar+ // to resolve CTE references.+ fallbackCTEMap map[string]*ast.SelectStmt+ // fallbackCTEAliases holds CTE column aliases (e.g., WITH t1(cc1, cc2) AS (...)).+ // Keyed by lowercase CTE name.+ fallbackCTEAliases map[string][]string++ // Catalog loader state — populated by initCatalog.+ // degraded records objects whose real install failed and fell back to+ // pseudo. Keyed by loader object key (schema.name with kind prefix).+ degraded map[string]error+ // trulyBroken records objects whose pseudo install also failed.+ trulyBroken map[string]error+ // loaderObjects records every object collected from metadata. Used by+ // tests to distinguish loader bugs from metadata gaps.+ loaderObjects map[string]bool+ // lastFallbackReason is the classifier's verdict for the most recent+ // AnalyzeSelectStmt error at any of the three fallback sites. Used by+ // tests; not consumed by production code.+ lastFallbackReason fallbackReason+}++// newOmniQuerySpanExtractor creates a new omni-based query span extractor.+func newOmniQuerySpanExtractor(defaultDatabase string, searchPath []string, gCtx base.GetQuerySpanContext) *omniQuerySpanExtractor {+ if len(searchPath) == 0 {+ searchPath = []string{"public"}+ }+ return &omniQuerySpanExtractor{+ defaultDatabase: defaultDatabase,+ searchPath: searchPath,+ gCtx: gCtx,+ metaCache: make(map[string]*model.DatabaseMetadata),+ funcBodyCache: make(map[uint32]*funcBodyAnalysis),+ funcOrigDefs: make(map[string]string),+ funcSourceColumns: make(base.SourceColumnSet),+ funcPredicateColumns: make(base.SourceColumnSet),+ }+}++// getDatabaseMetadata returns cached database metadata, fetching it if not yet cached.+func (e *omniQuerySpanExtractor) getDatabaseMetadata(database string) (*model.DatabaseMetadata, error) {+ if meta, ok := e.metaCache[database]; ok {+ return meta, nil+ }+ _, meta, err := e.gCtx.GetDatabaseMetadataFunc(e.ctx, e.gCtx.InstanceID, database)+ if err != nil {+ return nil, errors.Wrapf(err, "failed to get database metadata for database: %s", database)+ }+ e.metaCache[database] = meta+ return meta, nil+}++// initCatalog initializes the omni catalog from the database metadata using+// the Catalog loader. Every metadata object is installed in dependency order,+// with an inline pseudo fallback at any failed slot (see query_span_e3_*.go).+//+// The DDL render + batch-parse path used before this refactor is deleted: BYT-9215 and+// BYT-9261 are unreachable by construction here.+func (e *omniQuerySpanExtractor) initCatalog() error {+ meta, err := e.getDatabaseMetadata(e.defaultDatabase)+ if err != nil {+ return errors.Wrapf(err, "failed to get database metadata for catalog init")+ }++ e.cat = catalog.New()+ e.cat.SetSearchPath(e.searchPath)++ if meta == nil {+ return nil+ }++ loader := newCatalogLoader(e.cat, meta.GetProto())+ if err := loader.Load(e.ctx); err != nil {+ return errors.Wrapf(err, "catalog loader failed for %q", e.defaultDatabase)+ }+ e.degraded = loader.degraded+ e.trulyBroken = loader.trulyBroken+ e.loaderObjects = loader.loaderObjects++ if len(loader.degraded) > 0 || len(loader.trulyBroken) > 0 {+ slog.Debug("catalog loader degraded objects",+ slog.String("database", e.defaultDatabase),+ slog.Int("degraded", len(loader.degraded)),+ slog.Int("truly_broken", len(loader.trulyBroken)),+ )+ }++ // Populate original (non-stubbed) function definitions for PL/pgSQL body+ // analysis. This is independent of catalog loading and unchanged by the loader.+ for _, s := range meta.GetProto().GetSchemas() {+ for _, f := range s.GetFunctions() {+ if f.Definition == "" {+ continue+ }+ origBody := extractFuncBodyFromDef(f.Definition)+ if origBody != "" {+ e.funcOrigDefs[strings.ToLower(f.Name)] = origBody+ }+ }+ }++ return nil+}++// extractFuncBodyFromDef extracts the dollar-quoted function body from a+// CREATE FUNCTION definition string.+func extractFuncBodyFromDef(definition string) string {+ // Find dollar-quoted body.+ tag, bodyStart, bodyEnd := findDollarQuotedBody(definition)+ if tag == "" {+ return ""+ }+ return definition[bodyStart : bodyEnd-len(tag)]+}++// findDollarQuotedBody locates the dollar-quoted body in a function definition.+// Returns the tag, the start of body content (after opening tag), and the end+// position (after closing tag).+func findDollarQuotedBody(definition string) (tag string, bodyStart int, bodyEnd int) {+ for i := 0; i < len(definition); i++ {+ if definition[i] != '$' {+ continue+ }+ // Find end of tag.+ tagEnd := i + 1+ for tagEnd < len(definition) && definition[tagEnd] != '$' {+ tagEnd+++ }+ if tagEnd >= len(definition) {+ continue+ }+ tag := definition[i : tagEnd+1]+ contentStart := tagEnd + 1+ // Find closing tag.+ closeIdx := strings.Index(definition[contentStart:], tag)+ if closeIdx >= 0 {+ return tag, contentStart, contentStart + closeIdx + len(tag)+ }+ }+ return "", 0, 0+}++// unresolvedColumnsError checks stored metadata independently of column lineage.+// Accesses are conservative: CTE names can match physical tables, so this may+// refuse a CTE-only query. Reads missing from the access set remain unchecked.+func (e *omniQuerySpanExtractor) unresolvedColumnsError(accesses base.SourceColumnSet) *base.UnresolvedColumnsError {+ seen := make(map[base.ColumnResource]bool, len(accesses))+ var unresolved []base.ColumnResource+ for access := range accesses {+ relation := base.ColumnResource{+ Server: access.Server,+ Database: access.Database,+ Schema: access.Schema,+ Table: access.Table,+ }+ if relation.Table == "" || seen[relation] {+ continue+ }+ seen[relation] = true+ if e.relationHasNoSyncedColumns(relation) {+ unresolved = append(unresolved, relation)+ }+ }+ if len(unresolved) == 0 {+ return nil+ }+ return &base.UnresolvedColumnsError{Relations: unresolved}+}++// relationHasNoSyncedColumns checks tables only: masking policies attach to+// table columns, and GetTable resolves partitions to their parent.+// A legal zero-column table is indistinguishable from degraded metadata and+// remains blocked even after re-syncing.+func (e *omniQuerySpanExtractor) relationHasNoSyncedColumns(relation base.ColumnResource) bool {+ meta, err := e.getDatabaseMetadata(relation.Database)+ if err != nil || meta == nil {+ return false+ }+ schema := meta.GetSchemaMetadata(relation.Schema)+ if schema == nil {+ return false+ }+ table := schema.GetTable(relation.Table)+ return table != nil && len(table.GetProto().GetColumns()) == 0+}++// getQuerySpan extracts the query span for the given SQL statement.+func (e *omniQuerySpanExtractor) getQuerySpan(ctx context.Context, stmt string) (*base.QuerySpan, error) {+ e.ctx = ctx++ // Step 1: Parse with omni.+ omniStmts, err := ParsePg(stmt)+ if err != nil {+ // Convert omni parse error to *base.SyntaxError with position info+ // so the SQL service can populate DetailedError.SyntaxError.+ syntaxErr := &base.SyntaxError{+ Message: err.Error(),+ Position: &storepb.Position{Line: 1, Column: 1},+ }+ var parseErr *omniparser.ParseError+ if errors.As(err, &parseErr) && parseErr.Position > 0 {+ syntaxErr.Position = ByteOffsetToRunePosition(stmt, parseErr.Position-1)+ }+ return nil, syntaxErr+ }+ if len(omniStmts) != 1 {+ return nil, errors.Errorf("expected exactly 1 statement, got %d", len(omniStmts))+ }++ // Step 2: Extract access tables (non-fatal on error — some statement+ // types like SET don't have table references).+ accessesMap := make(base.SourceColumnSet)+ accessTables, err := ExtractAccessTables(stmt, ExtractAccessTablesOption{+ DefaultDatabase: e.defaultDatabase,+ DefaultSchema: e.searchPath[0],+ SearchPath: e.searchPath,+ GetDatabaseMetadata: e.gCtx.GetDatabaseMetadataFunc,+ Ctx: ctx,+ InstanceID: e.gCtx.InstanceID,+ SkipMetadataValidation: false,+ })+ if err == nil {+ for _, resource := range accessTables {+ accessesMap[resource] = true+ }+ }++ // Step 3: Check for mixed system/user tables.+ allSystems, mixed := isMixedQuery(accessesMap)+ if mixed {+ return nil, base.MixUserSystemTablesError+ }++ // Step 4: Classify query type.+ queryType, isExplainAnalyze := classifyQueryType(omniStmts[0].AST, allSystems)++ // Step 5: Return early for non-SELECT queries.+ if queryType != base.Select {+ return &base.QuerySpan{+ Type: queryType,+ SourceColumns: base.SourceColumnSet{},+ Results: []base.QuerySpanResult{},+ }, nil+ }++ // For EXPLAIN ANALYZE SELECT, return with source columns but no results.+ if isExplainAnalyze {+ return &base.QuerySpan{+ Type: queryType,+ SourceColumns: accessesMap,+ Results: []base.QuerySpanResult{},+ }, nil+ }++ // Step 6: Cast to SelectStmt, init catalog, analyze.+ selStmt, ok := omniStmts[0].AST.(*ast.SelectStmt)+ if !ok {+ // Not a SelectStmt (e.g., SET, SHOW classified as Select type).+ return &base.QuerySpan{+ Type: base.Select,+ SourceColumns: accessesMap,+ Results: []base.QuerySpanResult{},+ }, nil+ }++ if err := e.initCatalog(); err != nil {+ return nil, errors.Wrapf(err, "failed to initialize catalog")+ }++ query, err := e.cat.AnalyzeSelectStmt(selStmt)+ if err != nil {+ // Record the classifier's verdict for test inspection. This does not+ // gate behavior — the fallback below always runs on analyzer errors.+ e.lastFallbackReason = classifyAnalyzeError(err)++ // Before falling back, try to handle user-defined table-returning functions+ // that omni's AnalyzeSelectStmt can't resolve (e.g., RETURNS TABLE functions+ // used as table sources: SELECT * FROM func()).+ if results := e.tryUserFuncTableSource(selStmt, accessesMap); results != nil {+ return &base.QuerySpan{+ Type: base.Select,+ SourceColumns: accessesMap,+ Results: results,+ UnresolvedColumnsError: e.unresolvedColumnsError(accessesMap),+ }, nil+ }+ // Fail-open: return access tables with best-effort column names and lineage+ // when analysis fails (e.g., unsupported built-in functions).+ return &base.QuerySpan{+ Type: base.Select,+ SourceColumns: accessesMap,+ Results: e.extractFallbackColumns(selStmt),+ PredicateColumns: e.funcPredicateColumns,+ UnresolvedColumnsError: e.unresolvedColumnsError(accessesMap),+ }, nil+ }++ // Step 7: Extract lineage from analyzed query.+ // SourceColumns (table-level access) is already captured in accessesMap+ // from ExtractAccessTables above — no need to re-extract from the query.+ results := e.extractLineage(query, selStmt)++ // Merge columns discovered inside function bodies into the top-level sets.+ for col := range e.funcSourceColumns {+ accessesMap[col] = true+ }++ return &base.QuerySpan{+ Type: base.Select,+ SourceColumns: accessesMap,+ PredicateColumns: e.funcPredicateColumns,+ Results: results,+ UnresolvedColumnsError: e.unresolvedColumnsError(accessesMap),+ }, nil+}++// extractLineage extracts the result column lineage from an analyzed query.+// selStmt is the original parse tree, used to determine IsPlainField+// (which is true only for columns that came from * expansion).+func (e *omniQuerySpanExtractor) extractLineage(q *catalog.Query, selStmt *ast.SelectStmt) []base.QuerySpanResult {+ return e.extractLineageWithVisited(q, selStmt, make(map[*catalog.Query]bool))+}++func (e *omniQuerySpanExtractor) extractLineageWithVisited(q *catalog.Query, selStmt *ast.SelectStmt, visited map[*catalog.Query]bool) []base.QuerySpanResult {+ if q == nil {+ return nil+ }+ if visited[q] {+ return nil+ }+ visited[q] = true+ defer delete(visited, q)++ // Handle set operations (UNION/INTERSECT/EXCEPT).+ if q.SetOp != catalog.SetOpNone {+ return e.extractSetOpLineageWithVisited(q, selStmt, visited)+ }++ // Build a plain-field mask from the parse tree's target list.+ // IsPlainField = true only for columns expanded from SELECT * or SELECT t.*.+ plainMask := buildPlainFieldMask(selStmt, q)++ // Collect parse tree ResTargets for name fixups.+ var parseTargets []*ast.ResTarget+ if selStmt != nil && selStmt.TargetList != nil {+ for _, item := range selStmt.TargetList.Items {+ if rt, ok := item.(*ast.ResTarget); ok {+ parseTargets = append(parseTargets, rt)+ }+ }+ }++ // Build a helper analyzer for parse-tree fallback extraction.+ var analyzer *plpgsqlAnalyzer+ var fromTables map[string]base.ColumnResource+ if selStmt != nil {+ analyzer = &plpgsqlAnalyzer{extractor: e, scope: newVariableScope(nil)}+ fromTables = analyzer.collectFromTables(selStmt)+ }++ var results []base.QuerySpanResult+ idx := 0+ for _, te := range q.TargetList {+ if te.ResJunk {+ continue+ }+ sourceColSet := make(base.SourceColumnSet)+ e.walkExpr(q, te.Expr, sourceColSet)+ isPlain := idx < len(plainMask) && plainMask[idx]+ // Even if the parse tree says this came from *, the underlying+ // expression through CTEs/subqueries may not be a simple column ref.+ if isPlain {+ isPlain = isUltimatelyPlainColumn(q, te.Expr)+ }+ name := te.ResName+ // When the catalog reduces an expression to ConstExpr (losing column refs,+ // e.g., json_object('id': a)), fall back to the parse tree to extract+ // column references and derive a better name.+ if idx < len(parseTargets) {+ if name == "?column?" {+ if better := figureResTargetName(parseTargets[idx]); better != "" {+ name = better+ }+ }+ if len(sourceColSet) == 0 && analyzer != nil {+ analyzer.extractColumnRefsFromExpr(parseTargets[idx].Val, fromTables, sourceColSet)+ }+ }+ results = append(results, base.QuerySpanResult{+ Name: name,+ SourceColumns: sourceColSet,+ IsPlainField: isPlain,+ })+ idx+++ }+ return results+}++// isUltimatelyPlainColumn checks whether an expression, after resolving through+// CTEs and subqueries, is a simple column reference (VarExpr pointing to a+// physical table). Aggregates, functions, and other expressions return false.+func isUltimatelyPlainColumn(q *catalog.Query, expr catalog.AnalyzedExpr) bool {+ return isUltimatelyPlainColumnWithVisited(q, expr, make(map[queryExprKey]bool))+}++type queryExprKey struct {+ query *catalog.Query+ expr catalog.AnalyzedExpr+}++func isUltimatelyPlainColumnWithVisited(q *catalog.Query, expr catalog.AnalyzedExpr, visited map[queryExprKey]bool) bool {+ if expr == nil {+ return false+ }+ key := queryExprKey{query: q, expr: expr}+ if visited[key] {+ return false+ }+ visited[key] = true++ v, ok := expr.(*catalog.VarExpr)+ if !ok {+ return false+ }+ if v.RangeIdx < 0 || v.RangeIdx >= len(q.RangeTable) {+ return false+ }+ rte := q.RangeTable[v.RangeIdx]+ colIdx := int(v.AttNum - 1)++ switch rte.Kind {+ case catalog.RTERelation:+ return true+ case catalog.RTESubquery:+ if rte.Subquery != nil && colIdx >= 0 && colIdx < len(rte.Subquery.TargetList) {+ return isUltimatelyPlainColumnWithVisited(rte.Subquery, rte.Subquery.TargetList[colIdx].Expr, visited)+ }+ case catalog.RTECTE:+ if rte.CTEIndex >= 0 && rte.CTEIndex < len(q.CTEList) {+ cte := q.CTEList[rte.CTEIndex]+ if cte.Query != nil && colIdx >= 0 && colIdx < len(cte.Query.TargetList) {+ return isUltimatelyPlainColumnWithVisited(cte.Query, cte.Query.TargetList[colIdx].Expr, visited)+ }+ }+ default:+ return false+ }+ return false+}++// buildPlainFieldMask returns a boolean slice aligned with the analyzed+// query's non-junk TargetList. An entry is true if the column was produced+// by * expansion (SELECT * or SELECT t.*), false for explicit column refs.+func buildPlainFieldMask(selStmt *ast.SelectStmt, q *catalog.Query) []bool {+ // Collect non-junk target entries.+ var targets []*catalog.TargetEntry+ for _, te := range q.TargetList {+ if !te.ResJunk {+ targets = append(targets, te)+ }+ }+ nResults := len(targets)++ if selStmt == nil || selStmt.TargetList == nil {+ return make([]bool, nResults)+ }++ // Count parse-tree items (stars and non-stars).+ var parseTargets []*ast.ResTarget+ for _, item := range selStmt.TargetList.Items {+ if rt, ok := item.(*ast.ResTarget); ok {+ parseTargets = append(parseTargets, rt)+ }+ }++ // For each star, determine how many columns it expands to by+ // looking at the table it references and counting columns in that RTE.+ mask := make([]bool, nResults)+ pos := 0++ for _, rt := range parseTargets {+ if pos >= nResults {+ break+ }+ if isStarTarget(rt) {+ tableName := starTableName(rt)+ starCount := countStarColumnsFromRTE(q, targets, pos, tableName)+ for i := 0; i < starCount && pos < nResults; i++ {+ mask[pos] = true+ pos+++ }+ } else {+ mask[pos] = false+ pos+++ }+ }++ return mask+}++// isStarTarget checks if a ResTarget in the parse tree is a star expression+// (SELECT * or SELECT t.*).+func isStarTarget(rt *ast.ResTarget) bool {+ if rt == nil || rt.Val == nil {+ return false+ }+ cr, ok := rt.Val.(*ast.ColumnRef)+ if !ok || cr.Fields == nil || len(cr.Fields.Items) == 0 {+ return false+ }+ last := cr.Fields.Items[len(cr.Fields.Items)-1]+ _, isStar := last.(*ast.A_Star)+ return isStar+}++// starTableName extracts the table qualifier from a star target.+// For "SELECT *" returns "", for "SELECT t.*" returns "t".+func starTableName(rt *ast.ResTarget) string {+ cr, ok := rt.Val.(*ast.ColumnRef)+ if !ok || cr.Fields == nil {+ return ""+ }+ // For t.*, Fields = [String("t"), A_Star{}]+ if len(cr.Fields.Items) >= 2 {+ if s, ok := cr.Fields.Items[0].(*ast.String); ok {+ return s.Str+ }+ }+ return ""+}++// countStarColumnsFromRTE counts how many analyzed target entries starting+// at pos belong to a star expansion. For unqualified * (tableName=""), it+// counts entries that share the same contiguous RangeIdx sequence covering+// all non-join RTEs. For qualified t.* (tableName="t"), it counts entries+// whose RTE ERef matches the table name.+func countStarColumnsFromRTE(q *catalog.Query, targets []*catalog.TargetEntry, startPos int, tableName string) int {+ if startPos >= len(targets) {+ return 0+ }++ if tableName != "" {+ // Qualified star: count consecutive entries from the named RTE.+ count := 0+ for i := startPos; i < len(targets); i++ {+ v, ok := targets[i].Expr.(*catalog.VarExpr)+ if !ok {+ break+ }+ if v.RangeIdx < 0 || v.RangeIdx >= len(q.RangeTable) {+ break+ }+ rte := q.RangeTable[v.RangeIdx]+ if rte.ERef != tableName && rte.Alias != tableName {+ break+ }+ count+++ }+ if count == 0 {+ return 1+ }+ return count+ }++ // Unqualified star: expands all non-join RTEs in FROM order.+ // Count how many consecutive VarExprs follow the expected star expansion pattern.+ count := 0+ for i := startPos; i < len(targets); i++ {+ v, ok := targets[i].Expr.(*catalog.VarExpr)+ if !ok {+ break+ }+ if v.RangeIdx < 0 || v.RangeIdx >= len(q.RangeTable) {+ break+ }+ rte := q.RangeTable[v.RangeIdx]+ if rte.Kind == catalog.RTEJoin {+ break+ }+ // Check if this column's AttNum is sequential within its RTE.+ // Star expansion produces columns in order: attnum 1, 2, 3, ...+ if count > 0 {+ if prev, ok := targets[i-1].Expr.(*catalog.VarExpr); ok && v.RangeIdx == prev.RangeIdx && v.AttNum != prev.AttNum+1 {+ break+ }+ }+ count+++ }+ if count == 0 {+ return 1+ }+ return count+}++func (e *omniQuerySpanExtractor) extractSetOpLineageWithVisited(q *catalog.Query, selStmt *ast.SelectStmt, visited map[*catalog.Query]bool) []base.QuerySpanResult {+ if q.LArg == nil || q.RArg == nil {+ return nil+ }+ var lSelStmt, rSelStmt *ast.SelectStmt+ if selStmt != nil {+ lSelStmt = selStmt.Larg+ rSelStmt = selStmt.Rarg+ }+ lResults := e.extractLineageWithVisited(q.LArg, lSelStmt, visited)+ rResults := e.extractLineageWithVisited(q.RArg, rSelStmt, visited)++ // For EXCEPT, output rows come only from the left branch — do not+ // merge right-side lineage into the result columns.+ includeRight := q.SetOp != catalog.SetOpExcept && q.SetOp != catalog.SetOpExceptAll++ var results []base.QuerySpanResult+ for i, lr := range lResults {+ merged := make(base.SourceColumnSet)+ for col := range lr.SourceColumns {+ merged[col] = true+ }+ if includeRight && i < len(rResults) {+ for col := range rResults[i].SourceColumns {+ merged[col] = true+ }+ }+ results = append(results, base.QuerySpanResult{+ Name: lr.Name,+ SourceColumns: merged,+ IsPlainField: false, // set-op results are never plain fields+ })+ }+ return results+}++// walkExpr recursively walks an analyzed expression tree and collects all+// source column references into the result set.+func (e *omniQuerySpanExtractor) walkExpr(q *catalog.Query, expr catalog.AnalyzedExpr, result base.SourceColumnSet) {+ e.walkExprWithVisited([]*catalog.Query{q}, expr, result, make(map[queryExprKey]bool))+}++func (e *omniQuerySpanExtractor) walkExprWithVisited(queryStack []*catalog.Query, expr catalog.AnalyzedExpr, result base.SourceColumnSet, visited map[queryExprKey]bool) {+ if expr == nil {+ return+ }+ q := currentQuery(queryStack)+ if q == nil {+ return+ }+ key := queryExprKey{query: q, expr: expr}+ if visited[key] {+ return+ }+ visited[key] = true++ switch v := expr.(type) {+ case *catalog.VarExpr:+ e.resolveVar(queryStack, v, result, visited)+ case *catalog.FuncCallExpr:+ // Walk arguments first — they contribute to access tables.+ for _, arg := range v.Args {+ e.walkExprWithVisited(queryStack, arg, result, visited)+ }+ // Trace lineage through user-defined function body.+ if proc := e.cat.GetUserProcByOID(v.FuncOID); proc != nil {+ // Expression context: merge all output columns into one set.+ for _, colSet := range e.analyzeFunctionBody(proc) {+ for k, val := range colSet {+ result[k] = val+ }+ }+ }+ case *catalog.AggExpr:+ for _, arg := range v.Args {+ e.walkExprWithVisited(queryStack, arg, result, visited)+ }+ case *catalog.OpExpr:+ e.walkExprWithVisited(queryStack, v.Left, result, visited)+ e.walkExprWithVisited(queryStack, v.Right, result, visited)+ case *catalog.BoolExprQ:+ for _, arg := range v.Args {+ e.walkExprWithVisited(queryStack, arg, result, visited)+ }+ case *catalog.CaseExprQ:+ e.walkExprWithVisited(queryStack, v.Arg, result, visited)+ for _, w := range v.When {+ e.walkExprWithVisited(queryStack, w.Condition, result, visited)+ e.walkExprWithVisited(queryStack, w.Result, result, visited)+ }+ e.walkExprWithVisited(queryStack, v.Default, result, visited)+ case *catalog.CoalesceExprQ:+ for _, arg := range v.Args {+ e.walkExprWithVisited(queryStack, arg, result, visited)+ }+ case *catalog.SubLinkExpr:+ e.walkExprWithVisited(queryStack, v.TestExpr, result, visited)+ if v.SubQuery != nil {+ subQueryStack := appendQuery(queryStack, v.SubQuery)+ for _, te := range v.SubQuery.TargetList {+ if !te.ResJunk {+ e.walkExprWithVisited(subQueryStack, te.Expr, result, visited)+ }+ }+ }+ case *catalog.RelabelExpr:+ e.walkExprWithVisited(queryStack, v.Arg, result, visited)+ case *catalog.CoerceViaIOExpr:+ e.walkExprWithVisited(queryStack, v.Arg, result, visited)+ case *catalog.RowExprQ:+ for _, arg := range v.Args {+ e.walkExprWithVisited(queryStack, arg, result, visited)+ }+ case *catalog.WindowFuncExpr:+ for _, arg := range v.Args {+ e.walkExprWithVisited(queryStack, arg, result, visited)+ }+ e.walkExprWithVisited(queryStack, v.AggFilter, result, visited)+ case *catalog.NullIfExprQ:+ for _, arg := range v.Args {+ e.walkExprWithVisited(queryStack, arg, result, visited)+ }+ case *catalog.MinMaxExprQ:+ for _, arg := range v.Args {+ e.walkExprWithVisited(queryStack, arg, result, visited)+ }+ case *catalog.ArrayExprQ:+ for _, elem := range v.Elements {+ e.walkExprWithVisited(queryStack, elem, result, visited)+ }+ case *catalog.ScalarArrayOpExpr:+ e.walkExprWithVisited(queryStack, v.Left, result, visited)+ e.walkExprWithVisited(queryStack, v.Right, result, visited)+ case *catalog.CollateExprQ:+ e.walkExprWithVisited(queryStack, v.Arg, result, visited)+ case *catalog.NullTestExpr:+ e.walkExprWithVisited(queryStack, v.Arg, result, visited)+ case *catalog.BooleanTestExpr:+ e.walkExprWithVisited(queryStack, v.Arg, result, visited)+ case *catalog.DistinctExprQ:+ e.walkExprWithVisited(queryStack, v.Left, result, visited)+ e.walkExprWithVisited(queryStack, v.Right, result, visited)+ case *catalog.FieldSelectExprQ:+ e.walkExprWithVisited(queryStack, v.Arg, result, visited)+ // ConstExpr, SQLValueFuncExpr, CoerceToDomainValueExpr — no column refs.+ default:+ }+}++func currentQuery(queryStack []*catalog.Query) *catalog.Query {+ if len(queryStack) == 0 {+ return nil+ }+ return queryStack[len(queryStack)-1]+}++func appendQuery(queryStack []*catalog.Query, q *catalog.Query) []*catalog.Query {+ nextStack := make([]*catalog.Query, 0, len(queryStack)+1)+ nextStack = append(nextStack, queryStack...)+ if q == nil {+ return nextStack+ }+ return append(nextStack, q)+}++// resolveVar resolves a VarExpr to its ultimate source column(s).+func (e *omniQuerySpanExtractor) resolveVar(queryStack []*catalog.Query, v *catalog.VarExpr, result base.SourceColumnSet, visited map[queryExprKey]bool) {+ q := currentQuery(queryStack)+ effectiveStack := queryStack+ if v.LevelsUp > 0 {+ ancestorIdx := len(queryStack) - 1 - v.LevelsUp+ if ancestorIdx < 0 {+ return+ }+ q = queryStack[ancestorIdx]+ effectiveStack = queryStack[:ancestorIdx+1]+ }+ if q == nil {+ return+ }+ if v.RangeIdx < 0 || v.RangeIdx >= len(q.RangeTable) {+ return+ }+ rte := q.RangeTable[v.RangeIdx]+ colIdx := int(v.AttNum - 1) // AttNum is 1-based++ switch rte.Kind {+ case catalog.RTERelation:+ rel := e.cat.GetRelationByOID(rte.RelOID)+ if rel == nil || rel.Schema == nil {+ return+ }+ // Standalone composite types are not FROM-able; a valid analysis+ // never produces such an RTE, so treat it as unresolved.+ if rel.RelKind == 'c' {+ return+ }+ colName := ""+ if colIdx >= 0 && colIdx < len(rte.ColNames) {+ colName = rte.ColNames[colIdx]+ }+ result[base.ColumnResource{+ Database: e.defaultDatabase,+ Schema: rel.Schema.Name,+ Table: rel.Name,+ Column: colName,+ }] = true++ case catalog.RTESubquery:+ if rte.Subquery == nil {+ return+ }+ if colIdx >= 0 && colIdx < len(rte.Subquery.TargetList) {+ te := rte.Subquery.TargetList[colIdx]+ e.walkExprWithVisited(appendQuery(effectiveStack, rte.Subquery), te.Expr, result, visited)+ }++ case catalog.RTECTE:+ if cte := findCTEForRangeTableEntry(effectiveStack, rte); cte != nil && cte.Query != nil && colIdx >= 0 && colIdx < len(cte.Query.TargetList) {+ te := cte.Query.TargetList[colIdx]+ e.walkExprWithVisited(appendQuery(effectiveStack, cte.Query), te.Expr, result, visited)+ }++ case catalog.RTEJoin:+ // After analysis, VarExprs typically point to base RTEs, not join RTEs.++ case catalog.RTEFunction:+ // Trace lineage through user-defined function body.+ if len(rte.FuncExprs) > 0 {+ if fc, ok := rte.FuncExprs[0].(*catalog.FuncCallExpr); ok {+ if proc := e.cat.GetUserProcByOID(fc.FuncOID); proc != nil {+ bodySets := e.analyzeTableFunctionBody(proc)+ if colIdx >= 0 && colIdx < len(bodySets) {+ for k, val := range bodySets[colIdx] {+ result[k] = val+ }+ }+ } else {+ // Built-in function (no user proc) — trace lineage through+ // the function's arguments. E.g., jsonb_each(a) depends on column a.+ for _, arg := range fc.Args {+ e.walkExprWithVisited(effectiveStack, arg, result, visited)+ }+ }+ }+ }++ default:+ // Unknown RTE kind — skip.+ }+}++func findCTEForRangeTableEntry(queryStack []*catalog.Query, rte *catalog.RangeTableEntry) *catalog.CommonTableExprQ {+ if len(queryStack) == 0 || rte == nil {+ return nil+ }++ current := currentQuery(queryStack)+ if current != nil && rte.CTEIndex >= 0 && rte.CTEIndex < len(current.CTEList) {+ return current.CTEList[rte.CTEIndex]+ }++ if rte.CTEName == "" {+ return nil+ }+ for i := len(queryStack) - 1; i >= 0; i-- {+ for _, cte := range queryStack[i].CTEList {+ if strings.EqualFold(cte.Name, rte.CTEName) {+ return cte+ }+ }+ }+ return nil+}++// extractFallbackColumns attempts to extract column names and lineage from the parse tree+// when AnalyzeSelectStmt fails. It walks the AST to find column references and resolves+// them against tables in the FROM clause.+func (e *omniQuerySpanExtractor) extractFallbackColumns(selStmt *ast.SelectStmt) []base.QuerySpanResult {+ if selStmt == nil {+ return nil+ }++ // Build a helper analyzer to reuse column reference extraction.+ analyzer := &plpgsqlAnalyzer{+ extractor: e,+ scope: newVariableScope(nil),+ }+ fromTables := analyzer.collectFromTables(selStmt)++ // Build CTE map so we can trace through CTEs to real tables.+ cteMap := collectCTEDefinitions(selStmt)+ analyzer.cteMap = cteMap+ // Store cteMap on the extractor so extractColumnsFromRangeVar can resolve CTEs.+ e.fallbackCTEMap = cteMap+ e.fallbackCTEAliases = collectCTEAliases(selStmt)++ // Check if SELECT has explicit target list (not *).+ if selStmt.TargetList != nil {+ var results []base.QuerySpanResult+ allStar := true+ for _, item := range selStmt.TargetList.Items {+ rt, ok := item.(*ast.ResTarget)+ if !ok {+ continue+ }+ if !isStarTarget(rt) {+ allStar = false+ name := rt.Name+ if name == "" {+ name = figureResTargetName(rt)+ }+ // PostgreSQL uses "?column?" for unnamed result columns.+ if name == "" {+ name = "?column?"+ }+ // Extract column references from the expression for lineage.+ colSet := make(base.SourceColumnSet)+ analyzer.extractColumnRefsFromExpr(rt.Val, fromTables, colSet)+ results = append(results, base.QuerySpanResult{+ Name: name,+ SourceColumns: colSet,+ })+ }+ }+ if !allStar && len(results) > 0 {+ // Also extract WHERE clause columns for predicate tracking.+ if selStmt.WhereClause != nil {+ whereColSet := make(base.SourceColumnSet)+ analyzer.extractColumnRefsFromExpr(selStmt.WhereClause, fromTables, whereColSet)+ for k, v := range whereColSet {+ e.funcPredicateColumns[k] = v+ }+ }+ return results+ }+ }++ // For SELECT *, combine columns from ALL FROM clause items.+ if selStmt.FromClause != nil {+ var allCols []base.QuerySpanResult+ for _, item := range selStmt.FromClause.Items {+ allCols = append(allCols, e.extractColumnsFromFromItem(item, analyzer, fromTables)...)+ }+ if len(allCols) > 0 {+ return allCols+ }+ }++ return nil+}++// figureResTargetName extracts a column name from a ResTarget's expression.+func figureResTargetName(rt *ast.ResTarget) string {+ if rt == nil || rt.Val == nil {+ return ""+ }+ if cr, ok := rt.Val.(*ast.ColumnRef); ok && cr.Fields != nil {+ // Use the last String field — for "ia.approver_emails", return "approver_emails".+ // For unqualified "col", return "col". Skip A_Star nodes.+ name := ""+ for _, f := range cr.Fields.Items {+ if s, ok := f.(*ast.String); ok {+ name = s.Str+ }+ }+ return name+ }+ if fc, ok := rt.Val.(*ast.FuncCall); ok && fc.Funcname != nil {+ // Use the last name part — for "pg_catalog.func", return "func".+ name := ""+ for _, f := range fc.Funcname.Items {+ if s, ok := f.(*ast.String); ok {+ name = s.Str+ }+ }+ return name+ }+ // SQL/JSON constructors.+ if _, ok := rt.Val.(*ast.JsonObjectConstructor); ok {+ return "json_object"+ }+ if _, ok := rt.Val.(*ast.JsonArrayConstructor); ok {+ return "json_array"+ }+ return ""+}++// extractColumnsFromFromItem extracts column names from a FROM clause item.+// For RangeVar (tables), it looks up the catalog for column names and lineage.+// For RangeFunction, it uses function name or alias column names.+// analyzer and fromTables are optional (may be nil) and used for resolving+// function argument column refs in the fallback path.+func (e *omniQuerySpanExtractor) extractColumnsFromFromItem(item ast.Node, analyzer *plpgsqlAnalyzer, fromTables map[string]base.ColumnResource) []base.QuerySpanResult {+ if item == nil {+ return nil+ }++ switch v := item.(type) {+ case *ast.RangeVar:+ return e.extractColumnsFromRangeVar(v)+ case *ast.RangeFunction:+ return e.extractColumnsFromRangeFunction(v, analyzer, fromTables)+ case *ast.RangeSubselect:+ if v.Alias != nil && v.Alias.Colnames != nil && len(v.Alias.Colnames.Items) > 0 {+ return extractColnamesFromAlias(v.Alias)+ }+ // No explicit column aliases — extract column names from subquery's target list+ // (only when the target list has explicit columns, not SELECT *).+ if subSel, ok := v.Subquery.(*ast.SelectStmt); ok && subSel.TargetList != nil {+ var results []base.QuerySpanResult+ hasStar := false+ for _, item := range subSel.TargetList.Items {+ rt, ok := item.(*ast.ResTarget)+ if !ok {+ continue+ }+ if isStarTarget(rt) {+ hasStar = true+ break+ }+ name := rt.Name+ if name == "" {+ name = figureResTargetName(rt)+ }+ if name == "" {+ name = "?column?"+ }+ results = append(results, base.QuerySpanResult{+ Name: name,+ SourceColumns: base.SourceColumnSet{},+ })+ }+ if !hasStar && len(results) > 0 {+ return results+ }+ // For SELECT * in subquery, try to resolve columns from the subquery's FROM tables.+ if hasStar && subSel.FromClause != nil {+ var starResults []base.QuerySpanResult+ for _, fromItem := range subSel.FromClause.Items {+ starResults = append(starResults, e.extractColumnsFromFromItem(fromItem, analyzer, fromTables)...)+ }+ if len(starResults) > 0 {+ return starResults+ }+ }+ }+ return nil+ case *ast.JoinExpr:+ var results []base.QuerySpanResult+ results = append(results, e.extractColumnsFromFromItem(v.Larg, analyzer, fromTables)...)+ results = append(results, e.extractColumnsFromFromItem(v.Rarg, analyzer, fromTables)...)+ return results+ default:+ return nil+ }+}++// extractColumnsFromRangeVar looks up a table in the catalog and returns its columns with lineage.+// If the table name matches a CTE in fallbackCTEMap, it extracts columns from the CTE definition.+func (e *omniQuerySpanExtractor) extractColumnsFromRangeVar(rv *ast.RangeVar) []base.QuerySpanResult {+ // Check if this is a CTE reference.+ if rv.Schemaname == "" && e.fallbackCTEMap != nil {+ if cteSel, ok := e.fallbackCTEMap[strings.ToLower(rv.Relname)]; ok {+ return e.extractColumnsFromCTE(rv.Relname, cteSel)+ }+ }++ var rel *catalog.Relation+ if rv.Schemaname != "" {+ rel = e.cat.GetRelation(rv.Schemaname, rv.Relname)+ } else {+ for _, schema := range e.searchPath {+ rel = e.cat.GetRelation(schema, rv.Relname)+ if rel != nil {+ break+ }+ }+ }+ if rel == nil {+ return nil+ }+ // Standalone composite types share the relation namespace but are not+ // FROM-able; PostgreSQL rejects them as table sources.+ if rel.RelKind == 'c' {+ return nil+ }+ var results []base.QuerySpanResult+ for _, col := range rel.Columns {+ colSet := make(base.SourceColumnSet)+ colSet[base.ColumnResource{+ Database: e.defaultDatabase,+ Schema: rel.Schema.Name,+ Table: rel.Name,+ Column: col.Name,+ }] = true+ results = append(results, base.QuerySpanResult{+ Name: col.Name,+ SourceColumns: colSet,+ IsPlainField: true,+ })+ }+ return results+}++// extractColumnsFromCTE extracts columns from a CTE definition.+// For UNION CTEs, it uses the left branch (the non-recursive term) for column names+// and merges lineage from both branches.+func (e *omniQuerySpanExtractor) extractColumnsFromCTE(cteName string, cteSel *ast.SelectStmt) []base.QuerySpanResult {+ if cteSel == nil {+ return nil+ }++ // Build a helper analyzer.+ analyzer := &plpgsqlAnalyzer{+ extractor: e,+ scope: newVariableScope(nil),+ cteMap: e.fallbackCTEMap,+ }++ // For UNION (recursive or not), use the left branch for column names+ // and extract lineage from both branches.+ if cteSel.Larg != nil {+ leftResults := e.extractCTEBranchColumns(analyzer, cteSel.Larg)+ rightResults := e.extractCTEBranchColumns(analyzer, cteSel.Rarg)++ // Merge right-branch lineage into left-branch results.+ for i := range leftResults {+ if i < len(rightResults) {+ for k, v := range rightResults[i].SourceColumns {+ leftResults[i].SourceColumns[k] = v+ }+ }+ }++ // For recursive CTEs, the recursive term references CTE columns+ // (e.g., cc1*cc2). Track which CTE columns each recursive expression+ // depends on, then resolve those to source columns from the non-recursive term.+ if selectReferencesTable(cteSel.Rarg, cteName) {+ aliases := e.getCTEColumnAliases(cteName)+ if len(aliases) == 0 {+ // No explicit aliases — use the column names from leftResults.+ for _, r := range leftResults {+ aliases = append(aliases, r.Name)+ }+ }+ e.mergeRecursiveCTELineage(leftResults, cteSel.Rarg, cteName, aliases)+ }++ // Look up CTE column aliases from the WithClause.+ if aliases := e.getCTEColumnAliases(cteName); len(aliases) > 0 {+ for i := range leftResults {+ if i < len(aliases) {+ leftResults[i].Name = aliases[i]+ }+ }+ }++ return leftResults+ }++ // Simple CTE (no UNION) — extract directly.+ return e.extractCTEBranchColumns(analyzer, cteSel)+}++// extractCTEBranchColumns extracts column names and lineage from a single CTE branch.+func (*omniQuerySpanExtractor) extractCTEBranchColumns(analyzer *plpgsqlAnalyzer, sel *ast.SelectStmt) []base.QuerySpanResult {+ if sel == nil || sel.TargetList == nil {+ return nil+ }++ fromTables := analyzer.collectFromTables(sel)++ var results []base.QuerySpanResult+ for _, item := range sel.TargetList.Items {+ rt, ok := item.(*ast.ResTarget)+ if !ok {+ continue+ }+ name := rt.Name+ if name == "" {+ name = figureResTargetName(rt)+ }+ colSet := make(base.SourceColumnSet)+ analyzer.extractColumnRefsFromExpr(rt.Val, fromTables, colSet)+ results = append(results, base.QuerySpanResult{+ Name: name,+ SourceColumns: colSet,+ })+ }+ return results+}++// getCTEColumnAliases returns the column aliases defined on a CTE (e.g., t1(cc1, cc2, cc3)).+func (e *omniQuerySpanExtractor) getCTEColumnAliases(cteName string) []string {+ if e.fallbackCTEAliases == nil {+ return nil+ }+ return e.fallbackCTEAliases[strings.ToLower(cteName)]+}++// selectReferencesTable checks if a SELECT statement references a table name+// in its FROM clause. Used to detect recursive CTEs.+func selectReferencesTable(sel *ast.SelectStmt, tableName string) bool {+ if sel == nil || sel.FromClause == nil {+ return false+ }+ lower := strings.ToLower(tableName)+ for _, item := range sel.FromClause.Items {+ if nodeReferencesTable(item, lower) {+ return true+ }+ }+ return false+}++func nodeReferencesTable(node ast.Node, tableName string) bool {+ if node == nil {+ return false+ }+ switch v := node.(type) {+ case *ast.RangeVar:+ return strings.ToLower(v.Relname) == tableName+ case *ast.JoinExpr:+ return nodeReferencesTable(v.Larg, tableName) || nodeReferencesTable(v.Rarg, tableName)+ default:+ return false+ }+}++// mergeRecursiveCTELineage tracks which CTE columns each expression in the+// recursive term depends on, then resolves those to source columns from the+// non-recursive term results.+func (*omniQuerySpanExtractor) mergeRecursiveCTELineage(results []base.QuerySpanResult, recursiveSel *ast.SelectStmt, _ string, cteColNames []string) {+ if recursiveSel == nil || recursiveSel.TargetList == nil {+ return+ }++ // Build a map of CTE column name → index (for resolving references).+ cteColIndex := make(map[string]int)+ for i, name := range cteColNames {+ cteColIndex[strings.ToLower(name)] = i+ }++ // For each expression in the recursive term, find which CTE columns it references.+ for i, item := range recursiveSel.TargetList.Items {+ if i >= len(results) {+ break+ }+ rt, ok := item.(*ast.ResTarget)+ if !ok {+ continue+ }++ // Collect all column references from this expression.+ refs := collectColumnRefNames(rt.Val)++ // For each referenced column, if it's a CTE column, merge that column's+ // source set into this result's source set.+ for _, ref := range refs {+ if idx, ok := cteColIndex[strings.ToLower(ref)]; ok && idx < len(results) {+ for k, v := range results[idx].SourceColumns {+ results[i].SourceColumns[k] = v+ }+ }+ }+ }+}++// collectColumnRefNames extracts all unqualified column reference names from an expression.+func collectColumnRefNames(node ast.Node) []string {+ if node == nil {+ return nil+ }+ var names []string+ switch v := node.(type) {+ case *ast.ColumnRef:+ if v.Fields != nil && len(v.Fields.Items) == 1 {+ if s, ok := v.Fields.Items[0].(*ast.String); ok {+ names = append(names, s.Str)+ }+ }+ case *ast.FuncCall:+ if v.Args != nil {+ for _, arg := range v.Args.Items {+ names = append(names, collectColumnRefNames(arg)...)+ }+ }+ case *ast.A_Expr:+ names = append(names, collectColumnRefNames(v.Lexpr)...)+ names = append(names, collectColumnRefNames(v.Rexpr)...)+ case *ast.TypeCast:+ names = append(names, collectColumnRefNames(v.Arg)...)+ default:+ }+ return names+}++// collectCTEAliases extracts CTE column aliases from the WITH clause.+func collectCTEAliases(selStmt *ast.SelectStmt) map[string][]string {+ if selStmt == nil || selStmt.WithClause == nil {+ return nil+ }++ aliasMap := make(map[string][]string)+ for _, item := range selStmt.WithClause.Ctes.Items {+ cte, ok := item.(*ast.CommonTableExpr)+ if !ok {+ continue+ }+ if cte.Aliascolnames == nil || len(cte.Aliascolnames.Items) == 0 {+ continue+ }+ var aliases []string+ for _, nameItem := range cte.Aliascolnames.Items {+ if s, ok := nameItem.(*ast.String); ok {+ aliases = append(aliases, s.Str)+ }+ }+ if len(aliases) > 0 {+ aliasMap[strings.ToLower(cte.Ctename)] = aliases+ }+ }+ return aliasMap+}++// extractColumnsFromRangeFunction extracts columns from a function in FROM clause.+// It first tries to look up user-defined functions in the catalog for lineage tracing.+// analyzer and fromTables are optional and used for resolving function argument column refs.+func (e *omniQuerySpanExtractor) extractColumnsFromRangeFunction(rf *ast.RangeFunction, analyzer *plpgsqlAnalyzer, fromTables map[string]base.ColumnResource) []base.QuerySpanResult {+ // Try to resolve user-defined function for lineage tracing.+ funcName := extractFuncNameFromRange(rf)+ if funcName != "" && e.cat != nil {+ // First try catalog lookup.+ if proc := e.lookupUserProcByName(funcName); proc != nil {+ outNames := getOutputParamNames(proc)+ if len(outNames) > 0 {+ bodySets := e.analyzeTableFunctionBody(proc)+ var results []base.QuerySpanResult+ for i, name := range outNames {+ colSet := make(base.SourceColumnSet)+ if i < len(bodySets) {+ for k, v := range bodySets[i] {+ colSet[k] = v+ }+ }+ results = append(results, base.QuerySpanResult{+ Name: name,+ SourceColumns: colSet,+ })+ }+ return results+ }+ }+ // Catalog lookup failed — try metadata (for RETURNS TABLE functions).+ dummyAccesses := make(base.SourceColumnSet)+ if metaResults := e.tryMetadataFuncLookup(funcName, dummyAccesses); metaResults != nil {+ return metaResults+ }+ }++ if rf.Alias != nil && rf.Alias.Colnames != nil && len(rf.Alias.Colnames.Items) > 0 {+ // Even with alias column names, resolve function arg column refs for lineage.+ results := extractColnamesFromAlias(rf.Alias)+ e.enrichFuncResultsWithArgLineage(rf, analyzer, fromTables, results)+ return results+ }+ results := extractFuncColumnNames(rf, rf.Alias)+ e.enrichFuncResultsWithArgLineage(rf, analyzer, fromTables, results)+ return results+}++// enrichFuncResultsWithArgLineage resolves column references from function arguments+// and adds them as source columns to all function result columns.+// For built-in functions like jsonb_each(a), the output depends on the input column a.+func (*omniQuerySpanExtractor) enrichFuncResultsWithArgLineage(rf *ast.RangeFunction, analyzer *plpgsqlAnalyzer, fromTables map[string]base.ColumnResource, results []base.QuerySpanResult) {+ if analyzer == nil || fromTables == nil || rf.Functions == nil || len(results) == 0 {+ return+ }++ // Collect source columns from all function arguments.+ argSources := make(base.SourceColumnSet)+ for _, funcItem := range rf.Functions.Items {+ funcList, ok := funcItem.(*ast.List)+ if !ok || len(funcList.Items) < 1 {+ continue+ }+ fc, ok := funcList.Items[0].(*ast.FuncCall)+ if !ok || fc.Args == nil {+ continue+ }+ for _, arg := range fc.Args.Items {+ analyzer.extractColumnRefsFromExpr(arg, fromTables, argSources)+ }+ }++ // Apply argument source columns to all result columns.+ for i := range results {+ for k, v := range argSources {+ if results[i].SourceColumns == nil {+ results[i].SourceColumns = make(base.SourceColumnSet)+ }+ results[i].SourceColumns[k] = v+ }+ }+}++// extractColnamesFromAlias extracts column names from an alias's column name list.+func extractColnamesFromAlias(alias *ast.Alias) []base.QuerySpanResult {+ if alias == nil || alias.Colnames == nil {+ return nil+ }+ var results []base.QuerySpanResult+ for _, item := range alias.Colnames.Items {+ if s, ok := item.(*ast.String); ok {+ results = append(results, base.QuerySpanResult{+ Name: s.Str,+ SourceColumns: base.SourceColumnSet{},+ })+ }+ }+ return results+}++// extractFuncColumnNames extracts column names from a RangeFunction.+// For functions like unnest(ARRAY, ARRAY), each argument produces a column+// named after the function.+func extractFuncColumnNames(rf *ast.RangeFunction, _ *ast.Alias) []base.QuerySpanResult {+ if rf.Functions == nil {+ return nil+ }++ var results []base.QuerySpanResult+ for _, funcItem := range rf.Functions.Items {+ funcList, ok := funcItem.(*ast.List)+ if !ok || len(funcList.Items) < 1 {+ continue+ }+ fc, ok := funcList.Items[0].(*ast.FuncCall)+ if !ok || fc.Funcname == nil {+ continue+ }+ // Get function name.+ funcName := ""+ for _, nameItem := range fc.Funcname.Items {+ if s, ok := nameItem.(*ast.String); ok {+ funcName = s.Str+ }+ }+ if funcName == "" {+ continue+ }+ // Determine number of columns: for set-returning functions like unnest,+ // each argument produces a column.+ nCols := 1+ if fc.Args != nil && len(fc.Args.Items) > 1 {+ nCols = len(fc.Args.Items)+ }+ for range nCols {+ results = append(results, base.QuerySpanResult{+ Name: funcName,+ SourceColumns: base.SourceColumnSet{},+ })+ }+ }+ return results+}++// tryUserFuncTableSource handles the case where AnalyzeSelectStmt fails because+// the FROM clause contains a user-defined RETURNS TABLE function. The omni catalog+// cannot resolve these as table sources, so we look up the function manually,+// analyze its body for lineage, and construct the result.+// Returns nil if this case doesn't apply.+func (e *omniQuerySpanExtractor) tryUserFuncTableSource(selStmt *ast.SelectStmt, accessesMap base.SourceColumnSet) []base.QuerySpanResult {+ if selStmt == nil || selStmt.FromClause == nil {+ return nil+ }++ // Look for a single RangeFunction in the FROM clause.+ for _, item := range selStmt.FromClause.Items {+ rf, ok := item.(*ast.RangeFunction)+ if !ok || rf.Functions == nil {+ continue+ }++ // Extract function name from the RangeFunction.+ funcName := extractFuncNameFromRange(rf)+ if funcName == "" {+ continue+ }++ // Look up the function in the catalog.+ proc := e.lookupUserProcByName(funcName)+ if proc != nil {+ // Found in catalog — use it for lineage analysis.+ outNames := getOutputParamNames(proc)+ if len(outNames) == 0 {+ continue+ }+ bodySets := e.analyzeTableFunctionBody(proc)+ return e.buildFuncResults(outNames, bodySets, accessesMap)+ }++ // Catalog lookup failed — try metadata. This handles cases where+ // the metadata function name differs from the name in the DDL definition.+ if results := e.tryMetadataFuncLookup(funcName, accessesMap); results != nil {+ return results+ }+ }++ return nil+}++// extractFuncNameFromRange extracts the function name from a RangeFunction node.+func extractFuncNameFromRange(rf *ast.RangeFunction) string {+ if rf.Functions == nil {+ return ""+ }+ for _, funcItem := range rf.Functions.Items {+ funcList, ok := funcItem.(*ast.List)+ if !ok || len(funcList.Items) < 1 {+ continue+ }+ fc, ok := funcList.Items[0].(*ast.FuncCall)+ if !ok || fc.Funcname == nil {+ continue+ }+ // Use the last name part — for "schema.func", return "func".+ name := ""+ for _, nameItem := range fc.Funcname.Items {+ if s, ok := nameItem.(*ast.String); ok {+ name = s.Str+ }+ }+ return name+ }+ return ""+}++// lookupUserProcByName finds a user-defined function by name in the catalog,+// searching through schemas in the search path.+func (e *omniQuerySpanExtractor) lookupUserProcByName(name string) *catalog.UserProc {+ lowerName := strings.ToLower(name)+ for _, schemaName := range e.searchPath {+ for _, row := range e.cat.QueryPgProc(schemaName) {+ if strings.ToLower(row.ProName) == lowerName {+ return e.cat.GetUserProcByOID(row.OID)+ }+ }+ }+ return nil+}++// getOutputParamNames returns the names of output parameters (TABLE, OUT, or INOUT mode)+// for a user-defined function. Returns nil if the function has no output params.+func getOutputParamNames(proc *catalog.UserProc) []string {+ var names []string+ for i, mode := range proc.ArgModes {+ if mode == 't' || mode == 'o' || mode == 'b' {+ if i < len(proc.ArgNames) {+ names = append(names, proc.ArgNames[i])+ }+ }+ }+ return names+}++// buildFuncResults constructs QuerySpanResults from output parameter names and+// function body lineage analysis, and populates table-level access in accessesMap.+func (*omniQuerySpanExtractor) buildFuncResults(outNames []string, bodySets []base.SourceColumnSet, accessesMap base.SourceColumnSet) []base.QuerySpanResult {+ for _, colSet := range bodySets {+ for k, v := range colSet {+ accessesMap[base.ColumnResource{+ Database: k.Database,+ Schema: k.Schema,+ Table: k.Table,+ }] = v+ }+ }++ var results []base.QuerySpanResult+ for i, name := range outNames {+ sourceColumns := make(base.SourceColumnSet)+ if i < len(bodySets) {+ for k, v := range bodySets[i] {+ sourceColumns[k] = v+ }+ }+ results = append(results, base.QuerySpanResult{+ Name: name,+ SourceColumns: sourceColumns,+ })+ }+ return results+}++// tryMetadataFuncLookup searches for a function by name in the database metadata+// (not the catalog). This handles cases where the catalog can't resolve the+// function — either because the metadata function name differs from the DDL name,+// or because RETURNS TABLE functions can't be loaded into the catalog.+func (e *omniQuerySpanExtractor) tryMetadataFuncLookup(funcName string, accessesMap base.SourceColumnSet) []base.QuerySpanResult {+ meta, err := e.getDatabaseMetadata(e.defaultDatabase)+ if err != nil || meta == nil {+ return nil+ }++ _, funcs := meta.SearchFunctions(e.searchPath, funcName)+ if len(funcs) == 0 {+ return nil+ }++ // Use the first matching function's definition.+ funcDef := funcs[0].Definition+ if funcDef == "" {+ return nil+ }++ // Parse the function definition to extract output param names and body.+ // We can't rely on the catalog for RETURNS TABLE functions because the+ // catalog may reject them due to type validation.+ outNames, body, lang := parseFuncDefForLineage(funcDef)+ if len(outNames) == 0 || body == "" {+ return nil+ }++ // Construct a synthetic UserProc for body analysis.+ syntheticProc := &catalog.UserProc{+ Name: funcName,+ Language: lang,+ Body: body,+ }+ // Set ArgModes and ArgNames for output params.+ for _, name := range outNames {+ syntheticProc.ArgModes = append(syntheticProc.ArgModes, 't')+ syntheticProc.ArgNames = append(syntheticProc.ArgNames, name)+ }+ // Also extract input params for variable substitution.+ inputNames := parseInputParamNames(funcDef)+ for _, name := range inputNames {+ syntheticProc.ArgModes = append([]byte{'i'}, syntheticProc.ArgModes...)+ syntheticProc.ArgNames = append([]string{name}, syntheticProc.ArgNames...)+ }++ // Use a temporary OID for caching.+ syntheticProc.OID = uint32(0xFFFF0000 + len(e.funcBodyCache))++ bodySets := e.analyzeTableFunctionBody(syntheticProc)+ return e.buildFuncResults(outNames, bodySets, accessesMap)+}++// parseFuncDefForLineage extracts output parameter names, function body, and+// language from a CREATE FUNCTION definition string.+func parseFuncDefForLineage(definition string) (outNames []string, body string, lang string) {+ upper := strings.ToUpper(definition)++ // Extract language.+ if langIdx := strings.Index(upper, "LANGUAGE"); langIdx >= 0 {+ rest := strings.TrimSpace(definition[langIdx+8:])+ parts := strings.Fields(rest)+ if len(parts) > 0 {+ lang = strings.ToLower(strings.TrimRight(parts[0], ";"))+ }+ }++ // Extract body.+ body = extractFuncBodyFromDef(definition)++ // Extract output param names from RETURNS TABLE(name type, ...).+ tableIdx := strings.Index(upper, "RETURNS TABLE")+ if tableIdx < 0 {+ tableIdx = strings.Index(upper, "RETURNS\n TABLE")+ }+ if tableIdx >= 0 {+ rest := definition[tableIdx:]+ parenStart := strings.Index(rest, "(")+ if parenStart >= 0 {+ depth := 0+ parenEnd := -1+ for i := parenStart; i < len(rest); i++ {+ switch rest[i] {+ case '(':+ depth+++ case ')':+ depth--+ if depth == 0 {+ parenEnd = i+ }+ default:+ }+ if parenEnd >= 0 {+ break+ }+ }+ if parenEnd > parenStart {+ paramList := rest[parenStart+1 : parenEnd]+ for _, param := range strings.Split(paramList, ",") {+ parts := strings.Fields(strings.TrimSpace(param))+ if len(parts) >= 2 {+ outNames = append(outNames, parts[0])+ }+ }+ }+ }+ }++ return outNames, body, lang+}++// parseInputParamNames extracts input parameter names from a CREATE FUNCTION+// definition. It parses the parameter list before RETURNS.+func parseInputParamNames(definition string) []string {+ upper := strings.ToUpper(definition)++ // Find the parameter list: between FUNCTION name( and ) RETURNS.+ funcIdx := strings.Index(upper, "FUNCTION")+ if funcIdx < 0 {+ return nil+ }++ rest := definition[funcIdx:]+ parenStart := strings.Index(rest, "(")+ if parenStart < 0 {+ return nil+ }++ // Find the closing paren that ends the input params.+ returnsIdx := strings.Index(upper[funcIdx+parenStart:], "RETURNS")+ if returnsIdx < 0 {+ return nil+ }++ paramSection := rest[parenStart+1 : parenStart+returnsIdx]+ // Find the last ) before RETURNS.+ lastParen := strings.LastIndex(paramSection, ")")+ if lastParen >= 0 {+ paramSection = paramSection[:lastParen]+ }++ modeKeywords := map[string]bool{+ "IN": true, "OUT": true, "INOUT": true, "VARIADIC": true,+ }+ var names []string+ for _, param := range strings.Split(paramSection, ",") {+ parts := strings.Fields(strings.TrimSpace(param))+ if len(parts) < 2 {+ continue+ }+ // If the first word is a mode keyword (IN, OUT, INOUT, VARIADIC),+ // the parameter name is the second word. Otherwise the first word is the name.+ nameIdx := 0+ if modeKeywords[strings.ToUpper(parts[0])] {+ nameIdx = 1+ }+ if nameIdx < len(parts) {+ // Skip OUT/INOUT params — we only want input params for variable scope.+ upperFirst := strings.ToUpper(parts[0])+ if upperFirst == "OUT" {+ continue+ }+ names = append(names, parts[nameIdx])+ }+ }+ return names+}diff --git a/backend/plugin/parser/pg/query_span_loader.go b/backend/plugin/parser/pg/query_span_loader.goindex 900e5acda6..0704d7ba48 100644--- a/backend/plugin/parser/pg/query_span_loader.go+++ b/backend/plugin/parser/pg/query_span_loader.go@@ -546,7 +546,7 @@ func minSortKey(scc []*objectEntry) string {//// Functions are a special case: when a function's real install fails, we// deliberately leave the slot empty. Query span has a dedicated fallback for-// user functions (`tryMetadataFuncLookup` in query_span_omni.go) that+// user functions (`tryMetadataFuncLookup` in query_span.go) that// reconstructs a synthetic proc from metadata at query time. Installing a// text-backed pseudo function would crowd out that path, producing wrong// overload resolution and losing body-level lineage. Tables/views/types arediff --git a/backend/plugin/parser/pg/query_span_omni.go b/backend/plugin/parser/pg/query_span_omni.godeleted file mode 100644index a0208f0656..0000000000--- a/backend/plugin/parser/pg/query_span_omni.go+++ /dev/null@@ -1,1800 +0,0 @@-package pg--import (- "context"- "log/slog"- "strings"-- "github.com/pkg/errors"-- "github.com/bytebase/omni/pg/ast"- "github.com/bytebase/omni/pg/catalog"- omniparser "github.com/bytebase/omni/pg/parser"-- storepb "github.com/bytebase/bytebase/backend/generated-go/store"- "github.com/bytebase/bytebase/backend/plugin/parser/base"- "github.com/bytebase/bytebase/backend/store/model"-)--// omniQuerySpanExtractor extracts query span information using the omni parser-// and catalog, replacing the ANTLR-based querySpanExtractor.-type omniQuerySpanExtractor struct {- ctx context.Context- gCtx base.GetQuerySpanContext- defaultDatabase string- searchPath []string- // metaCache is a lazy-load cache for database metadata.- // Use getDatabaseMetadata() instead of accessing directly.- metaCache map[string]*model.DatabaseMetadata- cat *catalog.Catalog- funcBodyCache map[uint32]*funcBodyAnalysis- // funcOrigDefs stores the original (non-stubbed) function definitions keyed- // by lowercase function name. Used by analyzeFunctionBody to get the real- // body when it was stubbed during catalog loading.- funcOrigDefs map[string]string- // funcSourceColumns accumulates table-level access (column="") discovered inside- // function bodies. Merged into the top-level QuerySpan.SourceColumns.- funcSourceColumns base.SourceColumnSet- // funcPredicateColumns accumulates columns used in fallback WHERE/JOIN- // conditions. Function body analysis records predicates separately so callers- // can decide whether they enter the top-level QuerySpan.PredicateColumns.- funcPredicateColumns base.SourceColumnSet- // fallbackCTEMap holds CTE definitions during fallback column extraction.- // Set by extractFallbackColumns and used by extractColumnsFromRangeVar- // to resolve CTE references.- fallbackCTEMap map[string]*ast.SelectStmt- // fallbackCTEAliases holds CTE column aliases (e.g., WITH t1(cc1, cc2) AS (...)).- // Keyed by lowercase CTE name.- fallbackCTEAliases map[string][]string-- // Catalog loader state — populated by initCatalog.- // degraded records objects whose real install failed and fell back to- // pseudo. Keyed by loader object key (schema.name with kind prefix).- degraded map[string]error- // trulyBroken records objects whose pseudo install also failed.- trulyBroken map[string]error- // loaderObjects records every object collected from metadata. Used by- // tests to distinguish loader bugs from metadata gaps.- loaderObjects map[string]bool- // lastFallbackReason is the classifier's verdict for the most recent- // AnalyzeSelectStmt error at any of the three fallback sites. Used by- // tests; not consumed by production code.- lastFallbackReason fallbackReason-}--// newOmniQuerySpanExtractor creates a new omni-based query span extractor.-func newOmniQuerySpanExtractor(defaultDatabase string, searchPath []string, gCtx base.GetQuerySpanContext) *omniQuerySpanExtractor {- if len(searchPath) == 0 {- searchPath = []string{"public"}- }- return &omniQuerySpanExtractor{- defaultDatabase: defaultDatabase,- searchPath: searchPath,- gCtx: gCtx,- metaCache: make(map[string]*model.DatabaseMetadata),- funcBodyCache: make(map[uint32]*funcBodyAnalysis),- funcOrigDefs: make(map[string]string),- funcSourceColumns: make(base.SourceColumnSet),- funcPredicateColumns: make(base.SourceColumnSet),- }-}--// getDatabaseMetadata returns cached database metadata, fetching it if not yet cached.-func (e *omniQuerySpanExtractor) getDatabaseMetadata(database string) (*model.DatabaseMetadata, error) {- if meta, ok := e.metaCache[database]; ok {- return meta, nil- }- _, meta, err := e.gCtx.GetDatabaseMetadataFunc(e.ctx, e.gCtx.InstanceID, database)- if err != nil {- return nil, errors.Wrapf(err, "failed to get database metadata for database: %s", database)- }- e.metaCache[database] = meta- return meta, nil-}--// initCatalog initializes the omni catalog from the database metadata using-// the Catalog loader. Every metadata object is installed in dependency order,-// with an inline pseudo fallback at any failed slot (see query_span_e3_*.go).-//-// The DDL render + batch-parse path used before this refactor is deleted: BYT-9215 and-// BYT-9261 are unreachable by construction here.-func (e *omniQuerySpanExtractor) initCatalog() error {- meta, err := e.getDatabaseMetadata(e.defaultDatabase)- if err != nil {- return errors.Wrapf(err, "failed to get database metadata for catalog init")- }-- e.cat = catalog.New()- e.cat.SetSearchPath(e.searchPath)-- if meta == nil {- return nil- }-- loader := newCatalogLoader(e.cat, meta.GetProto())- if err := loader.Load(e.ctx); err != nil {- return errors.Wrapf(err, "catalog loader failed for %q", e.defaultDatabase)- }- e.degraded = loader.degraded- e.trulyBroken = loader.trulyBroken- e.loaderObjects = loader.loaderObjects-- if len(loader.degraded) > 0 || len(loader.trulyBroken) > 0 {- slog.Debug("catalog loader degraded objects",- slog.String("database", e.defaultDatabase),- slog.Int("degraded", len(loader.degraded)),- slog.Int("truly_broken", len(loader.trulyBroken)),- )- }-- // Populate original (non-stubbed) function definitions for PL/pgSQL body- // analysis. This is independent of catalog loading and unchanged by the loader.- for _, s := range meta.GetProto().GetSchemas() {- for _, f := range s.GetFunctions() {- if f.Definition == "" {- continue- }- origBody := extractFuncBodyFromDef(f.Definition)- if origBody != "" {- e.funcOrigDefs[strings.ToLower(f.Name)] = origBody- }- }- }-- return nil-}--// extractFuncBodyFromDef extracts the dollar-quoted function body from a-// CREATE FUNCTION definition string.-func extractFuncBodyFromDef(definition string) string {- // Find dollar-quoted body.- tag, bodyStart, bodyEnd := findDollarQuotedBody(definition)- if tag == "" {- return ""- }- return definition[bodyStart : bodyEnd-len(tag)]-}--// findDollarQuotedBody locates the dollar-quoted body in a function definition.-// Returns the tag, the start of body content (after opening tag), and the end-// position (after closing tag).-func findDollarQuotedBody(definition string) (tag string, bodyStart int, bodyEnd int) {- for i := 0; i < len(definition); i++ {- if definition[i] != '$' {- continue- }- // Find end of tag.- tagEnd := i + 1- for tagEnd < len(definition) && definition[tagEnd] != '$' {- tagEnd++- }- if tagEnd >= len(definition) {- continue- }- tag := definition[i : tagEnd+1]- contentStart := tagEnd + 1- // Find closing tag.- closeIdx := strings.Index(definition[contentStart:], tag)- if closeIdx >= 0 {- return tag, contentStart, contentStart + closeIdx + len(tag)- }- }- return "", 0, 0-}--// unresolvedColumnsError checks stored metadata independently of column lineage.-// Accesses are conservative: CTE names can match physical tables, so this may-// refuse a CTE-only query. Reads missing from the access set remain unchecked.-func (e *omniQuerySpanExtractor) unresolvedColumnsError(accesses base.SourceColumnSet) *base.UnresolvedColumnsError {- seen := make(map[base.ColumnResource]bool, len(accesses))- var unresolved []base.ColumnResource- for access := range accesses {- relation := base.ColumnResource{- Server: access.Server,- Database: access.Database,- Schema: access.Schema,- Table: access.Table,- }- if relation.Table == "" || seen[relation] {- continue- }- seen[relation] = true- if e.relationHasNoSyncedColumns(relation) {- unresolved = append(unresolved, relation)- }- }- if len(unresolved) == 0 {- return nil- }- return &base.UnresolvedColumnsError{Relations: unresolved}-}--// relationHasNoSyncedColumns checks tables only: masking policies attach to-// table columns, and GetTable resolves partitions to their parent.-// A legal zero-column table is indistinguishable from degraded metadata and-// remains blocked even after re-syncing.-func (e *omniQuerySpanExtractor) relationHasNoSyncedColumns(relation base.ColumnResource) bool {- meta, err := e.getDatabaseMetadata(relation.Database)- if err != nil || meta == nil {- return false- }- schema := meta.GetSchemaMetadata(relation.Schema)- if schema == nil {- return false- }- table := schema.GetTable(relation.Table)- return table != nil && len(table.GetProto().GetColumns()) == 0-}--// getQuerySpan extracts the query span for the given SQL statement.-func (e *omniQuerySpanExtractor) getQuerySpan(ctx context.Context, stmt string) (*base.QuerySpan, error) {- e.ctx = ctx-- // Step 1: Parse with omni.- omniStmts, err := ParsePg(stmt)- if err != nil {- // Convert omni parse error to *base.SyntaxError with position info- // so the SQL service can populate DetailedError.SyntaxError.- syntaxErr := &base.SyntaxError{- Message: err.Error(),- Position: &storepb.Position{Line: 1, Column: 1},- }- var parseErr *omniparser.ParseError- if errors.As(err, &parseErr) && parseErr.Position > 0 {- syntaxErr.Position = ByteOffsetToRunePosition(stmt, parseErr.Position-1)- }- return nil, syntaxErr- }- if len(omniStmts) != 1 {- return nil, errors.Errorf("expected exactly 1 statement, got %d", len(omniStmts))- }-- // Step 2: Extract access tables (non-fatal on error — some statement- // types like SET don't have table references).- accessesMap := make(base.SourceColumnSet)- accessTables, err := ExtractAccessTables(stmt, ExtractAccessTablesOption{- DefaultDatabase: e.defaultDatabase,- DefaultSchema: e.searchPath[0],- SearchPath: e.searchPath,- GetDatabaseMetadata: e.gCtx.GetDatabaseMetadataFunc,- Ctx: ctx,- InstanceID: e.gCtx.InstanceID,- SkipMetadataValidation: false,- })- if err == nil {- for _, resource := range accessTables {- accessesMap[resource] = true- }- }-- // Step 3: Check for mixed system/user tables.- allSystems, mixed := isMixedQuery(accessesMap)- if mixed {- return nil, base.MixUserSystemTablesError- }-- // Step 4: Classify query type.- queryType, isExplainAnalyze := classifyQueryType(omniStmts[0].AST, allSystems)-- // Step 5: Return early for non-SELECT queries.- if queryType != base.Select {- return &base.QuerySpan{- Type: queryType,- SourceColumns: base.SourceColumnSet{},- Results: []base.QuerySpanResult{},- }, nil- }-- // For EXPLAIN ANALYZE SELECT, return with source columns but no results.- if isExplainAnalyze {- return &base.QuerySpan{- Type: queryType,- SourceColumns: accessesMap,- Results: []base.QuerySpanResult{},- }, nil- }-- // Step 6: Cast to SelectStmt, init catalog, analyze.- selStmt, ok := omniStmts[0].AST.(*ast.SelectStmt)- if !ok {- // Not a SelectStmt (e.g., SET, SHOW classified as Select type).- return &base.QuerySpan{- Type: base.Select,- SourceColumns: accessesMap,- Results: []base.QuerySpanResult{},- }, nil- }-- if err := e.initCatalog(); err != nil {- return nil, errors.Wrapf(err, "failed to initialize catalog")- }-- query, err := e.cat.AnalyzeSelectStmt(selStmt)- if err != nil {- // Record the classifier's verdict for test inspection. This does not- // gate behavior — the fallback below always runs on analyzer errors.- e.lastFallbackReason = classifyAnalyzeError(err)-- // Before falling back, try to handle user-defined table-returning functions- // that omni's AnalyzeSelectStmt can't resolve (e.g., RETURNS TABLE functions- // used as table sources: SELECT * FROM func()).- if results := e.tryUserFuncTableSource(selStmt, accessesMap); results != nil {- return &base.QuerySpan{- Type: base.Select,- SourceColumns: accessesMap,- Results: results,- UnresolvedColumnsError: e.unresolvedColumnsError(accessesMap),- }, nil- }- // Fail-open: return access tables with best-effort column names and lineage- // when analysis fails (e.g., unsupported built-in functions).- return &base.QuerySpan{- Type: base.Select,- SourceColumns: accessesMap,- Results: e.extractFallbackColumns(selStmt),- PredicateColumns: e.funcPredicateColumns,- UnresolvedColumnsError: e.unresolvedColumnsError(accessesMap),- }, nil- }-- // Step 7: Extract lineage from analyzed query.- // SourceColumns (table-level access) is already captured in accessesMap- // from ExtractAccessTables above — no need to re-extract from the query.- results := e.extractLineage(query, selStmt)-- // Merge columns discovered inside function bodies into the top-level sets.- for col := range e.funcSourceColumns {- accessesMap[col] = true- }-- return &base.QuerySpan{- Type: base.Select,- SourceColumns: accessesMap,- PredicateColumns: e.funcPredicateColumns,- Results: results,- UnresolvedColumnsError: e.unresolvedColumnsError(accessesMap),- }, nil-}--// extractLineage extracts the result column lineage from an analyzed query.-// selStmt is the original parse tree, used to determine IsPlainField-// (which is true only for columns that came from * expansion).-func (e *omniQuerySpanExtractor) extractLineage(q *catalog.Query, selStmt *ast.SelectStmt) []base.QuerySpanResult {- return e.extractLineageWithVisited(q, selStmt, make(map[*catalog.Query]bool))-}--func (e *omniQuerySpanExtractor) extractLineageWithVisited(q *catalog.Query, selStmt *ast.SelectStmt, visited map[*catalog.Query]bool) []base.QuerySpanResult {- if q == nil {- return nil- }- if visited[q] {- return nil- }- visited[q] = true- defer delete(visited, q)-- // Handle set operations (UNION/INTERSECT/EXCEPT).- if q.SetOp != catalog.SetOpNone {- return e.extractSetOpLineageWithVisited(q, selStmt, visited)- }-- // Build a plain-field mask from the parse tree's target list.- // IsPlainField = true only for columns expanded from SELECT * or SELECT t.*.- plainMask := buildPlainFieldMask(selStmt, q)-- // Collect parse tree ResTargets for name fixups.- var parseTargets []*ast.ResTarget- if selStmt != nil && selStmt.TargetList != nil {- for _, item := range selStmt.TargetList.Items {- if rt, ok := item.(*ast.ResTarget); ok {- parseTargets = append(parseTargets, rt)- }- }- }-- // Build a helper analyzer for parse-tree fallback extraction.- var analyzer *plpgsqlAnalyzer- var fromTables map[string]base.ColumnResource- if selStmt != nil {- analyzer = &plpgsqlAnalyzer{extractor: e, scope: newVariableScope(nil)}- fromTables = analyzer.collectFromTables(selStmt)- }-- var results []base.QuerySpanResult- idx := 0- for _, te := range q.TargetList {- if te.ResJunk {- continue- }- sourceColSet := make(base.SourceColumnSet)- e.walkExpr(q, te.Expr, sourceColSet)- isPlain := idx < len(plainMask) && plainMask[idx]- // Even if the parse tree says this came from *, the underlying- // expression through CTEs/subqueries may not be a simple column ref.- if isPlain {- isPlain = isUltimatelyPlainColumn(q, te.Expr)- }- name := te.ResName- // When the catalog reduces an expression to ConstExpr (losing column refs,- // e.g., json_object('id': a)), fall back to the parse tree to extract- // column references and derive a better name.- if idx < len(parseTargets) {- if name == "?column?" {- if better := figureResTargetName(parseTargets[idx]); better != "" {- name = better- }- }- if len(sourceColSet) == 0 && analyzer != nil {- analyzer.extractColumnRefsFromExpr(parseTargets[idx].Val, fromTables, sourceColSet)- }- }- results = append(results, base.QuerySpanResult{- Name: name,- SourceColumns: sourceColSet,- IsPlainField: isPlain,- })- idx++- }- return results-}--// isUltimatelyPlainColumn checks whether an expression, after resolving through-// CTEs and subqueries, is a simple column reference (VarExpr pointing to a-// physical table). Aggregates, functions, and other expressions return false.-func isUltimatelyPlainColumn(q *catalog.Query, expr catalog.AnalyzedExpr) bool {- return isUltimatelyPlainColumnWithVisited(q, expr, make(map[queryExprKey]bool))-}--type queryExprKey struct {- query *catalog.Query- expr catalog.AnalyzedExpr-}--func isUltimatelyPlainColumnWithVisited(q *catalog.Query, expr catalog.AnalyzedExpr, visited map[queryExprKey]bool) bool {- if expr == nil {- return false- }- key := queryExprKey{query: q, expr: expr}- if visited[key] {- return false- }- visited[key] = true-- v, ok := expr.(*catalog.VarExpr)- if !ok {- return false- }- if v.RangeIdx < 0 || v.RangeIdx >= len(q.RangeTable) {- return false- }- rte := q.RangeTable[v.RangeIdx]- colIdx := int(v.AttNum - 1)-- switch rte.Kind {- case catalog.RTERelation:- return true- case catalog.RTESubquery:- if rte.Subquery != nil && colIdx >= 0 && colIdx < len(rte.Subquery.TargetList) {- return isUltimatelyPlainColumnWithVisited(rte.Subquery, rte.Subquery.TargetList[colIdx].Expr, visited)- }- case catalog.RTECTE:- if rte.CTEIndex >= 0 && rte.CTEIndex < len(q.CTEList) {- cte := q.CTEList[rte.CTEIndex]- if cte.Query != nil && colIdx >= 0 && colIdx < len(cte.Query.TargetList) {- return isUltimatelyPlainColumnWithVisited(cte.Query, cte.Query.TargetList[colIdx].Expr, visited)- }- }- default:- return false- }- return false-}--// buildPlainFieldMask returns a boolean slice aligned with the analyzed-// query's non-junk TargetList. An entry is true if the column was produced-// by * expansion (SELECT * or SELECT t.*), false for explicit column refs.-func buildPlainFieldMask(selStmt *ast.SelectStmt, q *catalog.Query) []bool {- // Collect non-junk target entries.- var targets []*catalog.TargetEntry- for _, te := range q.TargetList {- if !te.ResJunk {- targets = append(targets, te)- }- }- nResults := len(targets)-- if selStmt == nil || selStmt.TargetList == nil {- return make([]bool, nResults)- }-- // Count parse-tree items (stars and non-stars).- var parseTargets []*ast.ResTarget- for _, item := range selStmt.TargetList.Items {- if rt, ok := item.(*ast.ResTarget); ok {- parseTargets = append(parseTargets, rt)- }- }-- // For each star, determine how many columns it expands to by- // looking at the table it references and counting columns in that RTE.- mask := make([]bool, nResults)- pos := 0-- for _, rt := range parseTargets {- if pos >= nResults {- break- }- if isStarTarget(rt) {- tableName := starTableName(rt)- starCount := countStarColumnsFromRTE(q, targets, pos, tableName)- for i := 0; i < starCount && pos < nResults; i++ {- mask[pos] = true- pos++- }- } else {- mask[pos] = false- pos++- }- }-- return mask-}--// isStarTarget checks if a ResTarget in the parse tree is a star expression-// (SELECT * or SELECT t.*).-func isStarTarget(rt *ast.ResTarget) bool {- if rt == nil || rt.Val == nil {- return false- }- cr, ok := rt.Val.(*ast.ColumnRef)- if !ok || cr.Fields == nil || len(cr.Fields.Items) == 0 {- return false- }- last := cr.Fields.Items[len(cr.Fields.Items)-1]- _, isStar := last.(*ast.A_Star)- return isStar-}--// starTableName extracts the table qualifier from a star target.-// For "SELECT *" returns "", for "SELECT t.*" returns "t".-func starTableName(rt *ast.ResTarget) string {- cr, ok := rt.Val.(*ast.ColumnRef)- if !ok || cr.Fields == nil {- return ""- }- // For t.*, Fields = [String("t"), A_Star{}]- if len(cr.Fields.Items) >= 2 {- if s, ok := cr.Fields.Items[0].(*ast.String); ok {- return s.Str- }- }- return ""-}--// countStarColumnsFromRTE counts how many analyzed target entries starting-// at pos belong to a star expansion. For unqualified * (tableName=""), it-// counts entries that share the same contiguous RangeIdx sequence covering-// all non-join RTEs. For qualified t.* (tableName="t"), it counts entries-// whose RTE ERef matches the table name.-func countStarColumnsFromRTE(q *catalog.Query, targets []*catalog.TargetEntry, startPos int, tableName string) int {- if startPos >= len(targets) {- return 0- }-- if tableName != "" {- // Qualified star: count consecutive entries from the named RTE.- count := 0- for i := startPos; i < len(targets); i++ {- v, ok := targets[i].Expr.(*catalog.VarExpr)- if !ok {- break- }- if v.RangeIdx < 0 || v.RangeIdx >= len(q.RangeTable) {- break- }- rte := q.RangeTable[v.RangeIdx]- if rte.ERef != tableName && rte.Alias != tableName {- break- }- count++- }- if count == 0 {- return 1- }- return count- }-- // Unqualified star: expands all non-join RTEs in FROM order.- // Count how many consecutive VarExprs follow the expected star expansion pattern.- count := 0- for i := startPos; i < len(targets); i++ {- v, ok := targets[i].Expr.(*catalog.VarExpr)- if !ok {- break- }- if v.RangeIdx < 0 || v.RangeIdx >= len(q.RangeTable) {- break- }- rte := q.RangeTable[v.RangeIdx]- if rte.Kind == catalog.RTEJoin {- break- }- // Check if this column's AttNum is sequential within its RTE.- // Star expansion produces columns in order: attnum 1, 2, 3, ...- if count > 0 {- if prev, ok := targets[i-1].Expr.(*catalog.VarExpr); ok && v.RangeIdx == prev.RangeIdx && v.AttNum != prev.AttNum+1 {- break- }- }- count++- }- if count == 0 {- return 1- }- return count-}--func (e *omniQuerySpanExtractor) extractSetOpLineageWithVisited(q *catalog.Query, selStmt *ast.SelectStmt, visited map[*catalog.Query]bool) []base.QuerySpanResult {- if q.LArg == nil || q.RArg == nil {- return nil- }- var lSelStmt, rSelStmt *ast.SelectStmt- if selStmt != nil {- lSelStmt = selStmt.Larg- rSelStmt = selStmt.Rarg- }- lResults := e.extractLineageWithVisited(q.LArg, lSelStmt, visited)- rResults := e.extractLineageWithVisited(q.RArg, rSelStmt, visited)-- // For EXCEPT, output rows come only from the left branch — do not- // merge right-side lineage into the result columns.- includeRight := q.SetOp != catalog.SetOpExcept && q.SetOp != catalog.SetOpExceptAll-- var results []base.QuerySpanResult- for i, lr := range lResults {- merged := make(base.SourceColumnSet)- for col := range lr.SourceColumns {- merged[col] = true- }- if includeRight && i < len(rResults) {- for col := range rResults[i].SourceColumns {- merged[col] = true- }- }- results = append(results, base.QuerySpanResult{- Name: lr.Name,- SourceColumns: merged,- IsPlainField: false, // set-op results are never plain fields- })- }- return results-}--// walkExpr recursively walks an analyzed expression tree and collects all-// source column references into the result set.-func (e *omniQuerySpanExtractor) walkExpr(q *catalog.Query, expr catalog.AnalyzedExpr, result base.SourceColumnSet) {- e.walkExprWithVisited([]*catalog.Query{q}, expr, result, make(map[queryExprKey]bool))-}--func (e *omniQuerySpanExtractor) walkExprWithVisited(queryStack []*catalog.Query, expr catalog.AnalyzedExpr, result base.SourceColumnSet, visited map[queryExprKey]bool) {- if expr == nil {- return- }- q := currentQuery(queryStack)- if q == nil {- return- }- key := queryExprKey{query: q, expr: expr}- if visited[key] {- return- }- visited[key] = true-- switch v := expr.(type) {- case *catalog.VarExpr:- e.resolveVar(queryStack, v, result, visited)- case *catalog.FuncCallExpr:- // Walk arguments first — they contribute to access tables.- for _, arg := range v.Args {- e.walkExprWithVisited(queryStack, arg, result, visited)- }- // Trace lineage through user-defined function body.- if proc := e.cat.GetUserProcByOID(v.FuncOID); proc != nil {- // Expression context: merge all output columns into one set.- for _, colSet := range e.analyzeFunctionBody(proc) {- for k, val := range colSet {- result[k] = val- }- }- }- case *catalog.AggExpr:- for _, arg := range v.Args {- e.walkExprWithVisited(queryStack, arg, result, visited)- }- case *catalog.OpExpr:- e.walkExprWithVisited(queryStack, v.Left, result, visited)- e.walkExprWithVisited(queryStack, v.Right, result, visited)- case *catalog.BoolExprQ:- for _, arg := range v.Args {- e.walkExprWithVisited(queryStack, arg, result, visited)- }- case *catalog.CaseExprQ:- e.walkExprWithVisited(queryStack, v.Arg, result, visited)- for _, w := range v.When {- e.walkExprWithVisited(queryStack, w.Condition, result, visited)- e.walkExprWithVisited(queryStack, w.Result, result, visited)- }- e.walkExprWithVisited(queryStack, v.Default, result, visited)- case *catalog.CoalesceExprQ:- for _, arg := range v.Args {- e.walkExprWithVisited(queryStack, arg, result, visited)- }- case *catalog.SubLinkExpr:- e.walkExprWithVisited(queryStack, v.TestExpr, result, visited)- if v.SubQuery != nil {- subQueryStack := appendQuery(queryStack, v.SubQuery)- for _, te := range v.SubQuery.TargetList {- if !te.ResJunk {- e.walkExprWithVisited(subQueryStack, te.Expr, result, visited)- }- }- }- case *catalog.RelabelExpr:- e.walkExprWithVisited(queryStack, v.Arg, result, visited)- case *catalog.CoerceViaIOExpr:- e.walkExprWithVisited(queryStack, v.Arg, result, visited)- case *catalog.RowExprQ:- for _, arg := range v.Args {- e.walkExprWithVisited(queryStack, arg, result, visited)- }- case *catalog.WindowFuncExpr:- for _, arg := range v.Args {- e.walkExprWithVisited(queryStack, arg, result, visited)- }- e.walkExprWithVisited(queryStack, v.AggFilter, result, visited)- case *catalog.NullIfExprQ:- for _, arg := range v.Args {- e.walkExprWithVisited(queryStack, arg, result, visited)- }- case *catalog.MinMaxExprQ:- for _, arg := range v.Args {- e.walkExprWithVisited(queryStack, arg, result, visited)- }- case *catalog.ArrayExprQ:- for _, elem := range v.Elements {- e.walkExprWithVisited(queryStack, elem, result, visited)- }- case *catalog.ScalarArrayOpExpr:- e.walkExprWithVisited(queryStack, v.Left, result, visited)- e.walkExprWithVisited(queryStack, v.Right, result, visited)- case *catalog.CollateExprQ:- e.walkExprWithVisited(queryStack, v.Arg, result, visited)- case *catalog.NullTestExpr:- e.walkExprWithVisited(queryStack, v.Arg, result, visited)- case *catalog.BooleanTestExpr:- e.walkExprWithVisited(queryStack, v.Arg, result, visited)- case *catalog.DistinctExprQ:- e.walkExprWithVisited(queryStack, v.Left, result, visited)- e.walkExprWithVisited(queryStack, v.Right, result, visited)- case *catalog.FieldSelectExprQ:- e.walkExprWithVisited(queryStack, v.Arg, result, visited)- // ConstExpr, SQLValueFuncExpr, CoerceToDomainValueExpr — no column refs.- default:- }-}--func currentQuery(queryStack []*catalog.Query) *catalog.Query {- if len(queryStack) == 0 {- return nil- }- return queryStack[len(queryStack)-1]-}--func appendQuery(queryStack []*catalog.Query, q *catalog.Query) []*catalog.Query {- nextStack := make([]*catalog.Query, 0, len(queryStack)+1)- nextStack = append(nextStack, queryStack...)- if q == nil {- return nextStack- }- return append(nextStack, q)-}--// resolveVar resolves a VarExpr to its ultimate source column(s).-func (e *omniQuerySpanExtractor) resolveVar(queryStack []*catalog.Query, v *catalog.VarExpr, result base.SourceColumnSet, visited map[queryExprKey]bool) {- q := currentQuery(queryStack)- effectiveStack := queryStack- if v.LevelsUp > 0 {- ancestorIdx := len(queryStack) - 1 - v.LevelsUp- if ancestorIdx < 0 {- return- }- q = queryStack[ancestorIdx]- effectiveStack = queryStack[:ancestorIdx+1]- }- if q == nil {- return- }- if v.RangeIdx < 0 || v.RangeIdx >= len(q.RangeTable) {- return- }- rte := q.RangeTable[v.RangeIdx]- colIdx := int(v.AttNum - 1) // AttNum is 1-based-- switch rte.Kind {- case catalog.RTERelation:- rel := e.cat.GetRelationByOID(rte.RelOID)- if rel == nil || rel.Schema == nil {- return- }- // Standalone composite types are not FROM-able; a valid analysis- // never produces such an RTE, so treat it as unresolved.- if rel.RelKind == 'c' {- return- }- colName := ""- if colIdx >= 0 && colIdx < len(rte.ColNames) {- colName = rte.ColNames[colIdx]- }- result[base.ColumnResource{- Database: e.defaultDatabase,- Schema: rel.Schema.Name,- Table: rel.Name,- Column: colName,- }] = true-- case catalog.RTESubquery:- if rte.Subquery == nil {- return- }- if colIdx >= 0 && colIdx < len(rte.Subquery.TargetList) {- te := rte.Subquery.TargetList[colIdx]- e.walkExprWithVisited(appendQuery(effectiveStack, rte.Subquery), te.Expr, result, visited)- }-- case catalog.RTECTE:- if cte := findCTEForRangeTableEntry(effectiveStack, rte); cte != nil && cte.Query != nil && colIdx >= 0 && colIdx < len(cte.Query.TargetList) {- te := cte.Query.TargetList[colIdx]- e.walkExprWithVisited(appendQuery(effectiveStack, cte.Query), te.Expr, result, visited)- }-- case catalog.RTEJoin:- // After analysis, VarExprs typically point to base RTEs, not join RTEs.-- case catalog.RTEFunction:- // Trace lineage through user-defined function body.- if len(rte.FuncExprs) > 0 {- if fc, ok := rte.FuncExprs[0].(*catalog.FuncCallExpr); ok {- if proc := e.cat.GetUserProcByOID(fc.FuncOID); proc != nil {- bodySets := e.analyzeTableFunctionBody(proc)- if colIdx >= 0 && colIdx < len(bodySets) {- for k, val := range bodySets[colIdx] {- result[k] = val- }- }- } else {- // Built-in function (no user proc) — trace lineage through- // the function's arguments. E.g., jsonb_each(a) depends on column a.- for _, arg := range fc.Args {- e.walkExprWithVisited(effectiveStack, arg, result, visited)- }- }- }- }-- default:- // Unknown RTE kind — skip.- }-}--func findCTEForRangeTableEntry(queryStack []*catalog.Query, rte *catalog.RangeTableEntry) *catalog.CommonTableExprQ {- if len(queryStack) == 0 || rte == nil {- return nil- }-- current := currentQuery(queryStack)- if current != nil && rte.CTEIndex >= 0 && rte.CTEIndex < len(current.CTEList) {- return current.CTEList[rte.CTEIndex]- }-- if rte.CTEName == "" {- return nil- }- for i := len(queryStack) - 1; i >= 0; i-- {- for _, cte := range queryStack[i].CTEList {- if strings.EqualFold(cte.Name, rte.CTEName) {- return cte- }- }- }- return nil-}--// extractFallbackColumns attempts to extract column names and lineage from the parse tree-// when AnalyzeSelectStmt fails. It walks the AST to find column references and resolves-// them against tables in the FROM clause.-func (e *omniQuerySpanExtractor) extractFallbackColumns(selStmt *ast.SelectStmt) []base.QuerySpanResult {- if selStmt == nil {- return nil- }-- // Build a helper analyzer to reuse column reference extraction.- analyzer := &plpgsqlAnalyzer{- extractor: e,- scope: newVariableScope(nil),- }- fromTables := analyzer.collectFromTables(selStmt)-- // Build CTE map so we can trace through CTEs to real tables.- cteMap := collectCTEDefinitions(selStmt)- analyzer.cteMap = cteMap- // Store cteMap on the extractor so extractColumnsFromRangeVar can resolve CTEs.- e.fallbackCTEMap = cteMap- e.fallbackCTEAliases = collectCTEAliases(selStmt)-- // Check if SELECT has explicit target list (not *).- if selStmt.TargetList != nil {- var results []base.QuerySpanResult- allStar := true- for _, item := range selStmt.TargetList.Items {- rt, ok := item.(*ast.ResTarget)- if !ok {- continue- }- if !isStarTarget(rt) {- allStar = false- name := rt.Name- if name == "" {- name = figureResTargetName(rt)- }- // PostgreSQL uses "?column?" for unnamed result columns.- if name == "" {- name = "?column?"- }- // Extract column references from the expression for lineage.- colSet := make(base.SourceColumnSet)- analyzer.extractColumnRefsFromExpr(rt.Val, fromTables, colSet)- results = append(results, base.QuerySpanResult{- Name: name,- SourceColumns: colSet,- })- }- }- if !allStar && len(results) > 0 {- // Also extract WHERE clause columns for predicate tracking.- if selStmt.WhereClause != nil {- whereColSet := make(base.SourceColumnSet)- analyzer.extractColumnRefsFromExpr(selStmt.WhereClause, fromTables, whereColSet)- for k, v := range whereColSet {- e.funcPredicateColumns[k] = v- }- }- return results- }- }-- // For SELECT *, combine columns from ALL FROM clause items.- if selStmt.FromClause != nil {- var allCols []base.QuerySpanResult- for _, item := range selStmt.FromClause.Items {- allCols = append(allCols, e.extractColumnsFromFromItem(item, analyzer, fromTables)...)- }- if len(allCols) > 0 {- return allCols- }- }-- return nil-}--// figureResTargetName extracts a column name from a ResTarget's expression.-func figureResTargetName(rt *ast.ResTarget) string {- if rt == nil || rt.Val == nil {- return ""- }- if cr, ok := rt.Val.(*ast.ColumnRef); ok && cr.Fields != nil {- // Use the last String field — for "ia.approver_emails", return "approver_emails".- // For unqualified "col", return "col". Skip A_Star nodes.- name := ""- for _, f := range cr.Fields.Items {- if s, ok := f.(*ast.String); ok {- name = s.Str- }- }- return name- }- if fc, ok := rt.Val.(*ast.FuncCall); ok && fc.Funcname != nil {- // Use the last name part — for "pg_catalog.func", return "func".- name := ""- for _, f := range fc.Funcname.Items {- if s, ok := f.(*ast.String); ok {- name = s.Str- }- }- return name- }- // SQL/JSON constructors.- if _, ok := rt.Val.(*ast.JsonObjectConstructor); ok {- return "json_object"- }- if _, ok := rt.Val.(*ast.JsonArrayConstructor); ok {- return "json_array"- }- return ""-}--// extractColumnsFromFromItem extracts column names from a FROM clause item.-// For RangeVar (tables), it looks up the catalog for column names and lineage.-// For RangeFunction, it uses function name or alias column names.-// analyzer and fromTables are optional (may be nil) and used for resolving-// function argument column refs in the fallback path.-func (e *omniQuerySpanExtractor) extractColumnsFromFromItem(item ast.Node, analyzer *plpgsqlAnalyzer, fromTables map[string]base.ColumnResource) []base.QuerySpanResult {- if item == nil {- return nil- }-- switch v := item.(type) {- case *ast.RangeVar:- return e.extractColumnsFromRangeVar(v)- case *ast.RangeFunction:- return e.extractColumnsFromRangeFunction(v, analyzer, fromTables)- case *ast.RangeSubselect:- if v.Alias != nil && v.Alias.Colnames != nil && len(v.Alias.Colnames.Items) > 0 {- return extractColnamesFromAlias(v.Alias)- }- // No explicit column aliases — extract column names from subquery's target list- // (only when the target list has explicit columns, not SELECT *).- if subSel, ok := v.Subquery.(*ast.SelectStmt); ok && subSel.TargetList != nil {- var results []base.QuerySpanResult- hasStar := false- for _, item := range subSel.TargetList.Items {- rt, ok := item.(*ast.ResTarget)- if !ok {- continue- }- if isStarTarget(rt) {- hasStar = true- break- }- name := rt.Name- if name == "" {- name = figureResTargetName(rt)- }- if name == "" {- name = "?column?"- }- results = append(results, base.QuerySpanResult{- Name: name,- SourceColumns: base.SourceColumnSet{},- })- }- if !hasStar && len(results) > 0 {- return results- }- // For SELECT * in subquery, try to resolve columns from the subquery's FROM tables.- if hasStar && subSel.FromClause != nil {- var starResults []base.QuerySpanResult- for _, fromItem := range subSel.FromClause.Items {- starResults = append(starResults, e.extractColumnsFromFromItem(fromItem, analyzer, fromTables)...)- }- if len(starResults) > 0 {- return starResults- }- }- }- return nil- case *ast.JoinExpr:- var results []base.QuerySpanResult- results = append(results, e.extractColumnsFromFromItem(v.Larg, analyzer, fromTables)...)- results = append(results, e.extractColumnsFromFromItem(v.Rarg, analyzer, fromTables)...)- return results- default:- return nil- }-}--// extractColumnsFromRangeVar looks up a table in the catalog and returns its columns with lineage.-// If the table name matches a CTE in fallbackCTEMap, it extracts columns from the CTE definition.-func (e *omniQuerySpanExtractor) extractColumnsFromRangeVar(rv *ast.RangeVar) []base.QuerySpanResult {- // Check if this is a CTE reference.- if rv.Schemaname == "" && e.fallbackCTEMap != nil {- if cteSel, ok := e.fallbackCTEMap[strings.ToLower(rv.Relname)]; ok {- return e.extractColumnsFromCTE(rv.Relname, cteSel)- }- }-- var rel *catalog.Relation- if rv.Schemaname != "" {- rel = e.cat.GetRelation(rv.Schemaname, rv.Relname)- } else {- for _, schema := range e.searchPath {- rel = e.cat.GetRelation(schema, rv.Relname)- if rel != nil {- break- }- }- }- if rel == nil {- return nil- }- // Standalone composite types share the relation namespace but are not- // FROM-able; PostgreSQL rejects them as table sources.- if rel.RelKind == 'c' {- return nil- }- var results []base.QuerySpanResult- for _, col := range rel.Columns {- colSet := make(base.SourceColumnSet)- colSet[base.ColumnResource{- Database: e.defaultDatabase,- Schema: rel.Schema.Name,- Table: rel.Name,- Column: col.Name,- }] = true- results = append(results, base.QuerySpanResult{- Name: col.Name,- SourceColumns: colSet,- IsPlainField: true,- })- }- return results-}--// extractColumnsFromCTE extracts columns from a CTE definition.-// For UNION CTEs, it uses the left branch (the non-recursive term) for column names-// and merges lineage from both branches.-func (e *omniQuerySpanExtractor) extractColumnsFromCTE(cteName string, cteSel *ast.SelectStmt) []base.QuerySpanResult {- if cteSel == nil {- return nil- }-- // Build a helper analyzer.- analyzer := &plpgsqlAnalyzer{- extractor: e,- scope: newVariableScope(nil),- cteMap: e.fallbackCTEMap,- }-- // For UNION (recursive or not), use the left branch for column names- // and extract lineage from both branches.- if cteSel.Larg != nil {- leftResults := e.extractCTEBranchColumns(analyzer, cteSel.Larg)- rightResults := e.extractCTEBranchColumns(analyzer, cteSel.Rarg)-- // Merge right-branch lineage into left-branch results.- for i := range leftResults {- if i < len(rightResults) {- for k, v := range rightResults[i].SourceColumns {- leftResults[i].SourceColumns[k] = v- }- }- }-- // For recursive CTEs, the recursive term references CTE columns- // (e.g., cc1*cc2). Track which CTE columns each recursive expression- // depends on, then resolve those to source columns from the non-recursive term.- if selectReferencesTable(cteSel.Rarg, cteName) {- aliases := e.getCTEColumnAliases(cteName)- if len(aliases) == 0 {- // No explicit aliases — use the column names from leftResults.- for _, r := range leftResults {- aliases = append(aliases, r.Name)- }- }- e.mergeRecursiveCTELineage(leftResults, cteSel.Rarg, cteName, aliases)- }-- // Look up CTE column aliases from the WithClause.- if aliases := e.getCTEColumnAliases(cteName); len(aliases) > 0 {- for i := range leftResults {- if i < len(aliases) {- leftResults[i].Name = aliases[i]- }- }- }-- return leftResults- }-- // Simple CTE (no UNION) — extract directly.- return e.extractCTEBranchColumns(analyzer, cteSel)-}--// extractCTEBranchColumns extracts column names and lineage from a single CTE branch.-func (*omniQuerySpanExtractor) extractCTEBranchColumns(analyzer *plpgsqlAnalyzer, sel *ast.SelectStmt) []base.QuerySpanResult {- if sel == nil || sel.TargetList == nil {- return nil- }-- fromTables := analyzer.collectFromTables(sel)-- var results []base.QuerySpanResult- for _, item := range sel.TargetList.Items {- rt, ok := item.(*ast.ResTarget)- if !ok {- continue- }- name := rt.Name- if name == "" {- name = figureResTargetName(rt)- }- colSet := make(base.SourceColumnSet)- analyzer.extractColumnRefsFromExpr(rt.Val, fromTables, colSet)- results = append(results, base.QuerySpanResult{- Name: name,- SourceColumns: colSet,- })- }- return results-}--// getCTEColumnAliases returns the column aliases defined on a CTE (e.g., t1(cc1, cc2, cc3)).-func (e *omniQuerySpanExtractor) getCTEColumnAliases(cteName string) []string {- if e.fallbackCTEAliases == nil {- return nil- }- return e.fallbackCTEAliases[strings.ToLower(cteName)]-}--// selectReferencesTable checks if a SELECT statement references a table name-// in its FROM clause. Used to detect recursive CTEs.-func selectReferencesTable(sel *ast.SelectStmt, tableName string) bool {- if sel == nil || sel.FromClause == nil {- return false- }- lower := strings.ToLower(tableName)- for _, item := range sel.FromClause.Items {- if nodeReferencesTable(item, lower) {- return true- }- }- return false-}--func nodeReferencesTable(node ast.Node, tableName string) bool {- if node == nil {- return false- }- switch v := node.(type) {- case *ast.RangeVar:- return strings.ToLower(v.Relname) == tableName- case *ast.JoinExpr:- return nodeReferencesTable(v.Larg, tableName) || nodeReferencesTable(v.Rarg, tableName)- default:- return false- }-}--// mergeRecursiveCTELineage tracks which CTE columns each expression in the-// recursive term depends on, then resolves those to source columns from the-// non-recursive term results.-func (*omniQuerySpanExtractor) mergeRecursiveCTELineage(results []base.QuerySpanResult, recursiveSel *ast.SelectStmt, _ string, cteColNames []string) {- if recursiveSel == nil || recursiveSel.TargetList == nil {- return- }-- // Build a map of CTE column name → index (for resolving references).- cteColIndex := make(map[string]int)- for i, name := range cteColNames {- cteColIndex[strings.ToLower(name)] = i- }-- // For each expression in the recursive term, find which CTE columns it references.- for i, item := range recursiveSel.TargetList.Items {- if i >= len(results) {- break- }- rt, ok := item.(*ast.ResTarget)- if !ok {- continue- }-- // Collect all column references from this expression.- refs := collectColumnRefNames(rt.Val)-- // For each referenced column, if it's a CTE column, merge that column's- // source set into this result's source set.- for _, ref := range refs {- if idx, ok := cteColIndex[strings.ToLower(ref)]; ok && idx < len(results) {- for k, v := range results[idx].SourceColumns {- results[i].SourceColumns[k] = v- }- }- }- }-}--// collectColumnRefNames extracts all unqualified column reference names from an expression.-func collectColumnRefNames(node ast.Node) []string {- if node == nil {- return nil- }- var names []string- switch v := node.(type) {- case *ast.ColumnRef:- if v.Fields != nil && len(v.Fields.Items) == 1 {- if s, ok := v.Fields.Items[0].(*ast.String); ok {- names = append(names, s.Str)- }- }- case *ast.FuncCall:- if v.Args != nil {- for _, arg := range v.Args.Items {- names = append(names, collectColumnRefNames(arg)...)- }- }- case *ast.A_Expr:- names = append(names, collectColumnRefNames(v.Lexpr)...)- names = append(names, collectColumnRefNames(v.Rexpr)...)- case *ast.TypeCast:- names = append(names, collectColumnRefNames(v.Arg)...)- default:- }- return names-}--// collectCTEAliases extracts CTE column aliases from the WITH clause.-func collectCTEAliases(selStmt *ast.SelectStmt) map[string][]string {- if selStmt == nil || selStmt.WithClause == nil {- return nil- }-- aliasMap := make(map[string][]string)- for _, item := range selStmt.WithClause.Ctes.Items {- cte, ok := item.(*ast.CommonTableExpr)- if !ok {- continue- }- if cte.Aliascolnames == nil || len(cte.Aliascolnames.Items) == 0 {- continue- }- var aliases []string- for _, nameItem := range cte.Aliascolnames.Items {- if s, ok := nameItem.(*ast.String); ok {- aliases = append(aliases, s.Str)- }- }- if len(aliases) > 0 {- aliasMap[strings.ToLower(cte.Ctename)] = aliases- }- }- return aliasMap-}--// extractColumnsFromRangeFunction extracts columns from a function in FROM clause.-// It first tries to look up user-defined functions in the catalog for lineage tracing.-// analyzer and fromTables are optional and used for resolving function argument column refs.-func (e *omniQuerySpanExtractor) extractColumnsFromRangeFunction(rf *ast.RangeFunction, analyzer *plpgsqlAnalyzer, fromTables map[string]base.ColumnResource) []base.QuerySpanResult {- // Try to resolve user-defined function for lineage tracing.- funcName := extractFuncNameFromRange(rf)- if funcName != "" && e.cat != nil {- // First try catalog lookup.- if proc := e.lookupUserProcByName(funcName); proc != nil {- outNames := getOutputParamNames(proc)- if len(outNames) > 0 {- bodySets := e.analyzeTableFunctionBody(proc)- var results []base.QuerySpanResult- for i, name := range outNames {- colSet := make(base.SourceColumnSet)- if i < len(bodySets) {- for k, v := range bodySets[i] {- colSet[k] = v- }- }- results = append(results, base.QuerySpanResult{- Name: name,- SourceColumns: colSet,- })- }- return results- }- }- // Catalog lookup failed — try metadata (for RETURNS TABLE functions).- dummyAccesses := make(base.SourceColumnSet)- if metaResults := e.tryMetadataFuncLookup(funcName, dummyAccesses); metaResults != nil {- return metaResults- }- }-- if rf.Alias != nil && rf.Alias.Colnames != nil && len(rf.Alias.Colnames.Items) > 0 {- // Even with alias column names, resolve function arg column refs for lineage.- results := extractColnamesFromAlias(rf.Alias)- e.enrichFuncResultsWithArgLineage(rf, analyzer, fromTables, results)- return results- }- results := extractFuncColumnNames(rf, rf.Alias)- e.enrichFuncResultsWithArgLineage(rf, analyzer, fromTables, results)- return results-}--// enrichFuncResultsWithArgLineage resolves column references from function arguments-// and adds them as source columns to all function result columns.-// For built-in functions like jsonb_each(a), the output depends on the input column a.-func (*omniQuerySpanExtractor) enrichFuncResultsWithArgLineage(rf *ast.RangeFunction, analyzer *plpgsqlAnalyzer, fromTables map[string]base.ColumnResource, results []base.QuerySpanResult) {- if analyzer == nil || fromTables == nil || rf.Functions == nil || len(results) == 0 {- return- }-- // Collect source columns from all function arguments.- argSources := make(base.SourceColumnSet)- for _, funcItem := range rf.Functions.Items {- funcList, ok := funcItem.(*ast.List)- if !ok || len(funcList.Items) < 1 {- continue- }- fc, ok := funcList.Items[0].(*ast.FuncCall)- if !ok || fc.Args == nil {- continue- }- for _, arg := range fc.Args.Items {- analyzer.extractColumnRefsFromExpr(arg, fromTables, argSources)- }- }-- // Apply argument source columns to all result columns.- for i := range results {- for k, v := range argSources {- if results[i].SourceColumns == nil {- results[i].SourceColumns = make(base.SourceColumnSet)- }- results[i].SourceColumns[k] = v- }- }-}--// extractColnamesFromAlias extracts column names from an alias's column name list.-func extractColnamesFromAlias(alias *ast.Alias) []base.QuerySpanResult {- if alias == nil || alias.Colnames == nil {- return nil- }- var results []base.QuerySpanResult- for _, item := range alias.Colnames.Items {- if s, ok := item.(*ast.String); ok {- results = append(results, base.QuerySpanResult{- Name: s.Str,- SourceColumns: base.SourceColumnSet{},- })- }- }- return results-}--// extractFuncColumnNames extracts column names from a RangeFunction.-// For functions like unnest(ARRAY, ARRAY), each argument produces a column-// named after the function.-func extractFuncColumnNames(rf *ast.RangeFunction, _ *ast.Alias) []base.QuerySpanResult {- if rf.Functions == nil {- return nil- }-- var results []base.QuerySpanResult- for _, funcItem := range rf.Functions.Items {- funcList, ok := funcItem.(*ast.List)- if !ok || len(funcList.Items) < 1 {- continue- }- fc, ok := funcList.Items[0].(*ast.FuncCall)- if !ok || fc.Funcname == nil {- continue- }- // Get function name.- funcName := ""- for _, nameItem := range fc.Funcname.Items {- if s, ok := nameItem.(*ast.String); ok {- funcName = s.Str- }- }- if funcName == "" {- continue- }- // Determine number of columns: for set-returning functions like unnest,- // each argument produces a column.- nCols := 1- if fc.Args != nil && len(fc.Args.Items) > 1 {- nCols = len(fc.Args.Items)- }- for range nCols {- results = append(results, base.QuerySpanResult{- Name: funcName,- SourceColumns: base.SourceColumnSet{},- })- }- }- return results-}--// tryUserFuncTableSource handles the case where AnalyzeSelectStmt fails because-// the FROM clause contains a user-defined RETURNS TABLE function. The omni catalog-// cannot resolve these as table sources, so we look up the function manually,-// analyze its body for lineage, and construct the result.-// Returns nil if this case doesn't apply.-func (e *omniQuerySpanExtractor) tryUserFuncTableSource(selStmt *ast.SelectStmt, accessesMap base.SourceColumnSet) []base.QuerySpanResult {- if selStmt == nil || selStmt.FromClause == nil {- return nil- }-- // Look for a single RangeFunction in the FROM clause.- for _, item := range selStmt.FromClause.Items {- rf, ok := item.(*ast.RangeFunction)- if !ok || rf.Functions == nil {- continue- }-- // Extract function name from the RangeFunction.- funcName := extractFuncNameFromRange(rf)- if funcName == "" {- continue- }-- // Look up the function in the catalog.- proc := e.lookupUserProcByName(funcName)- if proc != nil {- // Found in catalog — use it for lineage analysis.- outNames := getOutputParamNames(proc)- if len(outNames) == 0 {- continue- }- bodySets := e.analyzeTableFunctionBody(proc)- return e.buildFuncResults(outNames, bodySets, accessesMap)- }-- // Catalog lookup failed — try metadata. This handles cases where- // the metadata function name differs from the name in the DDL definition.- if results := e.tryMetadataFuncLookup(funcName, accessesMap); results != nil {- return results- }- }-- return nil-}--// extractFuncNameFromRange extracts the function name from a RangeFunction node.-func extractFuncNameFromRange(rf *ast.RangeFunction) string {- if rf.Functions == nil {- return ""- }- for _, funcItem := range rf.Functions.Items {- funcList, ok := funcItem.(*ast.List)- if !ok || len(funcList.Items) < 1 {- continue- }- fc, ok := funcList.Items[0].(*ast.FuncCall)- if !ok || fc.Funcname == nil {- continue- }- // Use the last name part — for "schema.func", return "func".- name := ""- for _, nameItem := range fc.Funcname.Items {- if s, ok := nameItem.(*ast.String); ok {- name = s.Str- }- }- return name- }- return ""-}--// lookupUserProcByName finds a user-defined function by name in the catalog,-// searching through schemas in the search path.-func (e *omniQuerySpanExtractor) lookupUserProcByName(name string) *catalog.UserProc {- lowerName := strings.ToLower(name)- for _, schemaName := range e.searchPath {- for _, row := range e.cat.QueryPgProc(schemaName) {- if strings.ToLower(row.ProName) == lowerName {- return e.cat.GetUserProcByOID(row.OID)- }- }- }- return nil-}--// getOutputParamNames returns the names of output parameters (TABLE, OUT, or INOUT mode)-// for a user-defined function. Returns nil if the function has no output params.-func getOutputParamNames(proc *catalog.UserProc) []string {- var names []string- for i, mode := range proc.ArgModes {- if mode == 't' || mode == 'o' || mode == 'b' {- if i < len(proc.ArgNames) {- names = append(names, proc.ArgNames[i])- }- }- }- return names-}--// buildFuncResults constructs QuerySpanResults from output parameter names and-// function body lineage analysis, and populates table-level access in accessesMap.-func (*omniQuerySpanExtractor) buildFuncResults(outNames []string, bodySets []base.SourceColumnSet, accessesMap base.SourceColumnSet) []base.QuerySpanResult {- for _, colSet := range bodySets {- for k, v := range colSet {- accessesMap[base.ColumnResource{- Database: k.Database,- Schema: k.Schema,- Table: k.Table,- }] = v- }- }-- var results []base.QuerySpanResult- for i, name := range outNames {- sourceColumns := make(base.SourceColumnSet)- if i < len(bodySets) {- for k, v := range bodySets[i] {- sourceColumns[k] = v- }- }- results = append(results, base.QuerySpanResult{- Name: name,- SourceColumns: sourceColumns,- })- }- return results-}--// tryMetadataFuncLookup searches for a function by name in the database metadata-// (not the catalog). This handles cases where the catalog can't resolve the-// function — either because the metadata function name differs from the DDL name,-// or because RETURNS TABLE functions can't be loaded into the catalog.-func (e *omniQuerySpanExtractor) tryMetadataFuncLookup(funcName string, accessesMap base.SourceColumnSet) []base.QuerySpanResult {- meta, err := e.getDatabaseMetadata(e.defaultDatabase)- if err != nil || meta == nil {- return nil- }-- _, funcs := meta.SearchFunctions(e.searchPath, funcName)- if len(funcs) == 0 {- return nil- }-- // Use the first matching function's definition.- funcDef := funcs[0].Definition- if funcDef == "" {- return nil- }-- // Parse the function definition to extract output param names and body.- // We can't rely on the catalog for RETURNS TABLE functions because the- // catalog may reject them due to type validation.- outNames, body, lang := parseFuncDefForLineage(funcDef)- if len(outNames) == 0 || body == "" {- return nil- }-- // Construct a synthetic UserProc for body analysis.- syntheticProc := &catalog.UserProc{- Name: funcName,- Language: lang,- Body: body,- }- // Set ArgModes and ArgNames for output params.- for _, name := range outNames {- syntheticProc.ArgModes = append(syntheticProc.ArgModes, 't')- syntheticProc.ArgNames = append(syntheticProc.ArgNames, name)- }- // Also extract input params for variable substitution.- inputNames := parseInputParamNames(funcDef)- for _, name := range inputNames {- syntheticProc.ArgModes = append([]byte{'i'}, syntheticProc.ArgModes...)- syntheticProc.ArgNames = append([]string{name}, syntheticProc.ArgNames...)- }-- // Use a temporary OID for caching.- syntheticProc.OID = uint32(0xFFFF0000 + len(e.funcBodyCache))-- bodySets := e.analyzeTableFunctionBody(syntheticProc)- return e.buildFuncResults(outNames, bodySets, accessesMap)-}--// parseFuncDefForLineage extracts output parameter names, function body, and-// language from a CREATE FUNCTION definition string.-func parseFuncDefForLineage(definition string) (outNames []string, body string, lang string) {- upper := strings.ToUpper(definition)-- // Extract language.- if langIdx := strings.Index(upper, "LANGUAGE"); langIdx >= 0 {- rest := strings.TrimSpace(definition[langIdx+8:])- parts := strings.Fields(rest)- if len(parts) > 0 {- lang = strings.ToLower(strings.TrimRight(parts[0], ";"))- }- }-- // Extract body.- body = extractFuncBodyFromDef(definition)-- // Extract output param names from RETURNS TABLE(name type, ...).- tableIdx := strings.Index(upper, "RETURNS TABLE")- if tableIdx < 0 {- tableIdx = strings.Index(upper, "RETURNS\n TABLE")- }- if tableIdx >= 0 {- rest := definition[tableIdx:]- parenStart := strings.Index(rest, "(")- if parenStart >= 0 {- depth := 0- parenEnd := -1- for i := parenStart; i < len(rest); i++ {- switch rest[i] {- case '(':- depth++- case ')':- depth--- if depth == 0 {- parenEnd = i- }- default:- }- if parenEnd >= 0 {- break- }- }- if parenEnd > parenStart {- paramList := rest[parenStart+1 : parenEnd]- for _, param := range strings.Split(paramList, ",") {- parts := strings.Fields(strings.TrimSpace(param))- if len(parts) >= 2 {- outNames = append(outNames, parts[0])- }- }- }- }- }-- return outNames, body, lang-}--// parseInputParamNames extracts input parameter names from a CREATE FUNCTION-// definition. It parses the parameter list before RETURNS.-func parseInputParamNames(definition string) []string {- upper := strings.ToUpper(definition)-- // Find the parameter list: between FUNCTION name( and ) RETURNS.- funcIdx := strings.Index(upper, "FUNCTION")- if funcIdx < 0 {- return nil- }-- rest := definition[funcIdx:]- parenStart := strings.Index(rest, "(")- if parenStart < 0 {- return nil- }-- // Find the closing paren that ends the input params.- returnsIdx := strings.Index(upper[funcIdx+parenStart:], "RETURNS")- if returnsIdx < 0 {- return nil- }-- paramSection := rest[parenStart+1 : parenStart+returnsIdx]- // Find the last ) before RETURNS.- lastParen := strings.LastIndex(paramSection, ")")- if lastParen >= 0 {- paramSection = paramSection[:lastParen]- }-- modeKeywords := map[string]bool{- "IN": true, "OUT": true, "INOUT": true, "VARIADIC": true,- }- var names []string- for _, param := range strings.Split(paramSection, ",") {- parts := strings.Fields(strings.TrimSpace(param))- if len(parts) < 2 {- continue- }- // If the first word is a mode keyword (IN, OUT, INOUT, VARIADIC),- // the parameter name is the second word. Otherwise the first word is the name.- nameIdx := 0- if modeKeywords[strings.ToUpper(parts[0])] {- nameIdx = 1- }- if nameIdx < len(parts) {- // Skip OUT/INOUT params — we only want input params for variable scope.- upperFirst := strings.ToUpper(parts[0])- if upperFirst == "OUT" {- continue- }- names = append(names, parts[nameIdx])- }- }- return names-}diff --git a/backend/plugin/parser/pg/query_span_omni_plpgsql.go b/backend/plugin/parser/pg/query_span_plpgsql.gosimilarity index 100%rename from backend/plugin/parser/pg/query_span_omni_plpgsql.gorename to backend/plugin/parser/pg/query_span_plpgsql.godiff --git a/backend/plugin/parser/plsql/backup.go b/backend/plugin/parser/plsql/backup.goindex ccd873323e..a8a0e70b01 100644--- a/backend/plugin/parser/plsql/backup.go+++ b/backend/plugin/parser/plsql/backup.go@@ -210,7 +210,7 @@ func prepareTransformation(databaseName, statement string) ([]statementInfo, errif stmt.Empty {continue}- list, err := ParsePLSQLOmni(stmt.Text)+ list, err := ParsePLSQL(stmt.Text)if err != nil {return nil, errors.Wrap(err, "failed to parse PLSQL")}diff --git a/backend/plugin/parser/plsql/diagnose.go b/backend/plugin/parser/plsql/diagnose.goindex 8e06f0e20d..527b3b9d71 100644--- a/backend/plugin/parser/plsql/diagnose.go+++ b/backend/plugin/parser/plsql/diagnose.go@@ -32,7 +32,7 @@ func parsePLSQLStatement(statement string) *base.SyntaxError {statement += ";"}- if _, err := ParsePLSQLOmni(statement); err != nil {+ if _, err := ParsePLSQL(statement); err != nil {var syntaxErr *base.SyntaxErrorif errors.As(convertOmniError(err, base.Statement{Text: statement}), &syntaxErr) {return syntaxErrdiff --git a/backend/plugin/parser/plsql/omni.go b/backend/plugin/parser/plsql/omni.goindex 927c9cd0aa..b0af3453ce 100644--- a/backend/plugin/parser/plsql/omni.go+++ b/backend/plugin/parser/plsql/omni.go@@ -28,9 +28,9 @@ func (a *OmniAST) ASTStartPosition() *storepb.Position {return a.StartPosition}-// ParsePLSQLOmni parses SQL using omni's parser and returns an ast.List.+// ParsePLSQL 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) {+func ParsePLSQL(sql string) (*ast.List, error) {statements, err := SplitSQL(sql)if err != nil {return nil, errdiff --git a/backend/plugin/parser/plsql/omni_test.go b/backend/plugin/parser/plsql/omni_test.goindex 3e733e6044..60cc917095 100644--- a/backend/plugin/parser/plsql/omni_test.go+++ b/backend/plugin/parser/plsql/omni_test.go@@ -12,8 +12,8 @@ import ("github.com/bytebase/bytebase/backend/plugin/parser/base")-func TestParsePLSQLOmni(t *testing.T) {- list, err := ParsePLSQLOmni("SELECT * FROM T; INSERT INTO T VALUES (1);")+func TestParsePLSQL(t *testing.T) {+ list, err := ParsePLSQL("SELECT * FROM T; INSERT INTO T VALUES (1);")require.NoError(t, err)require.NotNil(t, list)require.Len(t, list.Items, 2)@@ -27,8 +27,8 @@ func TestParsePLSQLOmni(t *testing.T) {require.IsType(t, &ast.InsertStmt{}, second.Stmt)}-func TestParsePLSQLOmniSplitsSlashTerminatedPLSQLScript(t *testing.T) {- list, err := ParsePLSQLOmni(`+func TestParsePLSQLSplitsSlashTerminatedPLSQLScript(t *testing.T) {+ list, err := ParsePLSQL(`CREATE TABLE AUDIT_LOG (LOG_ID NUMBER PRIMARY KEY);@@ -54,8 +54,8 @@ END;require.IsType(t, &ast.CreateTriggerStmt{}, second.Stmt)}-func TestParsePLSQLOmniSkipsSQLPlusCommands(t *testing.T) {- list, err := ParsePLSQLOmni(`+func TestParsePLSQLSkipsSQLPlusCommands(t *testing.T) {+ list, err := ParsePLSQL(`SET DEFINE OFFPROMPT setup@@ -86,8 +86,8 @@ SPOOL OFFrequire.IsType(t, &ast.CreateTriggerStmt{}, second.Stmt)}-func TestParsePLSQLOmniKeepsRemarkColumnInCreateTable(t *testing.T) {- list, err := ParsePLSQLOmni(`+func TestParsePLSQLKeepsRemarkColumnInCreateTable(t *testing.T) {+ list, err := ParsePLSQL(`CREATE TABLE parser_regression_remark_column (id NUMBER NOT NULLCONSTRAINT parser_regression_remark_column_pk@@ -105,7 +105,7 @@ CREATE TABLE parser_regression_remark_column (require.IsType(t, &ast.CreateTableStmt{}, raw.Stmt)}-func TestParsePLSQLOmniMatchRecognize(t *testing.T) {+func TestParsePLSQLMatchRecognize(t *testing.T) {statement := `SELECT * FROM TRADES MATCH_RECOGNIZE (PARTITION BY ACCOUNT_IDORDER BY TRADE_TIME@@ -119,7 +119,7 @@ func TestParsePLSQLOmniMatchRecognize(t *testing.T) {require.Len(t, stmts, 1)require.Equal(t, statement, stmts[0].Text)- list, err := ParsePLSQLOmni(statement)+ list, err := ParsePLSQL(statement)require.NoError(t, err)require.Len(t, list.Items, 1)raw, ok := list.Items[0].(*ast.RawStmt)@@ -127,13 +127,13 @@ func TestParsePLSQLOmniMatchRecognize(t *testing.T) {require.IsType(t, &ast.SelectStmt{}, raw.Stmt)}-func TestParsePLSQLOmniPreservesScriptOffsets(t *testing.T) {+func TestParsePLSQLPreservesScriptOffsets(t *testing.T) {sql := `PROMPT setupSELECT 1 FROM DUAL;SELECT name FROM users;`- list, err := ParsePLSQLOmni(sql)+ list, err := ParsePLSQL(sql)require.NoError(t, err)require.NotNil(t, list)require.Len(t, list.Items, 2)@@ -149,8 +149,8 @@ SELECT name FROM users;require.Equal(t, strings.LastIndex(sql, ";"), second.Loc.End)}-func TestParsePLSQLOmniReturnsParseError(t *testing.T) {- _, err := ParsePLSQLOmni("SELECT * FROM")+func TestParsePLSQLReturnsParseError(t *testing.T) {+ _, err := ParsePLSQL("SELECT * FROM")require.Error(t, err)}diff --git a/backend/plugin/parser/plsql/plsql.go b/backend/plugin/parser/plsql/plsql.goindex 1b678dd943..d760add6dc 100644--- a/backend/plugin/parser/plsql/plsql.go+++ b/backend/plugin/parser/plsql/plsql.go@@ -32,7 +32,7 @@ func parsePLSQLStatements(statement string) ([]base.ParsedStatement, error) {continue}- list, err := ParsePLSQLOmni(stmt.Text)+ list, err := ParsePLSQL(stmt.Text)if err != nil {return nil, convertOmniError(err, stmt)}diff --git a/backend/plugin/parser/plsql/plsql_test.go b/backend/plugin/parser/plsql/plsql_test.goindex 830b165433..9f6e2e23a0 100644--- a/backend/plugin/parser/plsql/plsql_test.go+++ b/backend/plugin/parser/plsql/plsql_test.go@@ -64,7 +64,7 @@ INTERVAL (NUMTODSINTERVAL(1,'DAY'))}for _, test := range tests {- list, err := ParsePLSQLOmni(test.statement)+ list, err := ParsePLSQL(test.statement)if test.errorMessage == "" {require.NoError(t, err)require.NotEmpty(t, list.Items)diff --git a/backend/plugin/parser/plsql/query.go b/backend/plugin/parser/plsql/query.goindex 56cdf8eb23..a8cdd35883 100644--- a/backend/plugin/parser/plsql/query.go+++ b/backend/plugin/parser/plsql/query.go@@ -20,7 +20,7 @@ func validateQuery(statement string) (bool, bool, error) {}}- list, err := ParsePLSQLOmni(statement)+ list, err := ParsePLSQL(statement)if err != nil {return false, false, convertOmniError(err, base.Statement{Text: statement})}diff --git a/backend/plugin/parser/plsql/query_span_extractor.go b/backend/plugin/parser/plsql/query_span_extractor.goindex 765798be65..4e538a1941 100644--- a/backend/plugin/parser/plsql/query_span_extractor.go+++ b/backend/plugin/parser/plsql/query_span_extractor.go@@ -2,8 +2,11 @@ package plsqlimport ("context"+ "reflect""strings"+ "unicode"+ oracleast "github.com/bytebase/omni/oracle/ast""github.com/pkg/errors""github.com/bytebase/bytebase/backend/plugin/parser/base"@@ -282,3 +285,1532 @@ func (q *querySpanExtractor) getColumnsForMaterializedView(instanceID, defaultDa}return span.Results, nil}++type omniQuerySpanExtractor struct {+ *querySpanExtractor++ source string+ topLevelTableSourcesFrom []base.TableSource+}++func newOmniQuerySpanExtractor(connectionDatabase string, gCtx base.GetQuerySpanContext) *omniQuerySpanExtractor {+ return &omniQuerySpanExtractor{+ querySpanExtractor: newQuerySpanExtractor(connectionDatabase, gCtx),+ }+}++func (q *omniQuerySpanExtractor) getOmniQuerySpan(ctx context.Context, statement string) (*base.QuerySpan, error) {+ q.ctx = ctx+ q.source = statement++ list, err := ParsePLSQL(statement)+ if err != nil {+ return nil, errors.Wrapf(err, "failed to parse statement: %s", statement)+ }+ if list == nil || len(list.Items) == 0 {+ return nil, nil+ }+ if len(list.Items) > 1 {+ return nil, errors.Errorf("query span extraction only supports single statement, got %d statements", len(list.Items))+ }+ raw, ok := list.Items[0].(*oracleast.RawStmt)+ if !ok || raw.Stmt == nil {+ return nil, nil+ }++ accessTables := collectOmniAccessTables(q.defaultDatabase, raw.Stmt)+ allSystem, mixed := isMixedQuery(accessTables)+ if mixed {+ return nil, base.MixUserSystemTablesError+ }++ queryType := omniQueryType(raw.Stmt, allSystem)+ if queryType != base.Select {+ return &base.QuerySpan{+ Type: queryType,+ 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+ }++ selectStmt, ok := raw.Stmt.(*oracleast.SelectStmt)+ if !ok {+ return nil, errors.Errorf("expected SELECT statement, got %T", raw.Stmt)+ }+ tableSource, err := q.extractOmniSelect(selectStmt)+ 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 tableSource != nil {+ results = tableSource.GetQuerySpanResult()+ }+ if resourceNotFound := q.findMissingOmniAccessTable(raw.Stmt, accessTables); resourceNotFound != nil {+ 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 &base.QuerySpan{+ Type: base.Select,+ SourceColumns: columnSet,+ Results: results,+ }, nil+}++func omniQueryType(stmt oracleast.StmtNode, allSystem bool) base.QueryType {+ if stmt == nil {+ return base.QueryTypeUnknown+ }+ switch stmt.(type) {+ case *oracleast.ExplainPlanStmt:+ return base.Explain+ case *oracleast.SelectStmt:+ if allSystem {+ return base.SelectInfoSchema+ }+ return base.Select+ case *oracleast.InsertStmt, *oracleast.UpdateStmt, *oracleast.DeleteStmt, *oracleast.MergeStmt,+ *oracleast.CallStmt, *oracleast.LockTableStmt:+ return base.DML+ case *oracleast.CreateTableStmt, *oracleast.AlterTableStmt, *oracleast.DropStmt,+ *oracleast.CreateIndexStmt, *oracleast.CreateViewStmt,+ *oracleast.CreateSequenceStmt, *oracleast.CreateSynonymStmt,+ *oracleast.CreateDatabaseLinkStmt, *oracleast.CreateTypeStmt,+ *oracleast.CreatePackageStmt, *oracleast.CreateProcedureStmt,+ *oracleast.CreateFunctionStmt, *oracleast.CreateTriggerStmt,+ *oracleast.TruncateStmt, *oracleast.AlterSessionStmt,+ *oracleast.AlterSystemStmt, *oracleast.CreateUserStmt,+ *oracleast.AlterUserStmt, *oracleast.CreateRoleStmt,+ *oracleast.AlterRoleStmt, *oracleast.CreateProfileStmt,+ *oracleast.AlterProfileStmt, *oracleast.AlterResourceCostStmt,+ *oracleast.AdminDDLStmt, *oracleast.CreateSchemaStmt,+ *oracleast.AlterDatabaseLinkStmt, *oracleast.AlterSynonymStmt,+ *oracleast.AlterMaterializedViewStmt,+ *oracleast.CreateAuditPolicyStmt, *oracleast.AlterAuditPolicyStmt,+ *oracleast.DropAuditPolicyStmt, *oracleast.CreateTablespaceStmt,+ *oracleast.AlterTablespaceStmt, *oracleast.CreateTablespaceSetStmt,+ *oracleast.DropTablespaceStmt, *oracleast.CreateClusterStmt,+ *oracleast.CreateDimensionStmt, *oracleast.AlterClusterStmt,+ *oracleast.AlterDimensionStmt, *oracleast.CreateMaterializedZonemapStmt,+ *oracleast.AlterMaterializedZonemapStmt, *oracleast.CreateInmemoryJoinGroupStmt,+ *oracleast.AlterInmemoryJoinGroupStmt, *oracleast.AlterIndexStmt,+ *oracleast.AlterViewStmt, *oracleast.AlterSequenceStmt,+ *oracleast.AlterProcedureStmt, *oracleast.AlterFunctionStmt,+ *oracleast.AlterPackageStmt, *oracleast.AlterTriggerStmt,+ *oracleast.AlterTypeStmt, *oracleast.CreateIndextypeStmt,+ *oracleast.AlterIndextypeStmt, *oracleast.CreateOperatorStmt,+ *oracleast.AlterOperatorStmt, *oracleast.CreateMviewLogStmt,+ *oracleast.AlterMviewLogStmt, *oracleast.CreateAnalyticViewStmt,+ *oracleast.AlterAnalyticViewStmt, *oracleast.CreateJsonDualityViewStmt,+ *oracleast.AlterJsonDualityViewStmt, *oracleast.CreateAttributeDimensionStmt,+ *oracleast.AlterAttributeDimensionStmt, *oracleast.CreateHierarchyStmt,+ *oracleast.AlterHierarchyStmt, *oracleast.CreateDomainStmt,+ *oracleast.AlterDomainStmt, *oracleast.CreatePropertyGraphStmt,+ *oracleast.CreateVectorIndexStmt, *oracleast.CreateLockdownProfileStmt,+ *oracleast.AlterLockdownProfileStmt, *oracleast.CreateOutlineStmt,+ *oracleast.AlterOutlineStmt:+ return base.DDL+ }+ return base.QueryTypeUnknown+}++func (q *omniQuerySpanExtractor) findMissingOmniAccessTable(stmt oracleast.StmtNode, accessTables []base.SchemaResource) *base.ResourceNotFoundError {+ cteNames := collectOmniCTENames(stmt)+ for _, resource := range accessTables {+ if cteNames[resource.Table] || q.existsTableMetadata(resource) {+ continue+ }+ database := resource.Database+ if database == "" {+ database = q.defaultDatabase+ }+ table := resource.Table+ return &base.ResourceNotFoundError{+ Database: &database,+ Table: &table,+ }+ }+ return nil+}++func collectOmniCTENames(stmt oracleast.StmtNode) map[string]bool {+ result := make(map[string]bool)+ oracleast.Inspect(stmt, func(node oracleast.Node) bool {+ cte, ok := node.(*oracleast.CTE)+ if ok {+ result[cte.Name] = true+ }+ return true+ })+ return result+}++func collectOmniAccessTables(defaultDatabase string, stmt oracleast.StmtNode) []base.SchemaResource {+ seen := make(map[base.SchemaResource]bool)+ var result []base.SchemaResource+ addResource := func(name *oracleast.ObjectName) {+ if name == nil || name.Name == "DUAL" || name.DBLink != "" {+ return+ }+ database := name.Schema+ if database == "" {+ database = defaultDatabase+ }+ resource := base.SchemaResource{+ Database: database,+ Table: name.Name,+ }+ if !seen[resource] {+ seen[resource] = true+ result = append(result, resource)+ }+ }+ oracleast.Inspect(stmt, func(node oracleast.Node) bool {+ switch node := node.(type) {+ case *oracleast.TableRef:+ if node.Dblink == "" {+ addResource(node.Name)+ }+ case *oracleast.ContainersExpr:+ addResource(node.Name)+ default:+ }+ return true+ })+ return result+}++func (q *omniQuerySpanExtractor) clone() *omniQuerySpanExtractor {+ copyExtractor := *q.querySpanExtractor+ return &omniQuerySpanExtractor{+ querySpanExtractor: ©Extractor,+ source: q.source,+ topLevelTableSourcesFrom: cloneTableSourceSlice(q.topLevelTableSourcesFrom),+ }+}++func (q *omniQuerySpanExtractor) extractOmniSelect(stmt *oracleast.SelectStmt) (base.TableSource, error) {+ if stmt == nil {+ return nil, nil+ }++ oldCTEs := q.ctes+ if stmt.WithClause != nil {+ for _, node := range listItems(stmt.WithClause.CTEs) {+ cte, ok := node.(*oracleast.CTE)+ if !ok {+ continue+ }+ table, err := q.extractOmniCTE(cte)+ if err != nil {+ q.ctes = oldCTEs+ return nil, err+ }+ q.ctes = append(q.ctes, table)+ }+ }+ defer func() {+ q.ctes = oldCTEs+ }()++ if stmt.Op != 0 {+ return q.extractOmniSetSelect(stmt)+ }+ if stmt.ModelClause != nil {+ source, err := q.extractOmniModelSelect(stmt)+ if err != nil {+ return nil, err+ }+ return q.projectOmniTransformedSelect(stmt, source)+ }++ oldFrom := q.tableSourcesFrom+ oldTopLevelFrom := q.topLevelTableSourcesFrom+ q.tableSourcesFrom = nil+ q.topLevelTableSourcesFrom = nil+ defer func() {+ q.tableSourcesFrom = oldFrom+ q.topLevelTableSourcesFrom = oldTopLevelFrom+ }()++ for _, node := range listItems(stmt.FromClause) {+ tableExpr, ok := node.(oracleast.TableExpr)+ if !ok {+ continue+ }+ tableSource, err := q.extractOmniTableExpr(tableExpr)+ if err != nil {+ return nil, err+ }+ if tableSource != nil {+ q.tableSourcesFrom = append(q.tableSourcesFrom, tableSource)+ q.topLevelTableSourcesFrom = append(q.topLevelTableSourcesFrom, tableSource)+ }+ }++ results, err := q.extractOmniTargetList(stmt.TargetList)+ if err != nil {+ return nil, err+ }+ return &base.PseudoTable{+ Columns: results,+ }, nil+}++func (q *omniQuerySpanExtractor) projectOmniTransformedSelect(stmt *oracleast.SelectStmt, source base.TableSource) (base.TableSource, error) {+ oldFrom := q.tableSourcesFrom+ oldTopLevelFrom := q.topLevelTableSourcesFrom+ q.tableSourcesFrom = nil+ q.topLevelTableSourcesFrom = nil+ if source != nil {+ q.tableSourcesFrom = append(q.tableSourcesFrom, source)+ q.topLevelTableSourcesFrom = append(q.topLevelTableSourcesFrom, source)+ }+ defer func() {+ q.tableSourcesFrom = oldFrom+ q.topLevelTableSourcesFrom = oldTopLevelFrom+ }()++ results, err := q.extractOmniTargetList(stmt.TargetList)+ if err != nil {+ return nil, err+ }+ return &base.PseudoTable{Columns: results}, nil+}++func (q *omniQuerySpanExtractor) extractOmniSetSelect(stmt *oracleast.SelectStmt) (base.TableSource, error) {+ left, err := q.extractOmniSelect(omniSetLeftSelect(stmt))+ if err != nil {+ return nil, err+ }+ right, err := q.extractOmniSelect(stmt.Rarg)+ if err != nil {+ return nil, err+ }+ return mergeOmniSetTableSources(left, right)+}++func mergeOmniSetTableSources(left, right base.TableSource) (base.TableSource, error) {+ if left == nil {+ return right, nil+ }+ if right == nil {+ return left, nil+ }+ leftResults := left.GetQuerySpanResult()+ rightResults := right.GetQuerySpanResult()+ if len(leftResults) != len(rightResults) {+ return nil, errors.Errorf("left and right query span result length mismatch: %d != %d", len(leftResults), len(rightResults))+ }+ result := make([]base.QuerySpanResult, 0, len(leftResults))+ for i, leftResult := range leftResults {+ sourceColumns, _ := base.MergeSourceColumnSet(leftResult.SourceColumns, rightResults[i].SourceColumns)+ result = append(result, base.QuerySpanResult{+ Name: leftResult.Name,+ SourceColumns: sourceColumns,+ IsPlainField: false,+ })+ }+ return &base.PseudoTable{Columns: result}, nil+}++func (q *omniQuerySpanExtractor) extractOmniCTE(cte *oracleast.CTE) (*base.PseudoTable, error) {+ if cte == nil {+ return nil, nil+ }+ name := cte.Name+ columnNames := omniStringList(cte.Columns)++ selectStmt, ok := cte.Query.(*oracleast.SelectStmt)+ if ok && selectStmt.Op != 0 && len(columnNames) > 0 {+ initialSource, err := q.extractOmniSelect(omniSetLeftSelect(selectStmt))+ if err != nil {+ return nil, err+ }+ initial := cloneQuerySpanResults(initialSource.GetQuerySpanResult())+ applyOmniColumnAliases(initial, columnNames)++ placeholder := &base.PseudoTable{Name: name, Columns: initial}+ q.ctes = append(q.ctes, placeholder)+ defer func() {+ q.ctes = q.ctes[:len(q.ctes)-1]+ }()++ columns := initial+ for range 16 {+ placeholder.Columns = columns+ rightSource, err := q.extractOmniSelect(selectStmt.Rarg)+ if err != nil {+ return nil, err+ }+ mergedSource, err := mergeOmniSetTableSources(&base.PseudoTable{Columns: initial}, rightSource)+ if err != nil {+ return nil, err+ }+ next := cloneQuerySpanResults(mergedSource.GetQuerySpanResult())+ applyOmniColumnAliases(next, columnNames)+ if querySpanResultsEqual(columns, next) {+ return &base.PseudoTable{Name: name, Columns: next}, nil+ }+ columns = next+ }+ return &base.PseudoTable{Name: name, Columns: columns}, nil+ }++ child := q.clone()+ tableSource, err := child.extractOmniStmt(cte.Query)+ if err != nil {+ return nil, err+ }+ columns := cloneQuerySpanResults(tableSource.GetQuerySpanResult())+ applyOmniColumnAliases(columns, columnNames)+ return &base.PseudoTable{Name: name, Columns: columns}, nil+}++func (q *omniQuerySpanExtractor) extractOmniStmt(stmt oracleast.StmtNode) (base.TableSource, error) {+ selectStmt, ok := stmt.(*oracleast.SelectStmt)+ if !ok {+ return nil, errors.Errorf("unsupported statement in query span extractor: %T", stmt)+ }+ return q.extractOmniSelect(selectStmt)+}++func (q *omniQuerySpanExtractor) extractOmniTargetList(list *oracleast.List) ([]base.QuerySpanResult, error) {+ if list == nil || list.Len() == 0 {+ return q.expandOmniAsterisk("", "")+ }++ var results []base.QuerySpanResult+ for _, node := range listItems(list) {+ target, ok := node.(*oracleast.ResTarget)+ if !ok || target.Expr == nil {+ continue+ }+ if isOmniStar(target.Expr) {+ expanded, err := q.expandOmniAsterisk("", "")+ if err != nil {+ return nil, err+ }+ results = append(results, expanded...)+ continue+ }+ if ref, ok := target.Expr.(*oracleast.ColumnRef); ok && ref.Column == "*" {+ expanded, err := q.expandOmniAsterisk(ref.Schema, ref.Table)+ if err != nil {+ return nil, err+ }+ results = append(results, expanded...)+ continue+ }++ name, sourceColumns, err := q.extractOmniExpr(target.Expr)+ if err != nil {+ return nil, err+ }+ if target.Name != "" {+ name = target.Name+ }+ results = append(results, base.QuerySpanResult{+ Name: name,+ SourceColumns: sourceColumns,+ IsPlainField: false,+ })+ }+ return results, nil+}++func (q *omniQuerySpanExtractor) extractOmniTableExpr(expr oracleast.TableExpr) (base.TableSource, error) {+ switch expr := expr.(type) {+ case *oracleast.TableRef:+ if expr.Name == nil {+ return nil, nil+ }+ dbLink := expr.Name.DBLink+ if dbLink == "" {+ dbLink = expr.Dblink+ }+ database := expr.Name.Schema+ if database == "" && dbLink == "" {+ database = q.defaultDatabase+ }+ tableSource, err := q.plsqlFindTableSchema(splitOmniDBLink(dbLink), database, expr.Name.Name)+ if err != nil {+ return nil, err+ }+ return aliasOmniTableSource(tableSource, expr.Alias), nil+ case *oracleast.SubqueryRef:+ child := q.clone()+ tableSource, err := child.extractOmniStmt(expr.Subquery)+ if err != nil {+ return nil, err+ }+ return aliasOmniTableSource(tableSource, expr.Alias), nil+ case *oracleast.SubqueryExpr:+ child := q.clone()+ tableSource, err := child.extractOmniStmt(expr.Subquery)+ if err != nil {+ return nil, err+ }+ return tableSource, nil+ case *oracleast.LateralRef:+ child := q.clone()+ child.outerTableSources = append(cloneTableSourceSlice(child.outerTableSources), q.tableSourcesFrom...)+ tableSource, err := child.extractOmniStmt(expr.Subquery)+ if err != nil {+ return nil, err+ }+ return aliasOmniTableSource(tableSource, expr.Alias), nil+ case *oracleast.JoinClause:+ left, err := q.extractOmniTableExpr(expr.Left)+ if err != nil {+ return nil, err+ }+ if left != nil {+ q.tableSourcesFrom = append(q.tableSourcesFrom, left)+ }+ right, err := q.extractOmniTableExpr(expr.Right)+ if err != nil {+ return nil, err+ }+ if right != nil {+ q.tableSourcesFrom = append(q.tableSourcesFrom, right)+ }+ return mergeOmniJoinTableSource(expr, left, right)+ case *oracleast.XmlTableRef:+ return q.extractOmniXMLTable(expr)+ case *oracleast.JsonTableRef:+ return q.extractOmniJSONTable(expr)+ case *oracleast.ContainersExpr:+ if expr.Name == nil {+ return nil, nil+ }+ database := expr.Name.Schema+ if database == "" {+ database = q.defaultDatabase+ }+ tableSource, err := q.plsqlFindTableSchema(nil, database, expr.Name.Name)+ if err != nil {+ return nil, err+ }+ return aliasOmniTableSource(tableSource, expr.Alias), nil+ case *oracleast.InlineExternalTable:+ return extractOmniInlineExternalTable(expr), nil+ case *oracleast.TableCollectionExpr:+ return q.extractOmniTableCollection(expr)+ case *oracleast.PivotClause:+ return q.extractOmniPivot(expr)+ case *oracleast.UnpivotClause:+ return q.extractOmniUnpivot(expr)+ case *oracleast.MatchRecognizeClause:+ return q.extractOmniMatchRecognize(expr)+ default:+ return nil, errors.Errorf("unsupported oracle table source: %T", expr)+ }+}++func (q *omniQuerySpanExtractor) extractOmniPivot(pivot *oracleast.PivotClause) (base.TableSource, error) {+ if pivot == nil {+ return nil, nil+ }+ // Capture the FROM scope before extracting the source: a join source+ // appends its operands to tableSourcesFrom, and they must not leak past+ // this transform — the clause replaces them with its own output.+ oldFrom := q.tableSourcesFrom+ defer func() {+ q.tableSourcesFrom = oldFrom+ }()+ source, err := q.extractOmniTableExpr(pivot.Source)+ if err != nil {+ return nil, err+ }+ // While deriving the transform's output, the scope is exactly the+ // extracted source: the clause's inputs resolve against it alone, never+ // against enclosing join operands or the source's own leaked operands+ // (a USING-merged column must attribute to both sides, not to the first+ // operand in the slice).+ q.tableSourcesFrom = nil+ if source != nil {+ q.tableSourcesFrom = []base.TableSource{source}+ }++ excluded := make(map[string]bool)+ pivotSources := make(base.SourceColumnSet)+ for _, expr := range omniExprList(pivot.ForColumns) {+ name, sourceColumns, err := q.extractOmniExpr(expr)+ if err != nil {+ return nil, err+ }+ excluded[name] = true+ pivotSources, _ = base.MergeSourceColumnSet(pivotSources, sourceColumns)+ }++ var aggregates []*oracleast.PivotAggregate+ for _, item := range listItems(pivot.Aggregates) {+ aggregate, ok := item.(*oracleast.PivotAggregate)+ if ok {+ aggregates = append(aggregates, aggregate)+ }+ }+ var inItems []*oracleast.PivotInItem+ for _, item := range listItems(pivot.InItems) {+ inItem, ok := item.(*oracleast.PivotInItem)+ if ok {+ inItems = append(inItems, inItem)+ }+ }++ aggregateSources := make([]base.SourceColumnSet, len(aggregates))+ for i, aggregate := range aggregates {+ _, sourceColumns, err := q.extractOmniExpr(aggregate.Expr)+ if err != nil {+ return nil, err+ }+ aggregateSources[i] = sourceColumns+ excludeOmniColumnRefNames(excluded, aggregate.Expr)+ excludeSourceColumnNames(excluded, sourceColumns)+ }++ var results []base.QuerySpanResult+ if source != nil {+ for _, result := range source.GetQuerySpanResult() {+ if !excluded[result.Name] {+ results = append(results, cloneQuerySpanResult(result))+ }+ }+ }+ for _, inItem := range inItems {+ inName := pivotInItemName(q, inItem)+ for i, aggregate := range aggregates {+ sourceColumns, _ := base.MergeSourceColumnSet(pivotSources, aggregateSources[i])+ results = append(results, base.QuerySpanResult{+ Name: pivotColumnName(inName, aggregate.Alias, len(aggregates)),+ SourceColumns: sourceColumns,+ IsPlainField: false,+ })+ }+ }+ return aliasOmniTableSource(&base.PseudoTable{Columns: results}, pivot.Alias), nil+}++func (q *omniQuerySpanExtractor) extractOmniUnpivot(unpivot *oracleast.UnpivotClause) (base.TableSource, error) {+ if unpivot == nil {+ return nil, nil+ }+ // Capture the FROM scope before extracting the source: a join source+ // appends its operands to tableSourcesFrom, and they must not leak past+ // this transform — the clause replaces them with its own output.+ oldFrom := q.tableSourcesFrom+ defer func() {+ q.tableSourcesFrom = oldFrom+ }()+ source, err := q.extractOmniTableExpr(unpivot.Source)+ if err != nil {+ return nil, err+ }+ // While deriving the transform's output, the scope is exactly the+ // extracted source: the clause's inputs resolve against it alone, never+ // against enclosing join operands or the source's own leaked operands+ // (a USING-merged column must attribute to both sides, not to the first+ // operand in the slice).+ q.tableSourcesFrom = nil+ if source != nil {+ q.tableSourcesFrom = []base.TableSource{source}+ }++ valueColumns := omniExprList(unpivot.ValueColumns)+ inputSources := make([]base.SourceColumnSet, len(valueColumns))+ excluded := make(map[string]bool)+ for _, item := range listItems(unpivot.InputMappings) {+ mapping, ok := item.(*oracleast.UnpivotInItem)+ if !ok {+ continue+ }+ for i, input := range omniExprList(mapping.InputColumns) {+ name, sourceColumns, err := q.extractOmniExpr(input)+ if err != nil {+ return nil, err+ }+ excluded[name] = true+ if i < len(inputSources) {+ inputSources[i], _ = base.MergeSourceColumnSet(inputSources[i], sourceColumns)+ }+ }+ }++ var results []base.QuerySpanResult+ if source != nil {+ for _, result := range source.GetQuerySpanResult() {+ if !excluded[result.Name] {+ results = append(results, cloneQuerySpanResult(result))+ }+ }+ }+ for i, expr := range valueColumns {+ name, _, err := q.extractOmniExpr(expr)+ if err != nil {+ return nil, err+ }+ results = append(results, base.QuerySpanResult{+ Name: name,+ SourceColumns: inputSources[i],+ IsPlainField: false,+ })+ }+ if unpivot.PivotColumn != nil {+ name, _, err := q.extractOmniExpr(unpivot.PivotColumn)+ if err != nil {+ return nil, err+ }+ results = append(results, base.QuerySpanResult{+ Name: name,+ SourceColumns: base.SourceColumnSet{},+ IsPlainField: false,+ })+ }+ return aliasOmniTableSource(&base.PseudoTable{Columns: results}, unpivot.Alias), nil+}++func (q *omniQuerySpanExtractor) extractOmniModelSelect(stmt *oracleast.SelectStmt) (base.TableSource, error) {+ oldFrom := q.tableSourcesFrom+ oldTopLevelFrom := q.topLevelTableSourcesFrom+ q.tableSourcesFrom = nil+ q.topLevelTableSourcesFrom = nil+ defer func() {+ q.tableSourcesFrom = oldFrom+ q.topLevelTableSourcesFrom = oldTopLevelFrom+ }()++ for _, node := range listItems(stmt.FromClause) {+ tableExpr, ok := node.(oracleast.TableExpr)+ if !ok {+ continue+ }+ tableSource, err := q.extractOmniTableExpr(tableExpr)+ if err != nil {+ return nil, err+ }+ if tableSource != nil {+ q.tableSourcesFrom = append(q.tableSourcesFrom, tableSource)+ q.topLevelTableSourcesFrom = append(q.topLevelTableSourcesFrom, tableSource)+ }+ }++ var results []base.QuerySpanResult+ if stmt.ModelClause != nil && stmt.ModelClause.MainModel != nil && stmt.ModelClause.MainModel.ColumnClauses != nil {+ columns := stmt.ModelClause.MainModel.ColumnClauses+ for _, list := range []*oracleast.List{columns.PartitionBy, columns.DimensionBy, columns.Measures} {+ if list == nil {+ continue+ }+ extracted, err := q.extractOmniTargetList(list)+ if err != nil {+ return nil, err+ }+ results = append(results, extracted...)+ }+ }+ return &base.PseudoTable{Columns: results}, nil+}++func (*omniQuerySpanExtractor) extractOmniTableCollection(ref *oracleast.TableCollectionExpr) (base.TableSource, error) {+ if ref == nil {+ return nil, nil+ }+ var columns []base.QuerySpanResult+ for _, name := range omniStringList(ref.ColumnAliases) {+ columns = append(columns, base.QuerySpanResult{+ Name: name,+ SourceColumns: base.SourceColumnSet{},+ IsPlainField: false,+ })+ }+ if len(columns) == 0 {+ return nil, errors.Errorf("unsupported oracle table collection without column aliases")+ }+ return aliasOmniTableSource(&base.PseudoTable{Columns: columns}, ref.Alias), nil+}++func (q *omniQuerySpanExtractor) extractOmniMatchRecognize(ref *oracleast.MatchRecognizeClause) (base.TableSource, error) {+ if ref == nil {+ return nil, nil+ }+ // Capture the FROM scope before extracting the source: a join source+ // appends its operands to tableSourcesFrom, and they must not leak past+ // this transform — the clause replaces them with its own output.+ oldFrom := q.tableSourcesFrom+ defer func() {+ q.tableSourcesFrom = oldFrom+ }()+ source, err := q.extractOmniTableExpr(ref.Source)+ if err != nil {+ return nil, err+ }+ // While deriving the transform's output, the scope is exactly the+ // extracted source: the clause's inputs resolve against it alone, never+ // against enclosing join operands or the source's own leaked operands+ // (a USING-merged column must attribute to both sides, not to the first+ // operand in the slice).+ q.tableSourcesFrom = nil+ if source != nil {+ q.tableSourcesFrom = []base.TableSource{source}+ }++ partitionResults, err := q.extractOmniResultList(ref.PartitionBy)+ if err != nil {+ return nil, err+ }+ measureResults, err := q.extractOmniMatchRecognizeMeasureList(ref.Measures)+ if err != nil {+ return nil, err+ }+ var results []base.QuerySpanResult+ if strings.HasPrefix(strings.ToUpper(ref.RowsPerMatch), "ALL ROWS PER MATCH") && source != nil {+ results = cloneQuerySpanResults(source.GetQuerySpanResult())+ } else {+ results = append(results, partitionResults...)+ }+ results = append(results, measureResults...)+ return aliasOmniTableSource(&base.PseudoTable{Columns: results}, ref.Alias), nil+}++func (q *omniQuerySpanExtractor) extractOmniResultList(list *oracleast.List) ([]base.QuerySpanResult, error) {+ return q.extractOmniResultListWithSourceColumns(list, nil)+}++func (q *omniQuerySpanExtractor) extractOmniMatchRecognizeMeasureList(list *oracleast.List) ([]base.QuerySpanResult, error) {+ return q.extractOmniResultListWithSourceColumns(list, q.extractOmniMatchRecognizeMeasureSourceColumns)+}++func (q *omniQuerySpanExtractor) extractOmniResultListWithSourceColumns(list *oracleast.List, sourceColumnsExtractor func(oracleast.ExprNode) (base.SourceColumnSet, error)) ([]base.QuerySpanResult, error) {+ var results []base.QuerySpanResult+ for _, node := range listItems(list) {+ var expr oracleast.ExprNode+ name := ""+ switch node := node.(type) {+ case *oracleast.ResTarget:+ expr = node.Expr+ name = node.Name+ case oracleast.ExprNode:+ expr = node+ default:+ continue+ }+ if expr == nil {+ continue+ }++ extractedName, sourceColumns, err := q.extractOmniExpr(expr)+ if err != nil {+ return nil, err+ }+ if sourceColumnsExtractor != nil {+ sourceColumns, err = sourceColumnsExtractor(expr)+ if err != nil {+ return nil, err+ }+ }+ if name == "" {+ name = extractedName+ }+ results = append(results, base.QuerySpanResult{+ Name: name,+ SourceColumns: sourceColumns,+ IsPlainField: false,+ })+ }+ return results, nil+}++func (q *omniQuerySpanExtractor) extractOmniMatchRecognizeMeasureSourceColumns(expr oracleast.ExprNode) (base.SourceColumnSet, error) {+ return q.extractOmniExprSourceColumnsWithResolver(expr, func(node *oracleast.ColumnRef) base.SourceColumnSet {+ sourceColumns := q.getOmniFieldColumnSource(node.Schema, node.Table, node.Column)+ if len(sourceColumns) == 0 && node.Schema == "" && node.Table != "" {+ sourceColumns = q.getOmniFieldColumnSource("", "", node.Column)+ }+ return sourceColumns+ })+}++func omniSetLeftSelect(stmt *oracleast.SelectStmt) *oracleast.SelectStmt {+ if stmt == nil {+ return nil+ }+ if stmt.Larg != nil {+ return stmt.Larg+ }+ body := *stmt+ body.Op = 0+ body.SetAll = false+ body.Larg = nil+ body.Rarg = nil+ return &body+}++func mergeOmniJoinTableSource(join *oracleast.JoinClause, left, right base.TableSource) (base.TableSource, error) {+ if left == nil {+ return right, nil+ }+ if right == nil {+ return left, nil+ }+ leftResults := left.GetQuerySpanResult()+ rightResults := right.GetQuerySpanResult()+ result := new(base.PseudoTable)++ leftIndex := make(map[string]int)+ rightIndex := make(map[string]int)+ for i, field := range leftResults {+ leftIndex[field.Name] = i+ }+ for i, field := range rightResults {+ rightIndex[field.Name] = i+ }++ if isOmniNaturalJoin(join.Type) {+ for _, field := range leftResults {+ if rightIdx, ok := rightIndex[field.Name]; ok {+ field.SourceColumns, _ = base.MergeSourceColumnSet(field.SourceColumns, rightResults[rightIdx].SourceColumns)+ }+ result.Columns = append(result.Columns, field)+ }+ for _, field := range rightResults {+ if _, ok := leftIndex[field.Name]; !ok {+ result.Columns = append(result.Columns, field)+ }+ }+ return result, nil+ }++ if len(listItems(join.Using)) != 0 {+ usingMap := make(map[string]bool)+ for _, node := range listItems(join.Using) {+ switch node := node.(type) {+ case *oracleast.String:+ usingMap[node.Str] = true+ case *oracleast.ColumnRef:+ usingMap[node.Column] = true+ default:+ }+ }+ for _, field := range leftResults {+ if usingMap[field.Name] {+ if rightIdx, ok := rightIndex[field.Name]; ok {+ field.SourceColumns, _ = base.MergeSourceColumnSet(field.SourceColumns, rightResults[rightIdx].SourceColumns)+ }+ }+ result.Columns = append(result.Columns, field)+ }+ for _, field := range rightResults {+ if !usingMap[field.Name] {+ result.Columns = append(result.Columns, field)+ }+ }+ return result, nil+ }++ result.Columns = append(result.Columns, leftResults...)+ result.Columns = append(result.Columns, rightResults...)+ return result, nil+}++func isOmniNaturalJoin(joinType oracleast.JoinType) bool {+ switch joinType {+ case oracleast.JOIN_NATURAL_INNER, oracleast.JOIN_NATURAL_LEFT, oracleast.JOIN_NATURAL_RIGHT, oracleast.JOIN_NATURAL_FULL:+ return true+ default:+ return false+ }+}++func (q *omniQuerySpanExtractor) extractOmniExpr(expr oracleast.ExprNode) (string, base.SourceColumnSet, error) {+ if expr == nil {+ return "", base.SourceColumnSet{}, nil+ }++ switch expr := expr.(type) {+ case *oracleast.ColumnRef:+ if expr.Column == "*" {+ return "*", base.SourceColumnSet{}, nil+ }+ return expr.Column, q.getOmniFieldColumnSource(expr.Schema, expr.Table, expr.Column), nil+ case *oracleast.Star:+ return "*", base.SourceColumnSet{}, nil+ case *oracleast.NumberLiteral:+ return q.omniExprName(expr.Loc, expr.Val), base.SourceColumnSet{}, nil+ case *oracleast.StringLiteral:+ return q.omniExprName(expr.Loc, expr.Val), base.SourceColumnSet{}, nil+ case *oracleast.NullLiteral:+ return q.omniExprName(expr.Loc, "NULL"), base.SourceColumnSet{}, nil+ case *oracleast.DateTimeLiteral:+ return q.omniExprName(expr.Loc, expr.TypeName+" "+expr.Val), base.SourceColumnSet{}, nil+ case *oracleast.SubqueryExpr:+ child := q.clone()+ child.outerTableSources = append(cloneTableSourceSlice(q.outerTableSources), q.tableSourcesFrom...)+ tableSource, err := child.extractOmniStmt(expr.Subquery)+ if err != nil {+ return "", nil, err+ }+ return q.omniExprName(expr.Loc, ""), mergeSourceColumnsFromResults(tableSource.GetQuerySpanResult()), nil+ case *oracleast.ExistsExpr:+ child := q.clone()+ child.outerTableSources = append(cloneTableSourceSlice(q.outerTableSources), q.tableSourcesFrom...)+ tableSource, err := child.extractOmniStmt(expr.Subquery)+ if err != nil {+ return "", nil, err+ }+ return q.omniExprName(expr.Loc, ""), mergeSourceColumnsFromResults(tableSource.GetQuerySpanResult()), nil+ case *oracleast.CursorExpr:+ child := q.clone()+ child.outerTableSources = append(cloneTableSourceSlice(q.outerTableSources), q.tableSourcesFrom...)+ tableSource, err := child.extractOmniStmt(expr.Subquery)+ if err != nil {+ return "", nil, err+ }+ return q.omniExprName(expr.Loc, ""), mergeSourceColumnsFromResults(tableSource.GetQuerySpanResult()), nil+ default:+ name := q.omniExprName(getOmniExprFullLoc(expr), oracleast.NodeToString(expr))+ sourceColumns, err := q.extractOmniExprSourceColumns(expr)+ return name, sourceColumns, err+ }+}++func (q *omniQuerySpanExtractor) extractOmniExprSourceColumns(expr oracleast.ExprNode) (base.SourceColumnSet, error) {+ return q.extractOmniExprSourceColumnsWithResolver(expr, func(node *oracleast.ColumnRef) base.SourceColumnSet {+ return q.getOmniFieldColumnSource(node.Schema, node.Table, node.Column)+ })+}++func (q *omniQuerySpanExtractor) extractOmniExprSourceColumnsWithResolver(expr oracleast.ExprNode, resolveColumn func(*oracleast.ColumnRef) base.SourceColumnSet) (base.SourceColumnSet, error) {+ result := make(base.SourceColumnSet)+ var walkErr error+ oracleast.Inspect(expr, func(node oracleast.Node) bool {+ if walkErr != nil || node == nil {+ return false+ }+ switch node := node.(type) {+ case *oracleast.ColumnRef:+ if node.Column != "*" {+ result, _ = base.MergeSourceColumnSet(result, resolveColumn(node))+ }+ return false+ case *oracleast.FuncCallExpr:+ return true+ case *oracleast.SubqueryExpr:+ child := q.clone()+ child.outerTableSources = append(cloneTableSourceSlice(q.outerTableSources), q.tableSourcesFrom...)+ tableSource, err := child.extractOmniStmt(node.Subquery)+ if err != nil {+ walkErr = err+ return false+ }+ result, _ = base.MergeSourceColumnSet(result, mergeSourceColumnsFromResults(tableSource.GetQuerySpanResult()))+ return false+ case *oracleast.ExistsExpr:+ child := q.clone()+ child.outerTableSources = append(cloneTableSourceSlice(q.outerTableSources), q.tableSourcesFrom...)+ tableSource, err := child.extractOmniStmt(node.Subquery)+ if err != nil {+ walkErr = err+ return false+ }+ result, _ = base.MergeSourceColumnSet(result, mergeSourceColumnsFromResults(tableSource.GetQuerySpanResult()))+ return false+ case *oracleast.CursorExpr:+ child := q.clone()+ child.outerTableSources = append(cloneTableSourceSlice(q.outerTableSources), q.tableSourcesFrom...)+ tableSource, err := child.extractOmniStmt(node.Subquery)+ if err != nil {+ walkErr = err+ return false+ }+ result, _ = base.MergeSourceColumnSet(result, mergeSourceColumnsFromResults(tableSource.GetQuerySpanResult()))+ return false+ default:+ return true+ }+ })+ return result, walkErr+}++func (q *omniQuerySpanExtractor) getOmniFieldColumnSource(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+ }+ for _, field := range tableSource.GetQuerySpanResult() {+ if field.Name == columnName {+ return field.SourceColumns, true+ }+ }+ return nil, false+ }++ for _, tableSource := range q.tableSourcesFrom {+ if sourceColumnSet, ok := findInTableSource(tableSource); ok {+ return sourceColumnSet+ }+ }+ for i := len(q.outerTableSources) - 1; i >= 0; i-- {+ if sourceColumnSet, ok := findInTableSource(q.outerTableSources[i]); ok {+ return sourceColumnSet+ }+ }+ return base.SourceColumnSet{}+}++func (q *omniQuerySpanExtractor) expandOmniAsterisk(schemaName, tableName string) ([]base.QuerySpanResult, error) {+ findInTableSource := func(tableSource base.TableSource) ([]base.QuerySpanResult, bool) {+ if schemaName != "" && schemaName != tableSource.GetDatabaseName() {+ return nil, false+ }+ if tableName != "" && tableName != tableSource.GetTableName() {+ return nil, false+ }+ return tableSource.GetQuerySpanResult(), true+ }++ if tableName == "" && schemaName == "" {+ if len(q.topLevelTableSourcesFrom) > 0 {+ return cloneQuerySpanResultsFromTableSources(q.topLevelTableSourcesFrom), nil+ }+ if len(q.tableSourcesFrom) > 0 {+ return cloneQuerySpanResultsFromTableSources(q.tableSourcesFrom), nil+ }+ if len(q.outerTableSources) > 0 {+ return cloneQuerySpanResults(q.outerTableSources[len(q.outerTableSources)-1].GetQuerySpanResult()), nil+ }+ return []base.QuerySpanResult{}, nil+ }++ for i := len(q.tableSourcesFrom) - 1; i >= 0; i-- {+ if results, ok := findInTableSource(q.tableSourcesFrom[i]); ok {+ return cloneQuerySpanResults(results), nil+ }+ }+ for i := len(q.outerTableSources) - 1; i >= 0; i-- {+ if results, ok := findInTableSource(q.outerTableSources[i]); ok {+ return cloneQuerySpanResults(results), nil+ }+ }+ return nil, errors.Errorf("failed to resolve asterisk for table %q", tableName)+}++func cloneQuerySpanResultsFromTableSources(tableSources []base.TableSource) []base.QuerySpanResult {+ var result []base.QuerySpanResult+ for _, tableSource := range tableSources {+ if tableSource == nil {+ continue+ }+ result = append(result, cloneQuerySpanResults(tableSource.GetQuerySpanResult())...)+ }+ return result+}++func (q *omniQuerySpanExtractor) extractOmniXMLTable(ref *oracleast.XmlTableRef) (base.TableSource, error) {+ _, sourceColumns, err := q.extractOmniExpr(ref.Passing)+ if err != nil {+ return nil, err+ }+ var columns []base.QuerySpanResult+ for _, node := range listItems(ref.Columns) {+ column, ok := node.(*oracleast.XmlTableColumn)+ if !ok {+ continue+ }+ columnSource := base.SourceColumnSet{}+ if !column.ForOrdinality {+ columnSource = sourceColumns+ }+ columns = append(columns, base.QuerySpanResult{+ Name: column.Name,+ SourceColumns: columnSource,+ IsPlainField: false,+ })+ }+ name := ""+ if ref.Alias != nil {+ name = ref.Alias.Name+ }+ return &base.PseudoTable{Name: name, Columns: columns}, nil+}++func (q *omniQuerySpanExtractor) extractOmniJSONTable(ref *oracleast.JsonTableRef) (base.TableSource, error) {+ _, sourceColumns, err := q.extractOmniExpr(ref.Expr)+ if err != nil {+ return nil, err+ }+ columns := extractOmniJSONTableColumns(ref.Columns, sourceColumns)+ name := ""+ if ref.Alias != nil {+ name = ref.Alias.Name+ }+ return &base.PseudoTable{Name: name, Columns: columns}, nil+}++func extractOmniJSONTableColumns(list *oracleast.List, sourceColumns base.SourceColumnSet) []base.QuerySpanResult {+ var columns []base.QuerySpanResult+ for _, node := range listItems(list) {+ column, ok := node.(*oracleast.JsonTableColumn)+ if !ok {+ continue+ }+ if column.Nested != nil {+ columns = append(columns, extractOmniJSONTableColumns(column.Nested.Columns, sourceColumns)...)+ continue+ }+ columnSource := sourceColumns+ if column.ForOrdinality {+ columnSource = base.SourceColumnSet{}+ }+ columns = append(columns, base.QuerySpanResult{+ Name: column.Name,+ SourceColumns: columnSource,+ IsPlainField: false,+ })+ }+ return columns+}++func extractOmniInlineExternalTable(ref *oracleast.InlineExternalTable) base.TableSource {+ var columns []base.QuerySpanResult+ for _, node := range listItems(ref.Columns) {+ column, ok := node.(*oracleast.ColumnDef)+ if !ok {+ continue+ }+ columns = append(columns, base.QuerySpanResult{+ Name: column.Name,+ SourceColumns: base.SourceColumnSet{},+ IsPlainField: false,+ })+ }+ name := ""+ if ref.Alias != nil {+ name = ref.Alias.Name+ }+ return &base.PseudoTable{Name: name, Columns: columns}+}++func aliasOmniTableSource(tableSource base.TableSource, alias *oracleast.Alias) base.TableSource {+ if tableSource == nil || alias == nil || alias.Name == "" {+ return tableSource+ }+ columns := cloneQuerySpanResults(tableSource.GetQuerySpanResult())+ applyOmniColumnAliases(columns, omniStringList(alias.Cols))+ return &base.PseudoTable{+ Name: alias.Name,+ Columns: columns,+ }+}++func applyOmniColumnAliases(columns []base.QuerySpanResult, names []string) {+ for i, name := range names {+ if i >= len(columns) {+ return+ }+ columns[i].Name = name+ }+}++func cloneQuerySpanResult(result base.QuerySpanResult) base.QuerySpanResult {+ return base.QuerySpanResult{+ Name: result.Name,+ SourceColumns: cloneSourceColumnSet(result.SourceColumns),+ IsPlainField: result.IsPlainField,+ }+}++func cloneQuerySpanResults(results []base.QuerySpanResult) []base.QuerySpanResult {+ cloned := make([]base.QuerySpanResult, 0, len(results))+ for _, result := range results {+ cloned = append(cloned, cloneQuerySpanResult(result))+ }+ return cloned+}++func cloneSourceColumnSet(source base.SourceColumnSet) base.SourceColumnSet {+ cloned := make(base.SourceColumnSet, len(source))+ for column := range source {+ cloned[column] = true+ }+ return cloned+}++func excludeSourceColumnNames(excluded map[string]bool, source base.SourceColumnSet) {+ for column := range source {+ if column.Column == "" {+ continue+ }+ excluded[column.Column] = true+ excluded[strings.ToUpper(column.Column)] = true+ }+}++func excludeOmniColumnRefNames(excluded map[string]bool, expr oracleast.ExprNode) {+ oracleast.Inspect(expr, func(node oracleast.Node) bool {+ columnRef, ok := node.(*oracleast.ColumnRef)+ if ok && columnRef.Schema == "" && columnRef.Table == "" && columnRef.Column != "*" {+ excluded[columnRef.Column] = true+ excluded[strings.ToUpper(columnRef.Column)] = true+ }+ return true+ })+}++func mergeSourceColumnsFromResults(results []base.QuerySpanResult) base.SourceColumnSet {+ merged := make(base.SourceColumnSet)+ for _, result := range results {+ merged, _ = base.MergeSourceColumnSet(merged, result.SourceColumns)+ }+ return merged+}++func querySpanResultsEqual(left, right []base.QuerySpanResult) bool {+ if len(left) != len(right) {+ return false+ }+ for i := range left {+ if left[i].Name != right[i].Name || left[i].IsPlainField != right[i].IsPlainField {+ return false+ }+ if !sourceColumnSetEqual(left[i].SourceColumns, right[i].SourceColumns) {+ return false+ }+ }+ return true+}++func sourceColumnSetEqual(left, right base.SourceColumnSet) bool {+ if len(left) != len(right) {+ return false+ }+ for column := range left {+ if !right[column] {+ return false+ }+ }+ return true+}++func listItems(list *oracleast.List) []oracleast.Node {+ if list == nil {+ return nil+ }+ return list.Items+}++func omniExprList(list *oracleast.List) []oracleast.ExprNode {+ var result []oracleast.ExprNode+ for _, node := range listItems(list) {+ expr, ok := node.(oracleast.ExprNode)+ if ok {+ result = append(result, expr)+ }+ }+ return result+}++func omniStringList(list *oracleast.List) []string {+ var result []string+ for _, node := range listItems(list) {+ switch node := node.(type) {+ case *oracleast.String:+ result = append(result, node.Str)+ case *oracleast.ColumnRef:+ result = append(result, node.Column)+ default:+ }+ }+ return result+}++func pivotInItemName(q *omniQuerySpanExtractor, item *oracleast.PivotInItem) string {+ if item == nil {+ return ""+ }+ if item.Alias != "" {+ return item.Alias+ }+ var parts []string+ for _, expr := range omniExprList(item.Values) {+ name, _, err := q.extractOmniExpr(expr)+ if err != nil {+ continue+ }+ if name != "" {+ parts = append(parts, name)+ }+ }+ return strings.Join(parts, "_")+}++func pivotColumnName(inName, aggregateAlias string, _ int) string {+ if aggregateAlias == "" {+ return inName+ }+ if inName == "" {+ return aggregateAlias+ }+ return inName + "_" + aggregateAlias+}++func isOmniStar(expr oracleast.ExprNode) bool {+ _, ok := expr.(*oracleast.Star)+ return ok+}++func splitOmniDBLink(dbLink string) []string {+ if dbLink == "" {+ return nil+ }+ return strings.Split(dbLink, ".")+}++func cloneTableSourceSlice(sources []base.TableSource) []base.TableSource {+ cloned := make([]base.TableSource, len(sources))+ copy(cloned, sources)+ return cloned+}++func (q *omniQuerySpanExtractor) omniExprName(loc oracleast.Loc, fallback string) string {+ if !loc.IsUnknown() && loc.Start >= 0 && loc.End <= len(q.source) && loc.Start < loc.End {+ return removeWhitespace(q.source[loc.Start:loc.End])+ }+ return removeWhitespace(fallback)+}++func removeWhitespace(s string) string {+ return strings.Map(func(r rune) rune {+ if unicode.IsSpace(r) {+ return -1+ }+ return r+ }, s)+}++func getOmniNodeLoc(node oracleast.Node) oracleast.Loc {+ value := reflect.ValueOf(node)+ if value.Kind() != reflect.Pointer || value.IsNil() {+ return oracleast.NoLoc()+ }+ elem := value.Elem()+ field := elem.FieldByName("Loc")+ if !field.IsValid() || !field.CanInterface() {+ return oracleast.NoLoc()+ }+ loc, ok := field.Interface().(oracleast.Loc)+ if !ok {+ return oracleast.NoLoc()+ }+ return loc+}++func getOmniExprFullLoc(expr oracleast.ExprNode) oracleast.Loc {+ switch expr := expr.(type) {+ case *oracleast.BinaryExpr:+ return mergeOmniLoc(getOmniExprFullLoc(expr.Left), getOmniExprFullLoc(expr.Right), getOmniNodeLoc(expr))+ case *oracleast.UnaryExpr:+ return mergeOmniLoc(getOmniNodeLoc(expr), getOmniExprFullLoc(expr.Operand))+ case *oracleast.BoolExpr:+ return mergeOmniListLoc(expr.Args, getOmniNodeLoc(expr))+ case *oracleast.FuncCallExpr:+ return getOmniNodeLoc(expr)+ case *oracleast.CaseExpr:+ return mergeOmniLoc(getOmniNodeLoc(expr), getOmniListLastLoc(expr.Whens), getOmniExprFullLoc(expr.Default))+ case *oracleast.CaseWhen:+ return mergeOmniLoc(getOmniNodeLoc(expr), getOmniExprFullLoc(expr.Condition), getOmniExprFullLoc(expr.Result))+ case *oracleast.DecodeExpr:+ return mergeOmniLoc(getOmniNodeLoc(expr), getOmniListLastLoc(expr.Pairs), getOmniExprFullLoc(expr.Default))+ case *oracleast.DecodePair:+ return mergeOmniLoc(getOmniExprFullLoc(expr.Search), getOmniExprFullLoc(expr.Result), getOmniNodeLoc(expr))+ case *oracleast.BetweenExpr:+ return mergeOmniLoc(getOmniExprFullLoc(expr.Expr), getOmniExprFullLoc(expr.Low), getOmniExprFullLoc(expr.High), getOmniNodeLoc(expr))+ case *oracleast.InExpr:+ return mergeOmniLoc(getOmniExprFullLoc(expr.Expr), getOmniNodeLoc(expr))+ case *oracleast.LikeExpr:+ return mergeOmniLoc(getOmniExprFullLoc(expr.Expr), getOmniExprFullLoc(expr.Pattern), getOmniExprFullLoc(expr.Escape), getOmniNodeLoc(expr))+ case *oracleast.IsExpr:+ return mergeOmniLoc(getOmniExprFullLoc(expr.Expr), getOmniNodeLoc(expr))+ case *oracleast.CastExpr:+ return mergeOmniLoc(getOmniNodeLoc(expr), getOmniExprFullLoc(expr.Arg))+ case *oracleast.MultisetExpr:+ return mergeOmniLoc(getOmniExprFullLoc(expr.Left), getOmniExprFullLoc(expr.Right), getOmniNodeLoc(expr))+ case *oracleast.CursorExpr:+ return getOmniNodeLoc(expr)+ case *oracleast.TreatExpr:+ return mergeOmniLoc(getOmniNodeLoc(expr), getOmniExprFullLoc(expr.Expr))+ case *oracleast.ParenExpr:+ return mergeOmniLoc(getOmniNodeLoc(expr), getOmniExprFullLoc(expr.Expr))+ default:+ return getOmniNodeLoc(expr)+ }+}++func mergeOmniListLoc(list *oracleast.List, fallback oracleast.Loc) oracleast.Loc {+ loc := fallback+ for _, node := range listItems(list) {+ loc = mergeOmniLoc(loc, getOmniNodeLoc(node))+ }+ return loc+}++func getOmniListLastLoc(list *oracleast.List) oracleast.Loc {+ var loc oracleast.Loc+ for _, node := range listItems(list) {+ loc = mergeOmniLoc(loc, getOmniNodeLoc(node))+ }+ return loc+}++func mergeOmniLoc(locs ...oracleast.Loc) oracleast.Loc {+ result := oracleast.NoLoc()+ for _, loc := range locs {+ if loc.IsUnknown() || loc.Start < 0 || loc.End < loc.Start {+ continue+ }+ if result.IsUnknown() || loc.Start < result.Start {+ result.Start = loc.Start+ }+ if result.IsUnknown() || loc.End > result.End {+ result.End = loc.End+ }+ }+ return result+}diff --git a/backend/plugin/parser/plsql/query_span_extractor_omni.go b/backend/plugin/parser/plsql/query_span_extractor_omni.godeleted file mode 100644index 44b82bd90f..0000000000--- a/backend/plugin/parser/plsql/query_span_extractor_omni.go+++ /dev/null@@ -1,1543 +0,0 @@-package plsql--import (- "context"- "reflect"- "strings"- "unicode"-- "github.com/pkg/errors"-- oracleast "github.com/bytebase/omni/oracle/ast"-- "github.com/bytebase/bytebase/backend/plugin/parser/base"-)--type omniQuerySpanExtractor struct {- *querySpanExtractor-- source string- topLevelTableSourcesFrom []base.TableSource-}--func newOmniQuerySpanExtractor(connectionDatabase string, gCtx base.GetQuerySpanContext) *omniQuerySpanExtractor {- return &omniQuerySpanExtractor{- querySpanExtractor: newQuerySpanExtractor(connectionDatabase, gCtx),- }-}--func (q *omniQuerySpanExtractor) getOmniQuerySpan(ctx context.Context, statement string) (*base.QuerySpan, error) {- q.ctx = ctx- q.source = statement-- list, err := ParsePLSQLOmni(statement)- if err != nil {- return nil, errors.Wrapf(err, "failed to parse statement: %s", statement)- }- if list == nil || len(list.Items) == 0 {- return nil, nil- }- if len(list.Items) > 1 {- return nil, errors.Errorf("query span extraction only supports single statement, got %d statements", len(list.Items))- }- raw, ok := list.Items[0].(*oracleast.RawStmt)- if !ok || raw.Stmt == nil {- return nil, nil- }-- accessTables := collectOmniAccessTables(q.defaultDatabase, raw.Stmt)- allSystem, mixed := isMixedQuery(accessTables)- if mixed {- return nil, base.MixUserSystemTablesError- }-- queryType := omniQueryType(raw.Stmt, allSystem)- if queryType != base.Select {- return &base.QuerySpan{- Type: queryType,- 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- }-- selectStmt, ok := raw.Stmt.(*oracleast.SelectStmt)- if !ok {- return nil, errors.Errorf("expected SELECT statement, got %T", raw.Stmt)- }- tableSource, err := q.extractOmniSelect(selectStmt)- 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 tableSource != nil {- results = tableSource.GetQuerySpanResult()- }- if resourceNotFound := q.findMissingOmniAccessTable(raw.Stmt, accessTables); resourceNotFound != nil {- 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 &base.QuerySpan{- Type: base.Select,- SourceColumns: columnSet,- Results: results,- }, nil-}--func omniQueryType(stmt oracleast.StmtNode, allSystem bool) base.QueryType {- if stmt == nil {- return base.QueryTypeUnknown- }- switch stmt.(type) {- case *oracleast.ExplainPlanStmt:- return base.Explain- case *oracleast.SelectStmt:- if allSystem {- return base.SelectInfoSchema- }- return base.Select- case *oracleast.InsertStmt, *oracleast.UpdateStmt, *oracleast.DeleteStmt, *oracleast.MergeStmt,- *oracleast.CallStmt, *oracleast.LockTableStmt:- return base.DML- case *oracleast.CreateTableStmt, *oracleast.AlterTableStmt, *oracleast.DropStmt,- *oracleast.CreateIndexStmt, *oracleast.CreateViewStmt,- *oracleast.CreateSequenceStmt, *oracleast.CreateSynonymStmt,- *oracleast.CreateDatabaseLinkStmt, *oracleast.CreateTypeStmt,- *oracleast.CreatePackageStmt, *oracleast.CreateProcedureStmt,- *oracleast.CreateFunctionStmt, *oracleast.CreateTriggerStmt,- *oracleast.TruncateStmt, *oracleast.AlterSessionStmt,- *oracleast.AlterSystemStmt, *oracleast.CreateUserStmt,- *oracleast.AlterUserStmt, *oracleast.CreateRoleStmt,- *oracleast.AlterRoleStmt, *oracleast.CreateProfileStmt,- *oracleast.AlterProfileStmt, *oracleast.AlterResourceCostStmt,- *oracleast.AdminDDLStmt, *oracleast.CreateSchemaStmt,- *oracleast.AlterDatabaseLinkStmt, *oracleast.AlterSynonymStmt,- *oracleast.AlterMaterializedViewStmt,- *oracleast.CreateAuditPolicyStmt, *oracleast.AlterAuditPolicyStmt,- *oracleast.DropAuditPolicyStmt, *oracleast.CreateTablespaceStmt,- *oracleast.AlterTablespaceStmt, *oracleast.CreateTablespaceSetStmt,- *oracleast.DropTablespaceStmt, *oracleast.CreateClusterStmt,- *oracleast.CreateDimensionStmt, *oracleast.AlterClusterStmt,- *oracleast.AlterDimensionStmt, *oracleast.CreateMaterializedZonemapStmt,- *oracleast.AlterMaterializedZonemapStmt, *oracleast.CreateInmemoryJoinGroupStmt,- *oracleast.AlterInmemoryJoinGroupStmt, *oracleast.AlterIndexStmt,- *oracleast.AlterViewStmt, *oracleast.AlterSequenceStmt,- *oracleast.AlterProcedureStmt, *oracleast.AlterFunctionStmt,- *oracleast.AlterPackageStmt, *oracleast.AlterTriggerStmt,- *oracleast.AlterTypeStmt, *oracleast.CreateIndextypeStmt,- *oracleast.AlterIndextypeStmt, *oracleast.CreateOperatorStmt,- *oracleast.AlterOperatorStmt, *oracleast.CreateMviewLogStmt,- *oracleast.AlterMviewLogStmt, *oracleast.CreateAnalyticViewStmt,- *oracleast.AlterAnalyticViewStmt, *oracleast.CreateJsonDualityViewStmt,- *oracleast.AlterJsonDualityViewStmt, *oracleast.CreateAttributeDimensionStmt,- *oracleast.AlterAttributeDimensionStmt, *oracleast.CreateHierarchyStmt,- *oracleast.AlterHierarchyStmt, *oracleast.CreateDomainStmt,- *oracleast.AlterDomainStmt, *oracleast.CreatePropertyGraphStmt,- *oracleast.CreateVectorIndexStmt, *oracleast.CreateLockdownProfileStmt,- *oracleast.AlterLockdownProfileStmt, *oracleast.CreateOutlineStmt,- *oracleast.AlterOutlineStmt:- return base.DDL- }- return base.QueryTypeUnknown-}--func (q *omniQuerySpanExtractor) findMissingOmniAccessTable(stmt oracleast.StmtNode, accessTables []base.SchemaResource) *base.ResourceNotFoundError {- cteNames := collectOmniCTENames(stmt)- for _, resource := range accessTables {- if cteNames[resource.Table] || q.existsTableMetadata(resource) {- continue- }- database := resource.Database- if database == "" {- database = q.defaultDatabase- }- table := resource.Table- return &base.ResourceNotFoundError{- Database: &database,- Table: &table,- }- }- return nil-}--func collectOmniCTENames(stmt oracleast.StmtNode) map[string]bool {- result := make(map[string]bool)- oracleast.Inspect(stmt, func(node oracleast.Node) bool {- cte, ok := node.(*oracleast.CTE)- if ok {- result[cte.Name] = true- }- return true- })- return result-}--func collectOmniAccessTables(defaultDatabase string, stmt oracleast.StmtNode) []base.SchemaResource {- seen := make(map[base.SchemaResource]bool)- var result []base.SchemaResource- addResource := func(name *oracleast.ObjectName) {- if name == nil || name.Name == "DUAL" || name.DBLink != "" {- return- }- database := name.Schema- if database == "" {- database = defaultDatabase- }- resource := base.SchemaResource{- Database: database,- Table: name.Name,- }- if !seen[resource] {- seen[resource] = true- result = append(result, resource)- }- }- oracleast.Inspect(stmt, func(node oracleast.Node) bool {- switch node := node.(type) {- case *oracleast.TableRef:- if node.Dblink == "" {- addResource(node.Name)- }- case *oracleast.ContainersExpr:- addResource(node.Name)- default:- }- return true- })- return result-}--func (q *omniQuerySpanExtractor) clone() *omniQuerySpanExtractor {- copyExtractor := *q.querySpanExtractor- return &omniQuerySpanExtractor{- querySpanExtractor: ©Extractor,- source: q.source,- topLevelTableSourcesFrom: cloneTableSourceSlice(q.topLevelTableSourcesFrom),- }-}--func (q *omniQuerySpanExtractor) extractOmniSelect(stmt *oracleast.SelectStmt) (base.TableSource, error) {- if stmt == nil {- return nil, nil- }-- oldCTEs := q.ctes- if stmt.WithClause != nil {- for _, node := range listItems(stmt.WithClause.CTEs) {- cte, ok := node.(*oracleast.CTE)- if !ok {- continue- }- table, err := q.extractOmniCTE(cte)- if err != nil {- q.ctes = oldCTEs- return nil, err- }- q.ctes = append(q.ctes, table)- }- }- defer func() {- q.ctes = oldCTEs- }()-- if stmt.Op != 0 {- return q.extractOmniSetSelect(stmt)- }- if stmt.ModelClause != nil {- source, err := q.extractOmniModelSelect(stmt)- if err != nil {- return nil, err- }- return q.projectOmniTransformedSelect(stmt, source)- }-- oldFrom := q.tableSourcesFrom- oldTopLevelFrom := q.topLevelTableSourcesFrom- q.tableSourcesFrom = nil- q.topLevelTableSourcesFrom = nil- defer func() {- q.tableSourcesFrom = oldFrom- q.topLevelTableSourcesFrom = oldTopLevelFrom- }()-- for _, node := range listItems(stmt.FromClause) {- tableExpr, ok := node.(oracleast.TableExpr)- if !ok {- continue- }- tableSource, err := q.extractOmniTableExpr(tableExpr)- if err != nil {- return nil, err- }- if tableSource != nil {- q.tableSourcesFrom = append(q.tableSourcesFrom, tableSource)- q.topLevelTableSourcesFrom = append(q.topLevelTableSourcesFrom, tableSource)- }- }-- results, err := q.extractOmniTargetList(stmt.TargetList)- if err != nil {- return nil, err- }- return &base.PseudoTable{- Columns: results,- }, nil-}--func (q *omniQuerySpanExtractor) projectOmniTransformedSelect(stmt *oracleast.SelectStmt, source base.TableSource) (base.TableSource, error) {- oldFrom := q.tableSourcesFrom- oldTopLevelFrom := q.topLevelTableSourcesFrom- q.tableSourcesFrom = nil- q.topLevelTableSourcesFrom = nil- if source != nil {- q.tableSourcesFrom = append(q.tableSourcesFrom, source)- q.topLevelTableSourcesFrom = append(q.topLevelTableSourcesFrom, source)- }- defer func() {- q.tableSourcesFrom = oldFrom- q.topLevelTableSourcesFrom = oldTopLevelFrom- }()-- results, err := q.extractOmniTargetList(stmt.TargetList)- if err != nil {- return nil, err- }- return &base.PseudoTable{Columns: results}, nil-}--func (q *omniQuerySpanExtractor) extractOmniSetSelect(stmt *oracleast.SelectStmt) (base.TableSource, error) {- left, err := q.extractOmniSelect(omniSetLeftSelect(stmt))- if err != nil {- return nil, err- }- right, err := q.extractOmniSelect(stmt.Rarg)- if err != nil {- return nil, err- }- return mergeOmniSetTableSources(left, right)-}--func mergeOmniSetTableSources(left, right base.TableSource) (base.TableSource, error) {- if left == nil {- return right, nil- }- if right == nil {- return left, nil- }- leftResults := left.GetQuerySpanResult()- rightResults := right.GetQuerySpanResult()- if len(leftResults) != len(rightResults) {- return nil, errors.Errorf("left and right query span result length mismatch: %d != %d", len(leftResults), len(rightResults))- }- result := make([]base.QuerySpanResult, 0, len(leftResults))- for i, leftResult := range leftResults {- sourceColumns, _ := base.MergeSourceColumnSet(leftResult.SourceColumns, rightResults[i].SourceColumns)- result = append(result, base.QuerySpanResult{- Name: leftResult.Name,- SourceColumns: sourceColumns,- IsPlainField: false,- })- }- return &base.PseudoTable{Columns: result}, nil-}--func (q *omniQuerySpanExtractor) extractOmniCTE(cte *oracleast.CTE) (*base.PseudoTable, error) {- if cte == nil {- return nil, nil- }- name := cte.Name- columnNames := omniStringList(cte.Columns)-- selectStmt, ok := cte.Query.(*oracleast.SelectStmt)- if ok && selectStmt.Op != 0 && len(columnNames) > 0 {- initialSource, err := q.extractOmniSelect(omniSetLeftSelect(selectStmt))- if err != nil {- return nil, err- }- initial := cloneQuerySpanResults(initialSource.GetQuerySpanResult())- applyOmniColumnAliases(initial, columnNames)-- placeholder := &base.PseudoTable{Name: name, Columns: initial}- q.ctes = append(q.ctes, placeholder)- defer func() {- q.ctes = q.ctes[:len(q.ctes)-1]- }()-- columns := initial- for range 16 {- placeholder.Columns = columns- rightSource, err := q.extractOmniSelect(selectStmt.Rarg)- if err != nil {- return nil, err- }- mergedSource, err := mergeOmniSetTableSources(&base.PseudoTable{Columns: initial}, rightSource)- if err != nil {- return nil, err- }- next := cloneQuerySpanResults(mergedSource.GetQuerySpanResult())- applyOmniColumnAliases(next, columnNames)- if querySpanResultsEqual(columns, next) {- return &base.PseudoTable{Name: name, Columns: next}, nil- }- columns = next- }- return &base.PseudoTable{Name: name, Columns: columns}, nil- }-- child := q.clone()- tableSource, err := child.extractOmniStmt(cte.Query)- if err != nil {- return nil, err- }- columns := cloneQuerySpanResults(tableSource.GetQuerySpanResult())- applyOmniColumnAliases(columns, columnNames)- return &base.PseudoTable{Name: name, Columns: columns}, nil-}--func (q *omniQuerySpanExtractor) extractOmniStmt(stmt oracleast.StmtNode) (base.TableSource, error) {- selectStmt, ok := stmt.(*oracleast.SelectStmt)- if !ok {- return nil, errors.Errorf("unsupported statement in query span extractor: %T", stmt)- }- return q.extractOmniSelect(selectStmt)-}--func (q *omniQuerySpanExtractor) extractOmniTargetList(list *oracleast.List) ([]base.QuerySpanResult, error) {- if list == nil || list.Len() == 0 {- return q.expandOmniAsterisk("", "")- }-- var results []base.QuerySpanResult- for _, node := range listItems(list) {- target, ok := node.(*oracleast.ResTarget)- if !ok || target.Expr == nil {- continue- }- if isOmniStar(target.Expr) {- expanded, err := q.expandOmniAsterisk("", "")- if err != nil {- return nil, err- }- results = append(results, expanded...)- continue- }- if ref, ok := target.Expr.(*oracleast.ColumnRef); ok && ref.Column == "*" {- expanded, err := q.expandOmniAsterisk(ref.Schema, ref.Table)- if err != nil {- return nil, err- }- results = append(results, expanded...)- continue- }-- name, sourceColumns, err := q.extractOmniExpr(target.Expr)- if err != nil {- return nil, err- }- if target.Name != "" {- name = target.Name- }- results = append(results, base.QuerySpanResult{- Name: name,- SourceColumns: sourceColumns,- IsPlainField: false,- })- }- return results, nil-}--func (q *omniQuerySpanExtractor) extractOmniTableExpr(expr oracleast.TableExpr) (base.TableSource, error) {- switch expr := expr.(type) {- case *oracleast.TableRef:- if expr.Name == nil {- return nil, nil- }- dbLink := expr.Name.DBLink- if dbLink == "" {- dbLink = expr.Dblink- }- database := expr.Name.Schema- if database == "" && dbLink == "" {- database = q.defaultDatabase- }- tableSource, err := q.plsqlFindTableSchema(splitOmniDBLink(dbLink), database, expr.Name.Name)- if err != nil {- return nil, err- }- return aliasOmniTableSource(tableSource, expr.Alias), nil- case *oracleast.SubqueryRef:- child := q.clone()- tableSource, err := child.extractOmniStmt(expr.Subquery)- if err != nil {- return nil, err- }- return aliasOmniTableSource(tableSource, expr.Alias), nil- case *oracleast.SubqueryExpr:- child := q.clone()- tableSource, err := child.extractOmniStmt(expr.Subquery)- if err != nil {- return nil, err- }- return tableSource, nil- case *oracleast.LateralRef:- child := q.clone()- child.outerTableSources = append(cloneTableSourceSlice(child.outerTableSources), q.tableSourcesFrom...)- tableSource, err := child.extractOmniStmt(expr.Subquery)- if err != nil {- return nil, err- }- return aliasOmniTableSource(tableSource, expr.Alias), nil- case *oracleast.JoinClause:- left, err := q.extractOmniTableExpr(expr.Left)- if err != nil {- return nil, err- }- if left != nil {- q.tableSourcesFrom = append(q.tableSourcesFrom, left)- }- right, err := q.extractOmniTableExpr(expr.Right)- if err != nil {- return nil, err- }- if right != nil {- q.tableSourcesFrom = append(q.tableSourcesFrom, right)- }- return mergeOmniJoinTableSource(expr, left, right)- case *oracleast.XmlTableRef:- return q.extractOmniXMLTable(expr)- case *oracleast.JsonTableRef:- return q.extractOmniJSONTable(expr)- case *oracleast.ContainersExpr:- if expr.Name == nil {- return nil, nil- }- database := expr.Name.Schema- if database == "" {- database = q.defaultDatabase- }- tableSource, err := q.plsqlFindTableSchema(nil, database, expr.Name.Name)- if err != nil {- return nil, err- }- return aliasOmniTableSource(tableSource, expr.Alias), nil- case *oracleast.InlineExternalTable:- return extractOmniInlineExternalTable(expr), nil- case *oracleast.TableCollectionExpr:- return q.extractOmniTableCollection(expr)- case *oracleast.PivotClause:- return q.extractOmniPivot(expr)- case *oracleast.UnpivotClause:- return q.extractOmniUnpivot(expr)- case *oracleast.MatchRecognizeClause:- return q.extractOmniMatchRecognize(expr)- default:- return nil, errors.Errorf("unsupported oracle table source: %T", expr)- }-}--func (q *omniQuerySpanExtractor) extractOmniPivot(pivot *oracleast.PivotClause) (base.TableSource, error) {- if pivot == nil {- return nil, nil- }- // Capture the FROM scope before extracting the source: a join source- // appends its operands to tableSourcesFrom, and they must not leak past- // this transform — the clause replaces them with its own output.- oldFrom := q.tableSourcesFrom- defer func() {- q.tableSourcesFrom = oldFrom- }()- source, err := q.extractOmniTableExpr(pivot.Source)- if err != nil {- return nil, err- }- // While deriving the transform's output, the scope is exactly the- // extracted source: the clause's inputs resolve against it alone, never- // against enclosing join operands or the source's own leaked operands- // (a USING-merged column must attribute to both sides, not to the first- // operand in the slice).- q.tableSourcesFrom = nil- if source != nil {- q.tableSourcesFrom = []base.TableSource{source}- }-- excluded := make(map[string]bool)- pivotSources := make(base.SourceColumnSet)- for _, expr := range omniExprList(pivot.ForColumns) {- name, sourceColumns, err := q.extractOmniExpr(expr)- if err != nil {- return nil, err- }- excluded[name] = true- pivotSources, _ = base.MergeSourceColumnSet(pivotSources, sourceColumns)- }-- var aggregates []*oracleast.PivotAggregate- for _, item := range listItems(pivot.Aggregates) {- aggregate, ok := item.(*oracleast.PivotAggregate)- if ok {- aggregates = append(aggregates, aggregate)- }- }- var inItems []*oracleast.PivotInItem- for _, item := range listItems(pivot.InItems) {- inItem, ok := item.(*oracleast.PivotInItem)- if ok {- inItems = append(inItems, inItem)- }- }-- aggregateSources := make([]base.SourceColumnSet, len(aggregates))- for i, aggregate := range aggregates {- _, sourceColumns, err := q.extractOmniExpr(aggregate.Expr)- if err != nil {- return nil, err- }- aggregateSources[i] = sourceColumns- excludeOmniColumnRefNames(excluded, aggregate.Expr)- excludeSourceColumnNames(excluded, sourceColumns)- }-- var results []base.QuerySpanResult- if source != nil {- for _, result := range source.GetQuerySpanResult() {- if !excluded[result.Name] {- results = append(results, cloneQuerySpanResult(result))- }- }- }- for _, inItem := range inItems {- inName := pivotInItemName(q, inItem)- for i, aggregate := range aggregates {- sourceColumns, _ := base.MergeSourceColumnSet(pivotSources, aggregateSources[i])- results = append(results, base.QuerySpanResult{- Name: pivotColumnName(inName, aggregate.Alias, len(aggregates)),- SourceColumns: sourceColumns,- IsPlainField: false,- })- }- }- return aliasOmniTableSource(&base.PseudoTable{Columns: results}, pivot.Alias), nil-}--func (q *omniQuerySpanExtractor) extractOmniUnpivot(unpivot *oracleast.UnpivotClause) (base.TableSource, error) {- if unpivot == nil {- return nil, nil- }- // Capture the FROM scope before extracting the source: a join source- // appends its operands to tableSourcesFrom, and they must not leak past- // this transform — the clause replaces them with its own output.- oldFrom := q.tableSourcesFrom- defer func() {- q.tableSourcesFrom = oldFrom- }()- source, err := q.extractOmniTableExpr(unpivot.Source)- if err != nil {- return nil, err- }- // While deriving the transform's output, the scope is exactly the- // extracted source: the clause's inputs resolve against it alone, never- // against enclosing join operands or the source's own leaked operands- // (a USING-merged column must attribute to both sides, not to the first- // operand in the slice).- q.tableSourcesFrom = nil- if source != nil {- q.tableSourcesFrom = []base.TableSource{source}- }-- valueColumns := omniExprList(unpivot.ValueColumns)- inputSources := make([]base.SourceColumnSet, len(valueColumns))- excluded := make(map[string]bool)- for _, item := range listItems(unpivot.InputMappings) {- mapping, ok := item.(*oracleast.UnpivotInItem)- if !ok {- continue- }- for i, input := range omniExprList(mapping.InputColumns) {- name, sourceColumns, err := q.extractOmniExpr(input)- if err != nil {- return nil, err- }- excluded[name] = true- if i < len(inputSources) {- inputSources[i], _ = base.MergeSourceColumnSet(inputSources[i], sourceColumns)- }- }- }-- var results []base.QuerySpanResult- if source != nil {- for _, result := range source.GetQuerySpanResult() {- if !excluded[result.Name] {- results = append(results, cloneQuerySpanResult(result))- }- }- }- for i, expr := range valueColumns {- name, _, err := q.extractOmniExpr(expr)- if err != nil {- return nil, err- }- results = append(results, base.QuerySpanResult{- Name: name,- SourceColumns: inputSources[i],- IsPlainField: false,- })- }- if unpivot.PivotColumn != nil {- name, _, err := q.extractOmniExpr(unpivot.PivotColumn)- if err != nil {- return nil, err- }- results = append(results, base.QuerySpanResult{- Name: name,- SourceColumns: base.SourceColumnSet{},- IsPlainField: false,- })- }- return aliasOmniTableSource(&base.PseudoTable{Columns: results}, unpivot.Alias), nil-}--func (q *omniQuerySpanExtractor) extractOmniModelSelect(stmt *oracleast.SelectStmt) (base.TableSource, error) {- oldFrom := q.tableSourcesFrom- oldTopLevelFrom := q.topLevelTableSourcesFrom- q.tableSourcesFrom = nil- q.topLevelTableSourcesFrom = nil- defer func() {- q.tableSourcesFrom = oldFrom- q.topLevelTableSourcesFrom = oldTopLevelFrom- }()-- for _, node := range listItems(stmt.FromClause) {- tableExpr, ok := node.(oracleast.TableExpr)- if !ok {- continue- }- tableSource, err := q.extractOmniTableExpr(tableExpr)- if err != nil {- return nil, err- }- if tableSource != nil {- q.tableSourcesFrom = append(q.tableSourcesFrom, tableSource)- q.topLevelTableSourcesFrom = append(q.topLevelTableSourcesFrom, tableSource)- }- }-- var results []base.QuerySpanResult- if stmt.ModelClause != nil && stmt.ModelClause.MainModel != nil && stmt.ModelClause.MainModel.ColumnClauses != nil {- columns := stmt.ModelClause.MainModel.ColumnClauses- for _, list := range []*oracleast.List{columns.PartitionBy, columns.DimensionBy, columns.Measures} {- if list == nil {- continue- }- extracted, err := q.extractOmniTargetList(list)- if err != nil {- return nil, err- }- results = append(results, extracted...)- }- }- return &base.PseudoTable{Columns: results}, nil-}--func (*omniQuerySpanExtractor) extractOmniTableCollection(ref *oracleast.TableCollectionExpr) (base.TableSource, error) {- if ref == nil {- return nil, nil- }- var columns []base.QuerySpanResult- for _, name := range omniStringList(ref.ColumnAliases) {- columns = append(columns, base.QuerySpanResult{- Name: name,- SourceColumns: base.SourceColumnSet{},- IsPlainField: false,- })- }- if len(columns) == 0 {- return nil, errors.Errorf("unsupported oracle table collection without column aliases")- }- return aliasOmniTableSource(&base.PseudoTable{Columns: columns}, ref.Alias), nil-}--func (q *omniQuerySpanExtractor) extractOmniMatchRecognize(ref *oracleast.MatchRecognizeClause) (base.TableSource, error) {- if ref == nil {- return nil, nil- }- // Capture the FROM scope before extracting the source: a join source- // appends its operands to tableSourcesFrom, and they must not leak past- // this transform — the clause replaces them with its own output.- oldFrom := q.tableSourcesFrom- defer func() {- q.tableSourcesFrom = oldFrom- }()- source, err := q.extractOmniTableExpr(ref.Source)- if err != nil {- return nil, err- }- // While deriving the transform's output, the scope is exactly the- // extracted source: the clause's inputs resolve against it alone, never- // against enclosing join operands or the source's own leaked operands- // (a USING-merged column must attribute to both sides, not to the first- // operand in the slice).- q.tableSourcesFrom = nil- if source != nil {- q.tableSourcesFrom = []base.TableSource{source}- }-- partitionResults, err := q.extractOmniResultList(ref.PartitionBy)- if err != nil {- return nil, err- }- measureResults, err := q.extractOmniMatchRecognizeMeasureList(ref.Measures)- if err != nil {- return nil, err- }- var results []base.QuerySpanResult- if strings.HasPrefix(strings.ToUpper(ref.RowsPerMatch), "ALL ROWS PER MATCH") && source != nil {- results = cloneQuerySpanResults(source.GetQuerySpanResult())- } else {- results = append(results, partitionResults...)- }- results = append(results, measureResults...)- return aliasOmniTableSource(&base.PseudoTable{Columns: results}, ref.Alias), nil-}--func (q *omniQuerySpanExtractor) extractOmniResultList(list *oracleast.List) ([]base.QuerySpanResult, error) {- return q.extractOmniResultListWithSourceColumns(list, nil)-}--func (q *omniQuerySpanExtractor) extractOmniMatchRecognizeMeasureList(list *oracleast.List) ([]base.QuerySpanResult, error) {- return q.extractOmniResultListWithSourceColumns(list, q.extractOmniMatchRecognizeMeasureSourceColumns)-}--func (q *omniQuerySpanExtractor) extractOmniResultListWithSourceColumns(list *oracleast.List, sourceColumnsExtractor func(oracleast.ExprNode) (base.SourceColumnSet, error)) ([]base.QuerySpanResult, error) {- var results []base.QuerySpanResult- for _, node := range listItems(list) {- var expr oracleast.ExprNode- name := ""- switch node := node.(type) {- case *oracleast.ResTarget:- expr = node.Expr- name = node.Name- case oracleast.ExprNode:- expr = node- default:- continue- }- if expr == nil {- continue- }-- extractedName, sourceColumns, err := q.extractOmniExpr(expr)- if err != nil {- return nil, err- }- if sourceColumnsExtractor != nil {- sourceColumns, err = sourceColumnsExtractor(expr)- if err != nil {- return nil, err- }- }- if name == "" {- name = extractedName- }- results = append(results, base.QuerySpanResult{- Name: name,- SourceColumns: sourceColumns,- IsPlainField: false,- })- }- return results, nil-}--func (q *omniQuerySpanExtractor) extractOmniMatchRecognizeMeasureSourceColumns(expr oracleast.ExprNode) (base.SourceColumnSet, error) {- return q.extractOmniExprSourceColumnsWithResolver(expr, func(node *oracleast.ColumnRef) base.SourceColumnSet {- sourceColumns := q.getOmniFieldColumnSource(node.Schema, node.Table, node.Column)- if len(sourceColumns) == 0 && node.Schema == "" && node.Table != "" {- sourceColumns = q.getOmniFieldColumnSource("", "", node.Column)- }- return sourceColumns- })-}--func omniSetLeftSelect(stmt *oracleast.SelectStmt) *oracleast.SelectStmt {- if stmt == nil {- return nil- }- if stmt.Larg != nil {- return stmt.Larg- }- body := *stmt- body.Op = 0- body.SetAll = false- body.Larg = nil- body.Rarg = nil- return &body-}--func mergeOmniJoinTableSource(join *oracleast.JoinClause, left, right base.TableSource) (base.TableSource, error) {- if left == nil {- return right, nil- }- if right == nil {- return left, nil- }- leftResults := left.GetQuerySpanResult()- rightResults := right.GetQuerySpanResult()- result := new(base.PseudoTable)-- leftIndex := make(map[string]int)- rightIndex := make(map[string]int)- for i, field := range leftResults {- leftIndex[field.Name] = i- }- for i, field := range rightResults {- rightIndex[field.Name] = i- }-- if isOmniNaturalJoin(join.Type) {- for _, field := range leftResults {- if rightIdx, ok := rightIndex[field.Name]; ok {- field.SourceColumns, _ = base.MergeSourceColumnSet(field.SourceColumns, rightResults[rightIdx].SourceColumns)- }- result.Columns = append(result.Columns, field)- }- for _, field := range rightResults {- if _, ok := leftIndex[field.Name]; !ok {- result.Columns = append(result.Columns, field)- }- }- return result, nil- }-- if len(listItems(join.Using)) != 0 {- usingMap := make(map[string]bool)- for _, node := range listItems(join.Using) {- switch node := node.(type) {- case *oracleast.String:- usingMap[node.Str] = true- case *oracleast.ColumnRef:- usingMap[node.Column] = true- default:- }- }- for _, field := range leftResults {- if usingMap[field.Name] {- if rightIdx, ok := rightIndex[field.Name]; ok {- field.SourceColumns, _ = base.MergeSourceColumnSet(field.SourceColumns, rightResults[rightIdx].SourceColumns)- }- }- result.Columns = append(result.Columns, field)- }- for _, field := range rightResults {- if !usingMap[field.Name] {- result.Columns = append(result.Columns, field)- }- }- return result, nil- }-- result.Columns = append(result.Columns, leftResults...)- result.Columns = append(result.Columns, rightResults...)- return result, nil-}--func isOmniNaturalJoin(joinType oracleast.JoinType) bool {- switch joinType {- case oracleast.JOIN_NATURAL_INNER, oracleast.JOIN_NATURAL_LEFT, oracleast.JOIN_NATURAL_RIGHT, oracleast.JOIN_NATURAL_FULL:- return true- default:- return false- }-}--func (q *omniQuerySpanExtractor) extractOmniExpr(expr oracleast.ExprNode) (string, base.SourceColumnSet, error) {- if expr == nil {- return "", base.SourceColumnSet{}, nil- }-- switch expr := expr.(type) {- case *oracleast.ColumnRef:- if expr.Column == "*" {- return "*", base.SourceColumnSet{}, nil- }- return expr.Column, q.getOmniFieldColumnSource(expr.Schema, expr.Table, expr.Column), nil- case *oracleast.Star:- return "*", base.SourceColumnSet{}, nil- case *oracleast.NumberLiteral:- return q.omniExprName(expr.Loc, expr.Val), base.SourceColumnSet{}, nil- case *oracleast.StringLiteral:- return q.omniExprName(expr.Loc, expr.Val), base.SourceColumnSet{}, nil- case *oracleast.NullLiteral:- return q.omniExprName(expr.Loc, "NULL"), base.SourceColumnSet{}, nil- case *oracleast.DateTimeLiteral:- return q.omniExprName(expr.Loc, expr.TypeName+" "+expr.Val), base.SourceColumnSet{}, nil- case *oracleast.SubqueryExpr:- child := q.clone()- child.outerTableSources = append(cloneTableSourceSlice(q.outerTableSources), q.tableSourcesFrom...)- tableSource, err := child.extractOmniStmt(expr.Subquery)- if err != nil {- return "", nil, err- }- return q.omniExprName(expr.Loc, ""), mergeSourceColumnsFromResults(tableSource.GetQuerySpanResult()), nil- case *oracleast.ExistsExpr:- child := q.clone()- child.outerTableSources = append(cloneTableSourceSlice(q.outerTableSources), q.tableSourcesFrom...)- tableSource, err := child.extractOmniStmt(expr.Subquery)- if err != nil {- return "", nil, err- }- return q.omniExprName(expr.Loc, ""), mergeSourceColumnsFromResults(tableSource.GetQuerySpanResult()), nil- case *oracleast.CursorExpr:- child := q.clone()- child.outerTableSources = append(cloneTableSourceSlice(q.outerTableSources), q.tableSourcesFrom...)- tableSource, err := child.extractOmniStmt(expr.Subquery)- if err != nil {- return "", nil, err- }- return q.omniExprName(expr.Loc, ""), mergeSourceColumnsFromResults(tableSource.GetQuerySpanResult()), nil- default:- name := q.omniExprName(getOmniExprFullLoc(expr), oracleast.NodeToString(expr))- sourceColumns, err := q.extractOmniExprSourceColumns(expr)- return name, sourceColumns, err- }-}--func (q *omniQuerySpanExtractor) extractOmniExprSourceColumns(expr oracleast.ExprNode) (base.SourceColumnSet, error) {- return q.extractOmniExprSourceColumnsWithResolver(expr, func(node *oracleast.ColumnRef) base.SourceColumnSet {- return q.getOmniFieldColumnSource(node.Schema, node.Table, node.Column)- })-}--func (q *omniQuerySpanExtractor) extractOmniExprSourceColumnsWithResolver(expr oracleast.ExprNode, resolveColumn func(*oracleast.ColumnRef) base.SourceColumnSet) (base.SourceColumnSet, error) {- result := make(base.SourceColumnSet)- var walkErr error- oracleast.Inspect(expr, func(node oracleast.Node) bool {- if walkErr != nil || node == nil {- return false- }- switch node := node.(type) {- case *oracleast.ColumnRef:- if node.Column != "*" {- result, _ = base.MergeSourceColumnSet(result, resolveColumn(node))- }- return false- case *oracleast.FuncCallExpr:- return true- case *oracleast.SubqueryExpr:- child := q.clone()- child.outerTableSources = append(cloneTableSourceSlice(q.outerTableSources), q.tableSourcesFrom...)- tableSource, err := child.extractOmniStmt(node.Subquery)- if err != nil {- walkErr = err- return false- }- result, _ = base.MergeSourceColumnSet(result, mergeSourceColumnsFromResults(tableSource.GetQuerySpanResult()))- return false- case *oracleast.ExistsExpr:- child := q.clone()- child.outerTableSources = append(cloneTableSourceSlice(q.outerTableSources), q.tableSourcesFrom...)- tableSource, err := child.extractOmniStmt(node.Subquery)- if err != nil {- walkErr = err- return false- }- result, _ = base.MergeSourceColumnSet(result, mergeSourceColumnsFromResults(tableSource.GetQuerySpanResult()))- return false- case *oracleast.CursorExpr:- child := q.clone()- child.outerTableSources = append(cloneTableSourceSlice(q.outerTableSources), q.tableSourcesFrom...)- tableSource, err := child.extractOmniStmt(node.Subquery)- if err != nil {- walkErr = err- return false- }- result, _ = base.MergeSourceColumnSet(result, mergeSourceColumnsFromResults(tableSource.GetQuerySpanResult()))- return false- default:- return true- }- })- return result, walkErr-}--func (q *omniQuerySpanExtractor) getOmniFieldColumnSource(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- }- for _, field := range tableSource.GetQuerySpanResult() {- if field.Name == columnName {- return field.SourceColumns, true- }- }- return nil, false- }-- for _, tableSource := range q.tableSourcesFrom {- if sourceColumnSet, ok := findInTableSource(tableSource); ok {- return sourceColumnSet- }- }- for i := len(q.outerTableSources) - 1; i >= 0; i-- {- if sourceColumnSet, ok := findInTableSource(q.outerTableSources[i]); ok {- return sourceColumnSet- }- }- return base.SourceColumnSet{}-}--func (q *omniQuerySpanExtractor) expandOmniAsterisk(schemaName, tableName string) ([]base.QuerySpanResult, error) {- findInTableSource := func(tableSource base.TableSource) ([]base.QuerySpanResult, bool) {- if schemaName != "" && schemaName != tableSource.GetDatabaseName() {- return nil, false- }- if tableName != "" && tableName != tableSource.GetTableName() {- return nil, false- }- return tableSource.GetQuerySpanResult(), true- }-- if tableName == "" && schemaName == "" {- if len(q.topLevelTableSourcesFrom) > 0 {- return cloneQuerySpanResultsFromTableSources(q.topLevelTableSourcesFrom), nil- }- if len(q.tableSourcesFrom) > 0 {- return cloneQuerySpanResultsFromTableSources(q.tableSourcesFrom), nil- }- if len(q.outerTableSources) > 0 {- return cloneQuerySpanResults(q.outerTableSources[len(q.outerTableSources)-1].GetQuerySpanResult()), nil- }- return []base.QuerySpanResult{}, nil- }-- for i := len(q.tableSourcesFrom) - 1; i >= 0; i-- {- if results, ok := findInTableSource(q.tableSourcesFrom[i]); ok {- return cloneQuerySpanResults(results), nil- }- }- for i := len(q.outerTableSources) - 1; i >= 0; i-- {- if results, ok := findInTableSource(q.outerTableSources[i]); ok {- return cloneQuerySpanResults(results), nil- }- }- return nil, errors.Errorf("failed to resolve asterisk for table %q", tableName)-}--func cloneQuerySpanResultsFromTableSources(tableSources []base.TableSource) []base.QuerySpanResult {- var result []base.QuerySpanResult- for _, tableSource := range tableSources {- if tableSource == nil {- continue- }- result = append(result, cloneQuerySpanResults(tableSource.GetQuerySpanResult())...)- }- return result-}--func (q *omniQuerySpanExtractor) extractOmniXMLTable(ref *oracleast.XmlTableRef) (base.TableSource, error) {- _, sourceColumns, err := q.extractOmniExpr(ref.Passing)- if err != nil {- return nil, err- }- var columns []base.QuerySpanResult- for _, node := range listItems(ref.Columns) {- column, ok := node.(*oracleast.XmlTableColumn)- if !ok {- continue- }- columnSource := base.SourceColumnSet{}- if !column.ForOrdinality {- columnSource = sourceColumns- }- columns = append(columns, base.QuerySpanResult{- Name: column.Name,- SourceColumns: columnSource,- IsPlainField: false,- })- }- name := ""- if ref.Alias != nil {- name = ref.Alias.Name- }- return &base.PseudoTable{Name: name, Columns: columns}, nil-}--func (q *omniQuerySpanExtractor) extractOmniJSONTable(ref *oracleast.JsonTableRef) (base.TableSource, error) {- _, sourceColumns, err := q.extractOmniExpr(ref.Expr)- if err != nil {- return nil, err- }- columns := extractOmniJSONTableColumns(ref.Columns, sourceColumns)- name := ""- if ref.Alias != nil {- name = ref.Alias.Name- }- return &base.PseudoTable{Name: name, Columns: columns}, nil-}--func extractOmniJSONTableColumns(list *oracleast.List, sourceColumns base.SourceColumnSet) []base.QuerySpanResult {- var columns []base.QuerySpanResult- for _, node := range listItems(list) {- column, ok := node.(*oracleast.JsonTableColumn)- if !ok {- continue- }- if column.Nested != nil {- columns = append(columns, extractOmniJSONTableColumns(column.Nested.Columns, sourceColumns)...)- continue- }- columnSource := sourceColumns- if column.ForOrdinality {- columnSource = base.SourceColumnSet{}- }- columns = append(columns, base.QuerySpanResult{- Name: column.Name,- SourceColumns: columnSource,- IsPlainField: false,- })- }- return columns-}--func extractOmniInlineExternalTable(ref *oracleast.InlineExternalTable) base.TableSource {- var columns []base.QuerySpanResult- for _, node := range listItems(ref.Columns) {- column, ok := node.(*oracleast.ColumnDef)- if !ok {- continue- }- columns = append(columns, base.QuerySpanResult{- Name: column.Name,- SourceColumns: base.SourceColumnSet{},- IsPlainField: false,- })- }- name := ""- if ref.Alias != nil {- name = ref.Alias.Name- }- return &base.PseudoTable{Name: name, Columns: columns}-}--func aliasOmniTableSource(tableSource base.TableSource, alias *oracleast.Alias) base.TableSource {- if tableSource == nil || alias == nil || alias.Name == "" {- return tableSource- }- columns := cloneQuerySpanResults(tableSource.GetQuerySpanResult())- applyOmniColumnAliases(columns, omniStringList(alias.Cols))- return &base.PseudoTable{- Name: alias.Name,- Columns: columns,- }-}--func applyOmniColumnAliases(columns []base.QuerySpanResult, names []string) {- for i, name := range names {- if i >= len(columns) {- return- }- columns[i].Name = name- }-}--func cloneQuerySpanResult(result base.QuerySpanResult) base.QuerySpanResult {- return base.QuerySpanResult{- Name: result.Name,- SourceColumns: cloneSourceColumnSet(result.SourceColumns),- IsPlainField: result.IsPlainField,- }-}--func cloneQuerySpanResults(results []base.QuerySpanResult) []base.QuerySpanResult {- cloned := make([]base.QuerySpanResult, 0, len(results))- for _, result := range results {- cloned = append(cloned, cloneQuerySpanResult(result))- }- return cloned-}--func cloneSourceColumnSet(source base.SourceColumnSet) base.SourceColumnSet {- cloned := make(base.SourceColumnSet, len(source))- for column := range source {- cloned[column] = true- }- return cloned-}--func excludeSourceColumnNames(excluded map[string]bool, source base.SourceColumnSet) {- for column := range source {- if column.Column == "" {- continue- }- excluded[column.Column] = true- excluded[strings.ToUpper(column.Column)] = true- }-}--func excludeOmniColumnRefNames(excluded map[string]bool, expr oracleast.ExprNode) {- oracleast.Inspect(expr, func(node oracleast.Node) bool {- columnRef, ok := node.(*oracleast.ColumnRef)- if ok && columnRef.Schema == "" && columnRef.Table == "" && columnRef.Column != "*" {- excluded[columnRef.Column] = true- excluded[strings.ToUpper(columnRef.Column)] = true- }- return true- })-}--func mergeSourceColumnsFromResults(results []base.QuerySpanResult) base.SourceColumnSet {- merged := make(base.SourceColumnSet)- for _, result := range results {- merged, _ = base.MergeSourceColumnSet(merged, result.SourceColumns)- }- return merged-}--func querySpanResultsEqual(left, right []base.QuerySpanResult) bool {- if len(left) != len(right) {- return false- }- for i := range left {- if left[i].Name != right[i].Name || left[i].IsPlainField != right[i].IsPlainField {- return false- }- if !sourceColumnSetEqual(left[i].SourceColumns, right[i].SourceColumns) {- return false- }- }- return true-}--func sourceColumnSetEqual(left, right base.SourceColumnSet) bool {- if len(left) != len(right) {- return false- }- for column := range left {- if !right[column] {- return false- }- }- return true-}--func listItems(list *oracleast.List) []oracleast.Node {- if list == nil {- return nil- }- return list.Items-}--func omniExprList(list *oracleast.List) []oracleast.ExprNode {- var result []oracleast.ExprNode- for _, node := range listItems(list) {- expr, ok := node.(oracleast.ExprNode)- if ok {- result = append(result, expr)- }- }- return result-}--func omniStringList(list *oracleast.List) []string {- var result []string- for _, node := range listItems(list) {- switch node := node.(type) {- case *oracleast.String:- result = append(result, node.Str)- case *oracleast.ColumnRef:- result = append(result, node.Column)- default:- }- }- return result-}--func pivotInItemName(q *omniQuerySpanExtractor, item *oracleast.PivotInItem) string {- if item == nil {- return ""- }- if item.Alias != "" {- return item.Alias- }- var parts []string- for _, expr := range omniExprList(item.Values) {- name, _, err := q.extractOmniExpr(expr)- if err != nil {- continue- }- if name != "" {- parts = append(parts, name)- }- }- return strings.Join(parts, "_")-}--func pivotColumnName(inName, aggregateAlias string, _ int) string {- if aggregateAlias == "" {- return inName- }- if inName == "" {- return aggregateAlias- }- return inName + "_" + aggregateAlias-}--func isOmniStar(expr oracleast.ExprNode) bool {- _, ok := expr.(*oracleast.Star)- return ok-}--func splitOmniDBLink(dbLink string) []string {- if dbLink == "" {- return nil- }- return strings.Split(dbLink, ".")-}--func cloneTableSourceSlice(sources []base.TableSource) []base.TableSource {- cloned := make([]base.TableSource, len(sources))- copy(cloned, sources)- return cloned-}--func (q *omniQuerySpanExtractor) omniExprName(loc oracleast.Loc, fallback string) string {- if !loc.IsUnknown() && loc.Start >= 0 && loc.End <= len(q.source) && loc.Start < loc.End {- return removeWhitespace(q.source[loc.Start:loc.End])- }- return removeWhitespace(fallback)-}--func removeWhitespace(s string) string {- return strings.Map(func(r rune) rune {- if unicode.IsSpace(r) {- return -1- }- return r- }, s)-}--func getOmniNodeLoc(node oracleast.Node) oracleast.Loc {- value := reflect.ValueOf(node)- if value.Kind() != reflect.Pointer || value.IsNil() {- return oracleast.NoLoc()- }- elem := value.Elem()- field := elem.FieldByName("Loc")- if !field.IsValid() || !field.CanInterface() {- return oracleast.NoLoc()- }- loc, ok := field.Interface().(oracleast.Loc)- if !ok {- return oracleast.NoLoc()- }- return loc-}--func getOmniExprFullLoc(expr oracleast.ExprNode) oracleast.Loc {- switch expr := expr.(type) {- case *oracleast.BinaryExpr:- return mergeOmniLoc(getOmniExprFullLoc(expr.Left), getOmniExprFullLoc(expr.Right), getOmniNodeLoc(expr))- case *oracleast.UnaryExpr:- return mergeOmniLoc(getOmniNodeLoc(expr), getOmniExprFullLoc(expr.Operand))- case *oracleast.BoolExpr:- return mergeOmniListLoc(expr.Args, getOmniNodeLoc(expr))- case *oracleast.FuncCallExpr:- return getOmniNodeLoc(expr)- case *oracleast.CaseExpr:- return mergeOmniLoc(getOmniNodeLoc(expr), getOmniListLastLoc(expr.Whens), getOmniExprFullLoc(expr.Default))- case *oracleast.CaseWhen:- return mergeOmniLoc(getOmniNodeLoc(expr), getOmniExprFullLoc(expr.Condition), getOmniExprFullLoc(expr.Result))- case *oracleast.DecodeExpr:- return mergeOmniLoc(getOmniNodeLoc(expr), getOmniListLastLoc(expr.Pairs), getOmniExprFullLoc(expr.Default))- case *oracleast.DecodePair:- return mergeOmniLoc(getOmniExprFullLoc(expr.Search), getOmniExprFullLoc(expr.Result), getOmniNodeLoc(expr))- case *oracleast.BetweenExpr:- return mergeOmniLoc(getOmniExprFullLoc(expr.Expr), getOmniExprFullLoc(expr.Low), getOmniExprFullLoc(expr.High), getOmniNodeLoc(expr))- case *oracleast.InExpr:- return mergeOmniLoc(getOmniExprFullLoc(expr.Expr), getOmniNodeLoc(expr))- case *oracleast.LikeExpr:- return mergeOmniLoc(getOmniExprFullLoc(expr.Expr), getOmniExprFullLoc(expr.Pattern), getOmniExprFullLoc(expr.Escape), getOmniNodeLoc(expr))- case *oracleast.IsExpr:- return mergeOmniLoc(getOmniExprFullLoc(expr.Expr), getOmniNodeLoc(expr))- case *oracleast.CastExpr:- return mergeOmniLoc(getOmniNodeLoc(expr), getOmniExprFullLoc(expr.Arg))- case *oracleast.MultisetExpr:- return mergeOmniLoc(getOmniExprFullLoc(expr.Left), getOmniExprFullLoc(expr.Right), getOmniNodeLoc(expr))- case *oracleast.CursorExpr:- return getOmniNodeLoc(expr)- case *oracleast.TreatExpr:- return mergeOmniLoc(getOmniNodeLoc(expr), getOmniExprFullLoc(expr.Expr))- case *oracleast.ParenExpr:- return mergeOmniLoc(getOmniNodeLoc(expr), getOmniExprFullLoc(expr.Expr))- default:- return getOmniNodeLoc(expr)- }-}--func mergeOmniListLoc(list *oracleast.List, fallback oracleast.Loc) oracleast.Loc {- loc := fallback- for _, node := range listItems(list) {- loc = mergeOmniLoc(loc, getOmniNodeLoc(node))- }- return loc-}--func getOmniListLastLoc(list *oracleast.List) oracleast.Loc {- var loc oracleast.Loc- for _, node := range listItems(list) {- loc = mergeOmniLoc(loc, getOmniNodeLoc(node))- }- return loc-}--func mergeOmniLoc(locs ...oracleast.Loc) oracleast.Loc {- result := oracleast.NoLoc()- for _, loc := range locs {- if loc.IsUnknown() || loc.Start < 0 || loc.End < loc.Start {- continue- }- if result.IsUnknown() || loc.Start < result.Start {- result.Start = loc.Start- }- if result.IsUnknown() || loc.End > result.End {- result.End = loc.End- }- }- return result-}diff --git a/backend/plugin/parser/plsql/query_span_omni_parity_test.go b/backend/plugin/parser/plsql/query_span_parity_test.gosimilarity index 100%rename from backend/plugin/parser/plsql/query_span_omni_parity_test.gorename to backend/plugin/parser/plsql/query_span_parity_test.godiff --git a/backend/plugin/parser/plsql/query_span_omni_probe_test.go b/backend/plugin/parser/plsql/query_span_probe_test.gosimilarity index 98%rename from backend/plugin/parser/plsql/query_span_omni_probe_test.gorename to backend/plugin/parser/plsql/query_span_probe_test.goindex fc45472a48..142d64fccc 100644--- a/backend/plugin/parser/plsql/query_span_omni_probe_test.go+++ b/backend/plugin/parser/plsql/query_span_probe_test.go@@ -29,7 +29,7 @@ func TestOracleOmniParsesQuerySpanFixtureCorpus(t *testing.T) {for _, tc := range testCases {t.Run(tc.Description, func(t *testing.T) {- list, err := ParsePLSQLOmni(tc.Statement)+ list, err := ParsePLSQL(tc.Statement)require.NoError(t, err)require.NotNil(t, list)require.Len(t, list.Items, 1)@@ -164,7 +164,7 @@ func TestOracleOmniQuerySpanMigrationProbe(t *testing.T) {for _, test := range tests {t.Run(test.name, func(t *testing.T) {- list, err := ParsePLSQLOmni(test.statement)+ list, err := ParsePLSQL(test.statement)require.NoError(t, err)require.Len(t, list.Items, 1)raw, ok := list.Items[0].(*ast.RawStmt)diff --git a/backend/plugin/parser/plsql/query_span_test.go b/backend/plugin/parser/plsql/query_span_test.goindex 301de39bcb..36fb0810e0 100644--- a/backend/plugin/parser/plsql/query_span_test.go+++ b/backend/plugin/parser/plsql/query_span_test.go@@ -227,7 +227,7 @@ func TestGetAccessTables(t *testing.T) {}for _, test := range tests {- results, err := ParsePLSQLOmni(test.statement)+ results, err := ParsePLSQL(test.statement)require.NoError(t, err)require.NotEmpty(t, results)require.NotEmpty(t, results.Items)diff --git a/backend/plugin/parser/plsql/query_type_omni_test.go b/backend/plugin/parser/plsql/query_type_test.gosimilarity index 96%rename from backend/plugin/parser/plsql/query_type_omni_test.gorename to backend/plugin/parser/plsql/query_type_test.goindex 065d95c590..f890ace57e 100644--- a/backend/plugin/parser/plsql/query_type_omni_test.go+++ b/backend/plugin/parser/plsql/query_type_test.go@@ -49,7 +49,7 @@ func TestOracleOmniQueryTypeDDLClassification(t *testing.T) {for _, test := range tests {t.Run(test.name, func(t *testing.T) {- list, err := ParsePLSQLOmni(test.statement)+ list, err := ParsePLSQL(test.statement)require.NoError(t, err)require.Len(t, list.Items, 1)raw, ok := list.Items[0].(*oracleast.RawStmt)diff --git a/backend/plugin/parser/plsql/restore.go b/backend/plugin/parser/plsql/restore.goindex e3169eb82e..4ec9fe51c0 100644--- a/backend/plugin/parser/plsql/restore.go+++ b/backend/plugin/parser/plsql/restore.go@@ -77,7 +77,7 @@ func findFirstOracleDML(statement string) (oracleast.StmtNode, error) {}func findFirstOracleDMLOnce(statement string) (oracleast.StmtNode, error) {- list, err := ParsePLSQLOmni(statement)+ list, err := ParsePLSQL(statement)if err != nil {return nil, err}diff --git a/backend/plugin/parser/redshift/diagnose.go b/backend/plugin/parser/redshift/diagnose.goindex 998b84676d..522d9bed0d 100644--- a/backend/plugin/parser/redshift/diagnose.go+++ b/backend/plugin/parser/redshift/diagnose.go@@ -27,7 +27,7 @@ func parseRedshiftStatement(statement string) *base.SyntaxError {Text: statement,Start: &store.Position{Line: 1, Column: 1},}- if _, err := ParseRedshiftOmni(statement); err != nil {+ if _, err := ParseRedshift(statement); err != nil {syntaxErr, ok := convertOmniError(err, stmt).(*base.SyntaxError)if !ok {return &base.SyntaxError{diff --git a/backend/plugin/parser/redshift/omni.go b/backend/plugin/parser/redshift/omni.goindex 02b8cb7480..716ce8e19e 100644--- a/backend/plugin/parser/redshift/omni.go+++ b/backend/plugin/parser/redshift/omni.go@@ -28,8 +28,8 @@ func (a *OmniAST) ASTStartPosition() *storepb.Position {return a.StartPosition}-// ParseRedshiftOmni parses SQL using omni's parser.-func ParseRedshiftOmni(sql string) ([]omniredshift.Statement, error) {+// ParseRedshift parses SQL using omni's parser.+func ParseRedshift(sql string) ([]omniredshift.Statement, error) {return omniredshift.Parse(sql)}diff --git a/backend/plugin/parser/redshift/query.go b/backend/plugin/parser/redshift/query.goindex de9ff6541e..8e634cf7cc 100644--- a/backend/plugin/parser/redshift/query.go+++ b/backend/plugin/parser/redshift/query.go@@ -22,7 +22,7 @@ func init() {// - returnsData: whether all queries return data// - error: parsing error if the statement is invalidfunc ValidateSQLForEditor(statement string) (bool, bool, error) {- omniStmts, err := ParseRedshiftOmni(statement)+ omniStmts, err := ParseRedshift(statement)if err != nil {return false, false, convertOmniError(err, base.Statement{Text: statement,diff --git a/backend/plugin/parser/redshift/query_span_extractor_omni.go b/backend/plugin/parser/redshift/query_span_extractor.gosimilarity index 99%rename from backend/plugin/parser/redshift/query_span_extractor_omni.gorename to backend/plugin/parser/redshift/query_span_extractor.goindex a0148eea40..9c989003e5 100644--- a/backend/plugin/parser/redshift/query_span_extractor_omni.go+++ b/backend/plugin/parser/redshift/query_span_extractor.go@@ -49,7 +49,7 @@ func (q *omniQuerySpanExtractor) getOmniQuerySpan(ctx context.Context, statement}func (q *omniQuerySpanExtractor) getOmniQuerySpanWithFunctionStack(ctx context.Context, statement string, functionStack map[string]bool) (*base.QuerySpan, error) {- stmts, err := ParseRedshiftOmni(statement)+ stmts, err := ParseRedshift(statement)if err != nil {return nil, err}@@ -376,7 +376,7 @@ type redshiftSchemaQualificationEdit struct {}func qualifyRedshiftViewDefinition(definition, schemaName string, metadata *model.DatabaseMetadata) string {- stmts, err := ParseRedshiftOmni(definition)+ stmts, err := ParseRedshift(definition)if err != nil || len(stmts) != 1 {return definition}@@ -996,7 +996,7 @@ func omniFunctionCallName(list *redshiftast.List) (string, string) {}func omniFunctionParameterCount(definition string) (int, bool) {- stmts, err := ParseRedshiftOmni(definition)+ stmts, err := ParseRedshift(definition)if err != nil || len(stmts) != 1 {return 0, false}@@ -1008,7 +1008,7 @@ func omniFunctionParameterCount(definition string) (int, bool) {}func extractOmniSQLFunctionBody(definition string) (string, bool, error) {- stmts, err := ParseRedshiftOmni(definition)+ stmts, err := ParseRedshift(definition)if err != nil {return "", false, errors.Wrapf(err, "failed to parse function definition")}diff --git a/backend/plugin/parser/redshift/query_span_omni_test.go b/backend/plugin/parser/redshift/query_span_test.gosimilarity index 99%rename from backend/plugin/parser/redshift/query_span_omni_test.gorename to backend/plugin/parser/redshift/query_span_test.goindex 84932840e7..b007663363 100644--- a/backend/plugin/parser/redshift/query_span_omni_test.go+++ b/backend/plugin/parser/redshift/query_span_test.go@@ -98,18 +98,17 @@ func TestRedshiftOmniQuerySpanSupportedShapes(t *testing.T) {}func TestRedshiftQuerySpanEntrypointDoesNotDependOnANTLR(t *testing.T) {- for _, path := range []string{"query_span.go", "query_span_extractor_omni.go"} {+ for _, path := range []string{"query_span.go", "query_span_extractor.go"} {content, err := os.ReadFile(path)require.NoError(t, err)source := string(content)require.NotContains(t, source, "github.com/antlr4-go/antlr/v4", path)require.NotContains(t, source, "github.com/bytebase/parser/redshift", path)- require.NotContains(t, source, "ParseRedshift(", path)}}func TestRedshiftOmniQuerySpanUsesLazyRelationResolver(t *testing.T) {- content, err := os.ReadFile("query_span_extractor_omni.go")+ content, err := os.ReadFile("query_span_extractor.go")require.NoError(t, err)source := string(content)require.Contains(t, source, "SetRelationResolver")diff --git a/backend/plugin/parser/redshift/redshift.go b/backend/plugin/parser/redshift/redshift.goindex edc6488e28..fc602a9fe3 100644--- a/backend/plugin/parser/redshift/redshift.go+++ b/backend/plugin/parser/redshift/redshift.go@@ -25,7 +25,7 @@ func parseRedshiftStatements(statement string) ([]base.ParsedStatement, error) {continue}- omniStmts, err := ParseRedshiftOmni(stmt.Text)+ omniStmts, err := ParseRedshift(stmt.Text)if err != nil {return nil, convertOmniError(err, stmt)}diff --git a/backend/plugin/parser/redshift/resource_change.go b/backend/plugin/parser/redshift/resource_change.goindex 515d89b04a..ce4babbf86 100644--- a/backend/plugin/parser/redshift/resource_change.go+++ b/backend/plugin/parser/redshift/resource_change.go@@ -48,7 +48,7 @@ func extractChangedResources(database string, schema string, dbMetadata *model.D}func extractOmniSampleDMLs(statement string) ([]string, error) {- stmts, err := ParseRedshiftOmni(statement)+ stmts, err := ParseRedshift(statement)if err != nil {return nil, err}diff --git a/backend/plugin/parser/tsql/diagnose.go b/backend/plugin/parser/tsql/diagnose.goindex 3896981b4f..ba0b2f8d77 100644--- a/backend/plugin/parser/tsql/diagnose.go+++ b/backend/plugin/parser/tsql/diagnose.go@@ -34,7 +34,7 @@ func parseTSQLStatement(statement string) *base.SyntaxError {statement += ";"}- _, err := ParseTSQLOmni(statement)+ _, err := ParseTSQL(statement)if err == nil {return nil}diff --git a/backend/plugin/parser/tsql/dollar_token_test.go b/backend/plugin/parser/tsql/dollar_token_test.goindex 852d1dd380..a68ce0341c 100644--- a/backend/plugin/parser/tsql/dollar_token_test.go+++ b/backend/plugin/parser/tsql/dollar_token_test.go@@ -44,8 +44,8 @@ OUTPUT $action, INSERTED.k, INSERTED.v;`,_, err := base.ParseStatements(storepb.Engine_MSSQL, sql)require.NoError(t, err, "SQL review entry must accept %q", sql)- _, err = ParseTSQLOmni(sql)- require.NoError(t, err, "ParseTSQLOmni must accept %q", sql)+ _, err = ParseTSQL(sql)+ require.NoError(t, err, "ParseTSQL must accept %q", sql)})}diff --git a/backend/plugin/parser/tsql/omni.go b/backend/plugin/parser/tsql/omni.goindex e7e3bacc85..18d9d730a5 100644--- a/backend/plugin/parser/tsql/omni.go+++ b/backend/plugin/parser/tsql/omni.go@@ -25,9 +25,9 @@ func (a *OmniAST) ASTStartPosition() *storepb.Position {return a.StartPosition}-// ParseTSQLOmni parses SQL using omni's parser and returns omni Statement objects directly.+// ParseTSQL parses SQL using omni's parser and returns omni Statement objects directly.// This is the recommended entry point for new code that needs omni AST nodes.-func ParseTSQLOmni(sql string) ([]omnimssql.Statement, error) {+func ParseTSQL(sql string) ([]omnimssql.Statement, error) {return omnimssql.Parse(sql)}diff --git a/backend/plugin/parser/tsql/query.go b/backend/plugin/parser/tsql/query.goindex 69009a63c7..c8efd44b99 100644--- a/backend/plugin/parser/tsql/query.go+++ b/backend/plugin/parser/tsql/query.go@@ -15,7 +15,7 @@ func init() {// SELECT (no SELECT INTO). Returns (valid, allAlike, err). For MSSQL the two// booleans move together — we reject on the first non-SELECT.func ValidateSQLForEditor(statement string) (bool, bool, error) {- stmts, err := ParseTSQLOmni(statement)+ stmts, err := ParseTSQL(statement)if err != nil {return false, false, err}diff --git a/backend/plugin/parser/tsql/query_span_extractor.go b/backend/plugin/parser/tsql/query_span_extractor.goindex a544007927..8e20880d4f 100644--- a/backend/plugin/parser/tsql/query_span_extractor.go+++ b/backend/plugin/parser/tsql/query_span_extractor.go@@ -2,19 +2,16 @@ package tsqlimport ("context"+ "reflect""strings""unicode""github.com/bytebase/omni/mssql/ast"-"github.com/pkg/errors""github.com/bytebase/bytebase/backend/plugin/parser/base")-// querySpanExtractor holds the shared identifier-resolution and scoping state-// used by the omni-based query span extractor. Only string-based helpers live-// on this type; AST-walking logic lives on *omniQuerySpanExtractor.type querySpanExtractor struct {ctx context.Context@@ -167,7 +164,7 @@ func (q *querySpanExtractor) getColumnsFromCreateView(definition string, viewDatreturn nil, errors.Errorf("cyclic view reference detected while resolving %q", viewName)}- stmts, err := ParseTSQLOmni(definition)+ stmts, err := ParseTSQL(definition)if err != nil {return nil, errors.Wrapf(err, "failed to parse CREATE VIEW definition")}@@ -423,3 +420,1596 @@ func isSystemResource(resource base.ColumnResource, ignoreCaseSensitive bool) bo}return false}++// omniQuerySpanExtractor extracts query span information from omni MSSQL AST.+// It embeds querySpanExtractor so string-based resolution helpers+// (tsqlIsFieldSensitive, tsqlFindTableSchemaByParts, isIdentifierEqual,+// tsqlGetAllFieldsOfTableInFromOrOuterCTE) are reused directly.+type omniQuerySpanExtractor struct {+ *querySpanExtractor+ // source is the original SQL text, used to slice expression names via Loc.+ source string+}++func newOmniQuerySpanExtractor(defaultDatabase, defaultSchema string, gCtx base.GetQuerySpanContext, ignoreCaseSensitive bool) *omniQuerySpanExtractor {+ return &omniQuerySpanExtractor{+ querySpanExtractor: newQuerySpanExtractor(defaultDatabase, defaultSchema, gCtx, ignoreCaseSensitive),+ }+}++// getOmniQuerySpan is the public entry point. Mirrors the ANTLR getQuerySpan flow.+func (q *omniQuerySpanExtractor) getOmniQuerySpan(ctx context.Context, statement string) (*base.QuerySpan, error) {+ q.ctx = ctx+ q.source = statement++ stmts, err := ParseTSQL(statement)+ if err != nil {+ return nil, err+ }+ if len(stmts) == 0 {+ return &base.QuerySpan{+ Type: base.Select,+ SourceColumns: make(base.SourceColumnSet),+ Results: []base.QuerySpanResult{},+ }, nil+ }+ if len(stmts) != 1 {+ return nil, errors.Errorf("expected exactly 1 statement, got %d", len(stmts))+ }++ root := stmts[0].AST+ if root == nil {+ // An empty statement. Match ANTLR's zero-AST behavior.+ return &base.QuerySpan{+ Type: base.Select,+ SourceColumns: make(base.SourceColumnSet),+ Results: []base.QuerySpanResult{},+ }, nil+ }+ if _, isGo := root.(*ast.GoStmt); isGo {+ // A bare "GO" batch separator. ANTLR discards it and returns an empty+ // Select span; match that.+ return &base.QuerySpan{+ Type: base.Select,+ SourceColumns: make(base.SourceColumnSet),+ Results: []base.QuerySpanResult{},+ }, nil+ }++ // DECLARE @t TABLE(...) populates gCtx.TempTables so subsequent statements+ // in the same session (the caller loops over split statements) can resolve+ // @t. Mirrors the legacy ANTLR tsqlSelectOnlyListener.EnterDeclare_statement+ // side-effect. Non-table DECLARE (plain scalar variables) is a no-op.+ if d, ok := root.(*ast.DeclareStmt); ok {+ populateOmniTempTables(d, q.gCtx.TempTables)+ }+ if c, ok := root.(*ast.CreateTableStmt); ok {+ populateOmniCreateTempTable(c, q.gCtx.TempTables)+ }++ accessTables := collectOmniAccessTables(root, q.defaultDatabase, q.defaultSchema)+ allSystems, mixed := isMixedQuery(accessTables, q.ignoreCaseSensitive)+ if mixed {+ return nil, base.MixUserSystemTablesError+ }++ queryType := classifyQueryType(root, allSystems)+ sel, isSelect := root.(*ast.SelectStmt)+ // classifyQueryType maps SET/DECLARE/SetOption to base.Select for historical+ // reasons; those have no result columns. Return early if the root isn't a+ // real SELECT.+ if queryType != base.Select || !isSelect {+ return &base.QuerySpan{+ Type: queryType,+ SourceColumns: base.SourceColumnSet{},+ Results: []base.QuerySpanResult{},+ }, nil+ }++ pseudo, err := q.extractFromSelectStmt(sel)+ if err != nil {+ var resourceNotFound *base.ResourceNotFoundError+ if errors.As(err, &resourceNotFound) {+ return &base.QuerySpan{+ Type: base.Select,+ SourceColumns: accessTables,+ Results: []base.QuerySpanResult{},+ NotFoundError: resourceNotFound,+ }, nil+ }+ return nil, err+ }++ return &base.QuerySpan{+ Type: base.Select,+ SourceColumns: accessTables,+ Results: pseudo.GetQuerySpanResult(),+ PredicateColumns: q.predicateColumns,+ }, nil+}++// -------------------- SELECT processing --------------------++// extractFromSelectStmt processes a full SELECT statement (including set-ops,+// WITH clause) and returns the result column set as a PseudoTable.+func (q *omniQuerySpanExtractor) extractFromSelectStmt(sel *ast.SelectStmt) (*base.PseudoTable, error) {+ // WITH clause: populate CTE list BEFORE dispatching set-ops so that both+ // arms of a `WITH cte AS (...) SELECT ... FROM cte UNION SELECT ... FROM cte`+ // see the CTE in scope. The defer restores q.ctes on exit.+ ctesSnapshot := len(q.ctes)+ defer func() { q.ctes = q.ctes[:ctesSnapshot] }()+ if sel.WithClause != nil {+ if err := q.processWithClause(sel.WithClause); err != nil {+ return nil, err+ }+ }++ // Set operations: recurse into arms and union. The WITH clause above is+ // already in q.ctes, so both arms resolve CTE references correctly.+ if sel.Op != ast.SetOpNone && (sel.Larg != nil || sel.Rarg != nil) {+ return q.extractFromSetOp(sel)+ }++ // FROM clause — a SELECT without FROM is legal (e.g. SELECT 1).+ tableSourcesSnapshot := len(q.tableSourcesFrom)+ defer func() { q.tableSourcesFrom = q.tableSourcesFrom[:tableSourcesSnapshot] }()+ if sel.FromClause != nil {+ for _, item := range sel.FromClause.Items {+ ts, err := q.extractTableSource(item)+ if err != nil {+ return nil, err+ }+ q.tableSourcesFrom = append(q.tableSourcesFrom, ts...)+ }+ }++ // WHERE / HAVING predicate columns — resolved in THIS select's scope.+ // Subquery expressions encountered during the walk get cloned extractors;+ // their results merge back into q.predicateColumns. Errors (including+ // ResourceNotFoundError from a subquery referencing a missing table)+ // propagate up to getOmniQuerySpan which converts them into a span with+ // NotFoundError populated.+ if err := q.collectPredicatesInScope(sel.WhereClause); err != nil {+ return nil, err+ }+ if err := q.collectPredicatesInScope(sel.HavingClause); err != nil {+ return nil, err+ }++ // Target list.+ results, err := q.extractTargetList(sel.TargetList)+ if err != nil {+ return nil, err+ }+ q.populateSelectIntoTempTable(sel, results)++ return &base.PseudoTable{Columns: results}, nil+}++// collectPredicatesInScope walks a boolean expression in the extractor's+// current scope: plain ColumnRefs resolve against q.tableSourcesFrom ++// q.outerTableSources; subquery nodes trigger a scope clone, and the+// subquery's output-column sources plus its own predicate-column set merge+// back into q.predicateColumns.+//+// Errors from nested subquery extraction (ResourceNotFoundError or real+// parser errors) propagate so the caller can surface them via the top-level+// NotFoundError path instead of producing a silently-partial span.+func (q *omniQuerySpanExtractor) collectPredicatesInScope(expr ast.Node) error {+ if expr == nil {+ return nil+ }+ switch v := expr.(type) {+ case *ast.ColumnRef:+ if r, handled, err := q.resolvePseudoColumnRef(v); handled {+ if err != nil {+ return errors.Wrapf(err, "failed to resolve predicate column %q", v.Column)+ }+ q.predicateColumns, _ = base.MergeSourceColumnSet(q.predicateColumns, r.SourceColumns)+ return nil+ }+ r, err := q.tsqlIsFieldSensitive(v.Database, v.Schema, v.Table, v.Column)+ if err != nil {+ return errors.Wrapf(err, "failed to resolve predicate column %q", v.Column)+ }+ q.predicateColumns, _ = base.MergeSourceColumnSet(q.predicateColumns, r.SourceColumns)+ return nil+ case *ast.FullTextPredicate:+ if v.Columns != nil {+ for _, it := range v.Columns.Items {+ if cr, ok := it.(*ast.ColumnRef); ok {+ if err := q.collectPredicatesInScope(cr); err != nil {+ return err+ }+ }+ }+ }+ if err := q.collectPredicatesInScope(v.Value); err != nil {+ return err+ }+ return q.collectPredicatesInScope(v.LanguageTerm)+ case *ast.SubqueryExpr:+ return q.mergeSubqueryIntoPredicates(v.Query)+ case *ast.ExistsExpr:+ return q.mergeSubqueryIntoPredicates(v.Subquery)+ case *ast.SubqueryComparisonExpr:+ if err := q.collectPredicatesInScope(v.Left); err != nil {+ return err+ }+ return q.mergeSubqueryIntoPredicates(v.Subquery)+ case *ast.InExpr:+ if err := q.collectPredicatesInScope(v.Expr); err != nil {+ return err+ }+ if v.List != nil {+ for _, it := range v.List.Items {+ if err := q.collectPredicatesInScope(it); err != nil {+ return err+ }+ }+ }+ return q.collectPredicatesInScope(v.Subquery)+ case *ast.BinaryExpr:+ if err := q.collectPredicatesInScope(v.Left); err != nil {+ return err+ }+ return q.collectPredicatesInScope(v.Right)+ case *ast.UnaryExpr:+ return q.collectPredicatesInScope(v.Operand)+ case *ast.BetweenExpr:+ if err := q.collectPredicatesInScope(v.Expr); err != nil {+ return err+ }+ if err := q.collectPredicatesInScope(v.Low); err != nil {+ return err+ }+ return q.collectPredicatesInScope(v.High)+ case *ast.LikeExpr:+ if err := q.collectPredicatesInScope(v.Expr); err != nil {+ return err+ }+ if err := q.collectPredicatesInScope(v.Pattern); err != nil {+ return err+ }+ return q.collectPredicatesInScope(v.Escape)+ case *ast.IsExpr:+ return q.collectPredicatesInScope(v.Expr)+ case *ast.CaseExpr:+ if err := q.collectPredicatesInScope(v.Arg); err != nil {+ return err+ }+ if err := q.collectPredicatesInScope(v.ElseExpr); err != nil {+ return err+ }+ if v.WhenList != nil {+ for _, it := range v.WhenList.Items {+ if cw, ok := it.(*ast.CaseWhen); ok {+ if err := q.collectPredicatesInScope(cw.Condition); err != nil {+ return err+ }+ if err := q.collectPredicatesInScope(cw.Result); err != nil {+ return err+ }+ }+ }+ }+ return nil+ case *ast.IifExpr:+ if err := q.collectPredicatesInScope(v.Condition); err != nil {+ return err+ }+ if err := q.collectPredicatesInScope(v.TrueVal); err != nil {+ return err+ }+ return q.collectPredicatesInScope(v.FalseVal)+ case *ast.CoalesceExpr:+ if v.Args != nil {+ for _, it := range v.Args.Items {+ if err := q.collectPredicatesInScope(it); err != nil {+ return err+ }+ }+ }+ return nil+ case *ast.NullifExpr:+ if err := q.collectPredicatesInScope(v.Left); err != nil {+ return err+ }+ return q.collectPredicatesInScope(v.Right)+ case *ast.FuncCallExpr:+ if v.Args != nil {+ for _, it := range v.Args.Items {+ if err := q.collectPredicatesInScope(it); err != nil {+ return err+ }+ }+ }+ return nil+ case *ast.MethodCallExpr:+ if v.Args != nil {+ for _, it := range v.Args.Items {+ if err := q.collectPredicatesInScope(it); err != nil {+ return err+ }+ }+ }+ return nil+ case *ast.CastExpr:+ return q.collectPredicatesInScope(v.Expr)+ case *ast.ConvertExpr:+ if err := q.collectPredicatesInScope(v.Expr); err != nil {+ return err+ }+ return q.collectPredicatesInScope(v.Style)+ case *ast.TryCastExpr:+ return q.collectPredicatesInScope(v.Expr)+ case *ast.TryConvertExpr:+ if err := q.collectPredicatesInScope(v.Expr); err != nil {+ return err+ }+ return q.collectPredicatesInScope(v.Style)+ case *ast.ParenExpr:+ return q.collectPredicatesInScope(v.Expr)+ case *ast.CollateExpr:+ return q.collectPredicatesInScope(v.Expr)+ case *ast.AtTimeZoneExpr:+ if err := q.collectPredicatesInScope(v.Expr); err != nil {+ return err+ }+ return q.collectPredicatesInScope(v.TimeZone)+ default:+ // Literal, VariableRef, StarExpr, etc. — nothing to collect.+ return nil+ }+}++func (q *omniQuerySpanExtractor) mergeSubqueryIntoPredicates(body ast.Node) error {+ sel, ok := body.(*ast.SelectStmt)+ if !ok {+ return nil+ }+ clone := q.cloneForSubquery()+ pseudo, err := clone.extractFromSelectStmt(sel)+ if err != nil {+ return err+ }+ // Subquery output columns become outer-scope predicate columns.+ for _, c := range pseudo.GetQuerySpanResult() {+ q.predicateColumns, _ = base.MergeSourceColumnSet(q.predicateColumns, c.SourceColumns)+ }+ // And the clone's own predicate columns (from its WHERE etc.) propagate up.+ q.predicateColumns, _ = base.MergeSourceColumnSet(q.predicateColumns, clone.predicateColumns)+ return nil+}++func (q *omniQuerySpanExtractor) extractFromSetOp(sel *ast.SelectStmt) (*base.PseudoTable, error) {+ // Omni puts the WITH clause on the leftmost set-op arm (the parser attaches+ // the WITH to the first SELECT expression, not to the outer Op node). Lift+ // it into the current scope so the CTE is visible in BOTH arms, then+ // recurse into a copy of Larg with WithClause cleared to avoid double+ // processing.+ larg := sel.Larg+ if larg != nil && larg.WithClause != nil {+ if err := q.processWithClause(larg.WithClause); err != nil {+ return nil, err+ }+ cp := *larg+ cp.WithClause = nil+ larg = &cp+ }+ left, err := q.extractFromSelectStmt(larg)+ if err != nil {+ return nil, err+ }+ right, err := q.extractFromSelectStmt(sel.Rarg)+ if err != nil {+ return nil, err+ }+ merged, err := unionTableSources(left, right)+ if err != nil {+ return nil, err+ }+ return &base.PseudoTable{Columns: merged}, nil+}++func (q *omniQuerySpanExtractor) processWithClause(w *ast.WithClause) error {+ if w.CTEs == nil {+ return nil+ }+ for _, item := range w.CTEs.Items {+ cte, ok := item.(*ast.CommonTableExpr)+ if !ok {+ continue+ }+ body, ok := cte.Query.(*ast.SelectStmt)+ if !ok {+ return unsupportedNodeError("only SELECT CTE bodies are supported", cte.Query)+ }++ cteName := normIdent(cte.Name)+ cols, predicates, err := q.extractCTEBody(cteName, body)+ if err != nil {+ return err+ }+ if cte.Columns != nil && cte.Columns.Len() > 0 {+ if cte.Columns.Len() != len(cols) {+ return errors.Errorf("CTE %q column alias count %d does not match body column count %d", cte.Name, cte.Columns.Len(), len(cols))+ }+ for i, it := range cte.Columns.Items {+ if s, ok := it.(*ast.String); ok {+ cols[i].Name = normIdent(s.Str)+ }+ }+ }+ q.ctes = append(q.ctes, &base.PseudoTable{Name: cteName, Columns: cols})+ q.predicateColumns, _ = base.MergeSourceColumnSet(q.predicateColumns, predicates)+ }+ return nil+}++// extractCTEBody extracts the column set of a CTE body. For recursive CTEs+// (body is a set-op SelectStmt whose recursive arm references the CTE name),+// the extractor iterates until the column sources stabilize.+func (q *omniQuerySpanExtractor) extractCTEBody(cteName string, body *ast.SelectStmt) ([]base.QuerySpanResult, base.SourceColumnSet, error) {+ newClone := func() *omniQuerySpanExtractor {+ return &omniQuerySpanExtractor{+ querySpanExtractor: &querySpanExtractor{+ ctx: q.ctx,+ defaultDatabase: q.defaultDatabase,+ defaultSchema: q.defaultSchema,+ ignoreCaseSensitive: q.ignoreCaseSensitive,+ gCtx: q.gCtx,+ ctes: append([]*base.PseudoTable{}, q.ctes...),+ outerTableSources: nil,+ predicateColumns: make(base.SourceColumnSet),+ viewResolutionStack: cloneViewResolutionStack(q.viewResolutionStack),+ },+ source: q.source,+ }+ }++ // Non-set-op CTE: extract directly.+ if body.Op == ast.SetOpNone || (body.Larg == nil && body.Rarg == nil) {+ clone := newClone()+ pseudo, err := clone.extractFromSelectStmt(body)+ if err != nil {+ return nil, nil, err+ }+ return pseudo.GetQuerySpanResult(), clone.predicateColumns, nil+ }++ // Set-op CTE: extract anchor (Larg), register placeholder, then iterate Rarg+ // until the source column sets for the CTE columns stabilize.+ anchorClone := newClone()+ anchorPseudo, err := anchorClone.extractFromSelectStmt(body.Larg)+ if err != nil {+ return nil, nil, err+ }+ cols := append([]base.QuerySpanResult{}, anchorPseudo.GetQuerySpanResult()...)+ predicates := base.SourceColumnSet{}+ predicates, _ = base.MergeSourceColumnSet(predicates, anchorClone.predicateColumns)++ for iter := 0; iter < 16; iter++ {+ placeholder := &base.PseudoTable{Name: cteName, Columns: cols}+ clone := newClone()+ clone.ctes = append(clone.ctes, placeholder)+ rarg, rerr := clone.extractFromSelectStmt(body.Rarg)+ if rerr != nil {+ // Recursive arm failed to resolve (e.g. ResourceNotFoundError from+ // a missing table). Propagate — the top-level getOmniQuerySpan+ // converts ResourceNotFoundError into a span with NotFoundError+ // populated so callers don't see a silently-partial lineage.+ return nil, nil, rerr+ }+ rcols := rarg.GetQuerySpanResult()+ if len(rcols) != len(cols) {+ return nil, nil, errors.Errorf("CTE %q recursive arm returns %d columns, anchor returns %d", cteName, len(rcols), len(cols))+ }+ changed := false+ for i := range rcols {+ merged, anyChange := base.MergeSourceColumnSet(cols[i].SourceColumns, rcols[i].SourceColumns)+ cols[i].SourceColumns = merged+ if anyChange {+ changed = true+ }+ }+ predicates, _ = base.MergeSourceColumnSet(predicates, clone.predicateColumns)+ if !changed {+ break+ }+ }+ return cols, predicates, nil+}++// -------------------- FROM / table source --------------------++// extractTableSource returns the TableSource(s) produced by a single FROM item.+// A JoinClause contributes multiple sources (left + right flattened).+func (q *omniQuerySpanExtractor) extractTableSource(node ast.Node) ([]base.TableSource, error) {+ switch v := node.(type) {+ case *ast.JoinClause:+ return q.extractFromJoin(v)+ case *ast.TableRef:+ ts, err := q.resolveTableRef(v)+ if err != nil {+ return nil, err+ }+ return []base.TableSource{ts}, nil+ case *ast.AliasedTableRef:+ ts, err := q.resolveAliasedTableRef(v)+ if err != nil {+ return nil, err+ }+ return []base.TableSource{ts}, nil+ case *ast.SubqueryExpr:+ ts, err := q.resolveSubqueryAsTable(v, "")+ if err != nil {+ return nil, err+ }+ return []base.TableSource{ts}, nil+ case *ast.ValuesClause:+ ts, err := q.resolveValuesClause(v, "", nil)+ if err != nil {+ return nil, err+ }+ return []base.TableSource{ts}, nil+ case *ast.TableVarRef:+ return q.resolveTableVar(v, v.Alias)+ case *ast.TableVarMethodCallRef:+ return []base.TableSource{&base.PseudoTable{Name: v.Alias, Columns: xmlNodesColumns(v.Columns)}}, nil+ case *ast.PivotExpr:+ return nil, unsupportedTableSourceError(node)+ case *ast.UnpivotExpr:+ return nil, unsupportedTableSourceError(node)+ case *ast.FuncCallExpr:+ ts, err := q.resolveTableValuedFunction(v, "", nil)+ if err != nil {+ return nil, err+ }+ return []base.TableSource{ts}, nil+ default:+ return nil, unsupportedTableSourceError(node)+ }+}++func unsupportedTableSourceError(node ast.Node) error {+ return unsupportedNodeError("only full table name, supported TVF, derived table, values clause, and temp table in table source item are supported", node)+}++func unsupportedNodeError(message string, node ast.Node) error {+ typeName := "<nil>"+ if typ := reflect.TypeOf(node); typ != nil {+ typeName = typ.String()+ }+ return &base.TypeNotSupportedError{+ Err: errors.New(message),+ Type: typeName,+ }+}++func (q *omniQuerySpanExtractor) extractFromJoin(j *ast.JoinClause) ([]base.TableSource, error) {+ left, err := q.extractTableSource(j.Left)+ if err != nil {+ return nil, err+ }+ if j.Type == ast.JoinCrossApply || j.Type == ast.JoinOuterApply {+ tableSourcesSnapshot := len(q.tableSourcesFrom)+ q.tableSourcesFrom = append(q.tableSourcesFrom, left...)+ defer func() { q.tableSourcesFrom = q.tableSourcesFrom[:tableSourcesSnapshot] }()+ }+ right, err := q.extractTableSource(j.Right)+ if err != nil {+ return nil, err+ }+ return append(left, right...), nil+}++func (q *omniQuerySpanExtractor) resolveTableRef(t *ast.TableRef) (base.TableSource, error) {+ ts, err := q.tsqlFindTableSchemaByParts(t.Server, t.Database, t.Schema, t.Object)+ if err != nil {+ return nil, err+ }+ if t.Alias != "" {+ ts = &base.PseudoTable{+ Name: normIdent(t.Alias),+ Columns: ts.GetQuerySpanResult(),+ }+ }+ return ts, nil+}++func (q *omniQuerySpanExtractor) resolveAliasedTableRef(at *ast.AliasedTableRef) (base.TableSource, error) {+ var columnAliases []string+ if at.Columns != nil {+ for _, it := range at.Columns.Items {+ if s, ok := it.(*ast.String); ok {+ columnAliases = append(columnAliases, s.Str)+ }+ }+ }+ switch inner := at.Table.(type) {+ case *ast.TableRef:+ ts, err := q.tsqlFindTableSchemaByParts(inner.Server, inner.Database, inner.Schema, inner.Object)+ if err != nil {+ return nil, err+ }+ cols := append([]base.QuerySpanResult{}, ts.GetQuerySpanResult()...)+ if err := applyColumnAliases(cols, columnAliases); err != nil {+ return nil, err+ }+ name := inner.Object+ if at.Alias != "" {+ name = at.Alias+ }+ return &base.PseudoTable{Name: name, Columns: cols}, nil+ case *ast.SubqueryExpr:+ return q.resolveSubqueryAsTable(inner, at.Alias, columnAliases...)+ case *ast.ValuesClause:+ return q.resolveValuesClause(inner, at.Alias, columnAliases)+ case *ast.TableVarRef:+ inners, err := q.resolveTableVar(inner, at.Alias)+ if err != nil {+ return nil, err+ }+ if len(inners) == 1 {+ return inners[0], nil+ }+ return nil, unsupportedNodeError("aliased table variable must produce a single table source", at.Table)+ case *ast.FuncCallExpr:+ return q.resolveTableValuedFunction(inner, at.Alias, columnAliases)+ case *ast.TableVarMethodCallRef:+ cols := xmlNodesColumns(inner.Columns)+ if err := applyColumnAliases(cols, columnAliases); err != nil {+ return nil, err+ }+ return &base.PseudoTable{Name: normIdent(at.Alias), Columns: cols}, nil+ default:+ return nil, unsupportedNodeError("unsupported aliased table source item", at.Table)+ }+}++func (q *omniQuerySpanExtractor) resolveTableValuedFunction(fn *ast.FuncCallExpr, alias string, columnAliases []string) (base.TableSource, error) {+ if fn == nil || fn.Name == nil {+ return nil, unsupportedTableSourceError(fn)+ }+ var columnNames []string+ switch strings.ToUpper(fn.Name.Object) {+ case "STRING_SPLIT":+ columnNames = []string{"value"}+ hasOrdinal, err := stringSplitHasOrdinalColumn(fn.Args)+ if err != nil {+ return nil, err+ }+ if hasOrdinal {+ columnNames = append(columnNames, "ordinal")+ }+ case "OPENJSON":+ columnNames = []string{"key", "value", "type"}+ default:+ return nil, unsupportedTableSourceError(fn)+ }++ argSources, err := q.mergeListSources(fn.Args)+ if err != nil {+ return nil, err+ }+ columns := make([]base.QuerySpanResult, 0, len(columnNames))+ for _, name := range columnNames {+ columns = append(columns, base.QuerySpanResult{+ Name: name,+ SourceColumns: argSources.SourceColumns,+ })+ }+ if strings.EqualFold(fn.Name.Object, "STRING_SPLIT") && len(columns) > 1 {+ columns[1].SourceColumns = make(base.SourceColumnSet)+ }+ if err := applyColumnAliases(columns, columnAliases); err != nil {+ return nil, err+ }+ return &base.PseudoTable{Name: normIdent(alias), Columns: columns}, nil+}++func stringSplitHasOrdinalColumn(args *ast.List) (bool, error) {+ if args == nil || args.Len() < 3 {+ return false, nil+ }+ arg := args.Items[2]+ for {+ paren, ok := arg.(*ast.ParenExpr)+ if !ok {+ break+ }+ arg = paren.Expr+ }+ literal, ok := arg.(*ast.Literal)+ if !ok {+ return false, unsupportedNodeError("STRING_SPLIT enable_ordinal must be a constant 0, 1, or NULL", arg)+ }+ switch literal.Type {+ case ast.LitInteger:+ switch literal.Ival {+ case 0:+ return false, nil+ case 1:+ return true, nil+ default:+ return false, unsupportedNodeError("STRING_SPLIT enable_ordinal must be 0 or 1", arg)+ }+ case ast.LitNull:+ return false, nil+ default:+ return false, unsupportedNodeError("STRING_SPLIT enable_ordinal must be a constant 0, 1, or NULL", arg)+ }+}++func (q *omniQuerySpanExtractor) resolveSubqueryAsTable(sq *ast.SubqueryExpr, alias string, columnAliases ...string) (base.TableSource, error) {+ body, ok := sq.Query.(*ast.SelectStmt)+ if !ok {+ return nil, unsupportedNodeError("only SELECT subqueries in table source are supported", sq.Query)+ }+ clone := q.cloneForSubquery()+ pseudo, err := clone.extractFromSelectStmt(body)+ if err != nil {+ return nil, err+ }+ cols := append([]base.QuerySpanResult{}, pseudo.GetQuerySpanResult()...)+ if err := applyColumnAliases(cols, columnAliases); err != nil {+ return nil, err+ }+ q.predicateColumns, _ = base.MergeSourceColumnSet(q.predicateColumns, clone.predicateColumns)+ return &base.PseudoTable{Name: normIdent(alias), Columns: cols}, nil+}++func (q *omniQuerySpanExtractor) resolveValuesClause(vc *ast.ValuesClause, alias string, columnAliases []string) (base.TableSource, error) {+ name := normIdent(alias)+ if vc.Rows == nil || vc.Rows.Len() == 0 {+ return &base.PseudoTable{Name: name}, nil+ }+ firstRow, ok := vc.Rows.Items[0].(*ast.List)+ if !ok {+ return &base.PseudoTable{Name: name}, nil+ }+ cols := make([]base.QuerySpanResult, 0, firstRow.Len())+ for rowIndex, item := range vc.Rows.Items {+ row, ok := item.(*ast.List)+ if !ok {+ continue+ }+ if row.Len() != firstRow.Len() {+ return nil, errors.Errorf("VALUES row %d has %d columns, first row has %d", rowIndex+1, row.Len(), firstRow.Len())+ }+ for i, it := range row.Items {+ expr, ok := it.(ast.ExprNode)+ if !ok {+ if rowIndex == 0 {+ cols = append(cols, base.QuerySpanResult{})+ }+ continue+ }+ r, err := q.resolveExpression(expr)+ if err != nil {+ return nil, err+ }+ if rowIndex == 0 {+ cols = append(cols, r)+ continue+ }+ cols[i].SourceColumns, _ = base.MergeSourceColumnSet(cols[i].SourceColumns, r.SourceColumns)+ }+ }+ if err := applyColumnAliases(cols, columnAliases); err != nil {+ return nil, err+ }+ return &base.PseudoTable{Name: name, Columns: cols}, nil+}++func (q *omniQuerySpanExtractor) resolveTableVar(tv *ast.TableVarRef, alias string) ([]base.TableSource, error) {+ if tv == nil {+ return nil, nil+ }+ name := tv.Name+ if temp, ok := q.findTempTable(name); ok {+ tableName := name+ if alias != "" {+ tableName = alias+ }+ cols := make([]base.QuerySpanResult, 0, len(temp.Columns))+ for _, c := range temp.Columns {+ cols = append(cols, base.QuerySpanResult{+ Name: c,+ SourceColumns: base.SourceColumnSet{+ base.ColumnResource{+ Server: temp.Server,+ Database: temp.Database,+ Schema: temp.Schema,+ Table: temp.Name,+ Column: c,+ }: true,+ },+ IsPlainField: true,+ })+ }+ return []base.TableSource{&base.PseudoTable{Name: tableName, Columns: cols}}, nil+ }+ return nil, &base.ResourceNotFoundError{+ Table: &name,+ Err: errors.Errorf("temp table %s not found", name),+ }+}++// populateOmniTempTables mirrors the ANTLR tempTableColumnDefinitionListener:+// for each VariableDecl of table type, build a PhysicalTable keyed by the+// variable name (including the leading '@') and store it in the shared map.+func populateOmniTempTables(d *ast.DeclareStmt, out map[string]*base.PhysicalTable) {+ if d == nil || d.Variables == nil || out == nil {+ return+ }+ for _, it := range d.Variables.Items {+ v, ok := it.(*ast.VariableDecl)+ if !ok || !v.IsTable || v.TableDef == nil {+ continue+ }+ columns := make([]string, 0, v.TableDef.Len())+ for _, cdef := range v.TableDef.Items {+ if cd, ok := cdef.(*ast.ColumnDef); ok {+ columns = append(columns, cd.Name)+ }+ }+ out[v.Name] = &base.PhysicalTable{+ Name: v.Name,+ Columns: columns,+ }+ }+}++func populateOmniCreateTempTable(c *ast.CreateTableStmt, out map[string]*base.PhysicalTable) {+ if c == nil || c.Name == nil || out == nil || !strings.HasPrefix(c.Name.Object, "#") {+ return+ }+ var columns []string+ if c.Columns != nil {+ columns = make([]string, 0, c.Columns.Len())+ for _, item := range c.Columns.Items {+ if cd, ok := item.(*ast.ColumnDef); ok {+ columns = append(columns, cd.Name)+ }+ }+ }+ out[c.Name.Object] = &base.PhysicalTable{+ Name: c.Name.Object,+ Columns: columns,+ }+}++func (q *omniQuerySpanExtractor) populateSelectIntoTempTable(sel *ast.SelectStmt, results []base.QuerySpanResult) {+ if sel == nil || sel.IntoTable == nil || q.gCtx.TempTables == nil || !strings.HasPrefix(sel.IntoTable.Object, "#") {+ return+ }+ columns := make([]string, 0, len(results))+ for i, result := range results {+ name := result.Name+ if name == "" && sel.TargetList != nil && i < len(sel.TargetList.Items) {+ name = q.sliceName(sel.TargetList.Items[i])+ }+ columns = append(columns, name)+ }+ q.gCtx.TempTables[sel.IntoTable.Object] = &base.PhysicalTable{+ Name: sel.IntoTable.Object,+ Columns: columns,+ }+}++func xmlNodesColumns(cols []string) []base.QuerySpanResult {+ out := make([]base.QuerySpanResult, 0, len(cols))+ for _, c := range cols {+ out = append(out, base.QuerySpanResult{Name: c})+ }+ return out+}++func applyColumnAliases(cols []base.QuerySpanResult, aliases []string) error {+ if len(aliases) == 0 {+ return nil+ }+ if len(aliases) != len(cols) {+ return errors.Errorf("column alias count %d does not match column count %d", len(aliases), len(cols))+ }+ for i, name := range aliases {+ cols[i].Name = normIdent(name)+ }+ return nil+}++func (q *omniQuerySpanExtractor) cloneForSubquery() *omniQuerySpanExtractor {+ clone := &omniQuerySpanExtractor{+ querySpanExtractor: &querySpanExtractor{+ ctx: q.ctx,+ defaultDatabase: q.defaultDatabase,+ defaultSchema: q.defaultSchema,+ ignoreCaseSensitive: q.ignoreCaseSensitive,+ gCtx: q.gCtx,+ ctes: append([]*base.PseudoTable{}, q.ctes...),+ outerTableSources: append(append([]base.TableSource{}, q.outerTableSources...), q.tableSourcesFrom...),+ predicateColumns: make(base.SourceColumnSet),+ viewResolutionStack: cloneViewResolutionStack(q.viewResolutionStack),+ },+ source: q.source,+ }+ return clone+}++// -------------------- Target list --------------------++func (q *omniQuerySpanExtractor) extractTargetList(list *ast.List) ([]base.QuerySpanResult, error) {+ if list == nil {+ return nil, nil+ }+ var results []base.QuerySpanResult+ for _, item := range list.Items {+ switch v := item.(type) {+ case *ast.ResTarget:+ if star, ok := v.Val.(*ast.StarExpr); ok {+ fields, err := q.expandStar(star)+ if err != nil {+ return nil, err+ }+ results = append(results, fields...)+ continue+ }+ r, err := q.resolveExpression(v.Val)+ if err != nil {+ return nil, err+ }+ if v.Name != "" {+ r.Name = normIdent(v.Name)+ }+ results = append(results, r)+ case *ast.StarExpr:+ fields, err := q.expandStar(v)+ if err != nil {+ return nil, err+ }+ results = append(results, fields...)+ case *ast.SelectAssign:+ // SELECT @v = expr — no result column produced; just fold the expr+ // for predicate/source tracking (omitted here since it doesn't emit a column).+ continue+ default:+ if expr, ok := item.(ast.ExprNode); ok {+ r, err := q.resolveExpression(expr)+ if err != nil {+ return nil, err+ }+ results = append(results, r)+ continue+ }+ return nil, unsupportedNodeError("unsupported SELECT target item", item)+ }+ }+ return results, nil+}++func (q *omniQuerySpanExtractor) expandStar(s *ast.StarExpr) ([]base.QuerySpanResult, error) {+ if s.Qualifier == "" {+ var out []base.QuerySpanResult+ for _, ts := range q.tableSourcesFrom {+ out = append(out, ts.GetQuerySpanResult()...)+ }+ return out, nil+ }+ return q.tsqlGetAllFieldsOfTableInFromOrOuterCTE("", "", s.Qualifier)+}++// -------------------- Expression resolver --------------------++// resolveExpression maps an omni ExprNode to a QuerySpanResult. This is the+// omni equivalent of the ANTLR getQuerySpanResultFromExpr.+func (q *omniQuerySpanExtractor) resolveExpression(expr ast.ExprNode) (base.QuerySpanResult, error) {+ return q.resolveExpressionNode(expr)+}++func (q *omniQuerySpanExtractor) resolveExpressionNode(n ast.Node) (base.QuerySpanResult, error) {+ if n == nil {+ return base.QuerySpanResult{SourceColumns: make(base.SourceColumnSet)}, nil+ }+ if r, handled, err := q.resolveSimpleExpressionNode(n); handled {+ return r, err+ }+ switch v := n.(type) {+ case *ast.ColumnRef:+ if r, handled, err := q.resolvePseudoColumnRef(v); handled {+ if err != nil {+ return base.QuerySpanResult{}, errors.Wrapf(err, "failed to resolve column %q", v.Column)+ }+ return r, nil+ }+ r, err := q.tsqlIsFieldSensitive(v.Database, v.Schema, v.Table, v.Column)+ if err != nil {+ return base.QuerySpanResult{}, errors.Wrapf(err, "failed to resolve column %q", v.Column)+ }+ r.IsPlainField = true+ return r, nil+ case *ast.AtTimeZoneExpr:+ r, err := q.mergeExprSources(v.Expr, v.TimeZone)+ r.Name = q.sliceName(n)+ return r, err+ case *ast.BinaryExpr:+ r, err := q.mergeExprSources(v.Left, v.Right)+ r.Name = q.sliceName(n)+ return r, err+ case *ast.UnaryExpr:+ r, err := q.resolveExpressionNode(v.Operand)+ if err != nil {+ return r, err+ }+ r.Name = q.sliceName(n)+ r.IsPlainField = false+ return r, nil+ case *ast.BetweenExpr:+ r, err := q.mergeExprSources(v.Expr, v.Low, v.High)+ r.Name = q.sliceName(n)+ return r, err+ case *ast.LikeExpr:+ r, err := q.mergeExprSources(v.Expr, v.Pattern, v.Escape)+ r.Name = q.sliceName(n)+ return r, err+ case *ast.IsExpr:+ r, err := q.resolveExpressionNode(v.Expr)+ if err != nil {+ return r, err+ }+ r.Name = q.sliceName(n)+ r.IsPlainField = false+ return r, nil+ case *ast.InExpr:+ exprs := []ast.ExprNode{v.Expr}+ if v.List != nil {+ for _, it := range v.List.Items {+ if e, ok := it.(ast.ExprNode); ok {+ exprs = append(exprs, e)+ }+ }+ }+ if v.Subquery != nil {+ exprs = append(exprs, v.Subquery)+ }+ r, err := q.mergeExprSources(exprs...)+ r.Name = q.sliceName(n)+ return r, err+ case *ast.CaseExpr:+ exprs := []ast.ExprNode{v.Arg, v.ElseExpr}+ if v.WhenList != nil {+ for _, it := range v.WhenList.Items {+ if cw, ok := it.(*ast.CaseWhen); ok {+ exprs = append(exprs, cw.Condition, cw.Result)+ }+ }+ }+ r, err := q.mergeExprSources(exprs...)+ r.Name = q.sliceName(n)+ return r, err+ case *ast.IifExpr:+ r, err := q.mergeExprSources(v.Condition, v.TrueVal, v.FalseVal)+ r.Name = q.sliceName(n)+ return r, err+ case *ast.CoalesceExpr:+ r, err := q.mergeListSources(v.Args)+ r.Name = q.sliceName(n)+ return r, err+ case *ast.NullifExpr:+ r, err := q.mergeExprSources(v.Left, v.Right)+ r.Name = q.sliceName(n)+ return r, err+ case *ast.FuncCallExpr:+ r, err := q.mergeListSources(v.Args)+ if err != nil {+ return r, err+ }+ // Also merge Over clause partition/order.+ if v.Over != nil {+ sub, err := q.mergeListSources(v.Over.PartitionBy)+ if err != nil {+ return r, err+ }+ r.SourceColumns, _ = base.MergeSourceColumnSet(r.SourceColumns, sub.SourceColumns)+ sub, err = q.mergeOrderBySources(v.Over.OrderBy)+ if err != nil {+ return r, err+ }+ r.SourceColumns, _ = base.MergeSourceColumnSet(r.SourceColumns, sub.SourceColumns)+ }+ if v.Within != nil {+ sub, err := q.mergeOrderBySources(v.Within)+ if err != nil {+ return r, err+ }+ r.SourceColumns, _ = base.MergeSourceColumnSet(r.SourceColumns, sub.SourceColumns)+ }+ r.Name = q.sliceName(n)+ return r, nil+ case *ast.MethodCallExpr:+ r, err := q.mergeListSources(v.Args)+ r.Name = q.sliceName(n)+ return r, err+ case *ast.CastExpr:+ r, err := q.resolveExpressionNode(v.Expr)+ if err != nil {+ return r, err+ }+ r.Name = q.sliceName(n)+ r.IsPlainField = false+ return r, nil+ case *ast.ConvertExpr:+ r, err := q.mergeExprSources(v.Expr, v.Style)+ r.Name = q.sliceName(n)+ return r, err+ case *ast.TryCastExpr:+ r, err := q.resolveExpressionNode(v.Expr)+ if err != nil {+ return r, err+ }+ r.Name = q.sliceName(n)+ r.IsPlainField = false+ return r, nil+ case *ast.TryConvertExpr:+ r, err := q.mergeExprSources(v.Expr, v.Style)+ r.Name = q.sliceName(n)+ return r, err+ case *ast.SubqueryExpr:+ return q.resolveSubqueryExpr(v)+ case *ast.SubqueryComparisonExpr:+ r, err := q.resolveExpressionNode(v.Left)+ if err != nil {+ return r, err+ }+ if body, ok := v.Subquery.(*ast.SelectStmt); ok {+ clone := q.cloneForSubquery()+ sub, subErr := clone.extractFromSelectStmt(body)+ if subErr != nil {+ return r, subErr+ }+ for _, sc := range sub.GetQuerySpanResult() {+ r.SourceColumns, _ = base.MergeSourceColumnSet(r.SourceColumns, sc.SourceColumns)+ }+ q.predicateColumns, _ = base.MergeSourceColumnSet(q.predicateColumns, clone.predicateColumns)+ }+ r.Name = q.sliceName(n)+ r.IsPlainField = false+ return r, nil+ case *ast.ExistsExpr:+ r := base.QuerySpanResult{+ Name: q.sliceName(n),+ SourceColumns: make(base.SourceColumnSet),+ }+ if body, ok := v.Subquery.(*ast.SelectStmt); ok {+ clone := q.cloneForSubquery()+ if _, err := clone.extractFromSelectStmt(body); err != nil {+ return r, err+ }+ q.predicateColumns, _ = base.MergeSourceColumnSet(q.predicateColumns, clone.predicateColumns)+ }+ return r, nil+ case *ast.FullTextPredicate:+ r := base.QuerySpanResult{SourceColumns: make(base.SourceColumnSet)}+ if v.Columns != nil {+ for _, it := range v.Columns.Items {+ if cr, ok := it.(*ast.ColumnRef); ok {+ sub, err := q.tsqlIsFieldSensitive(cr.Database, cr.Schema, cr.Table, cr.Column)+ if err != nil {+ return r, errors.Wrapf(err, "failed to resolve full-text predicate column %q", cr.Column)+ }+ r.SourceColumns, _ = base.MergeSourceColumnSet(r.SourceColumns, sub.SourceColumns)+ }+ }+ }+ if v.Value != nil {+ sub, err := q.resolveExpressionNode(v.Value)+ if err != nil {+ return r, err+ }+ r.SourceColumns, _ = base.MergeSourceColumnSet(r.SourceColumns, sub.SourceColumns)+ }+ r.Name = q.sliceName(n)+ return r, nil+ case *ast.StarExpr:+ // Star in scalar context: treat as empty (already handled at target-list level).+ return base.QuerySpanResult{Name: q.sliceName(n), SourceColumns: make(base.SourceColumnSet)}, nil+ case *ast.GroupingSetsExpr, *ast.RollupExpr, *ast.CubeExpr:+ // Appear in GROUP BY; not typical targets. Fallback to empty.+ return base.QuerySpanResult{Name: q.sliceName(n), SourceColumns: make(base.SourceColumnSet)}, nil+ case *ast.ResTarget:+ r, err := q.resolveExpressionNode(v.Val)+ if err != nil {+ return r, err+ }+ if v.Name != "" {+ r.Name = v.Name+ }+ return r, nil+ case *ast.SelectAssign:+ return q.resolveExpressionNode(v.Value)+ case *ast.CaseWhen:+ return q.mergeExprSources(v.Condition, v.Result)+ case *ast.CurrentOfExpr:+ return base.QuerySpanResult{Name: q.sliceName(n), SourceColumns: make(base.SourceColumnSet)}, nil+ default:+ return base.QuerySpanResult{Name: q.sliceName(n), SourceColumns: make(base.SourceColumnSet)}, nil+ }+}++func (q *omniQuerySpanExtractor) resolveSimpleExpressionNode(n ast.Node) (base.QuerySpanResult, bool, error) {+ switch v := n.(type) {+ case *ast.Literal, *ast.VariableRef, *ast.Boolean:+ return base.QuerySpanResult{Name: q.sliceName(v), SourceColumns: make(base.SourceColumnSet)}, true, nil+ case *ast.ParenExpr:+ r, err := q.resolveExpressionNode(v.Expr)+ return r, true, err+ case *ast.CollateExpr:+ r, err := q.resolveExpressionNode(v.Expr)+ return r, true, err+ default:+ return base.QuerySpanResult{}, false, nil+ }+}++func (q *omniQuerySpanExtractor) resolveSubqueryExpr(sq *ast.SubqueryExpr) (base.QuerySpanResult, error) {+ r := base.QuerySpanResult{+ Name: q.sliceName(sq),+ SourceColumns: make(base.SourceColumnSet),+ }+ body, ok := sq.Query.(*ast.SelectStmt)+ if !ok {+ return r, nil+ }+ clone := q.cloneForSubquery()+ pseudo, err := clone.extractFromSelectStmt(body)+ if err != nil {+ return r, err+ }+ // Scalar subquery contributes its first result column's source columns.+ results := pseudo.GetQuerySpanResult()+ for _, c := range results {+ r.SourceColumns, _ = base.MergeSourceColumnSet(r.SourceColumns, c.SourceColumns)+ }+ q.predicateColumns, _ = base.MergeSourceColumnSet(q.predicateColumns, clone.predicateColumns)+ return r, nil+}++func (q *omniQuerySpanExtractor) mergeExprSources(exprs ...ast.ExprNode) (base.QuerySpanResult, error) {+ r := base.QuerySpanResult{SourceColumns: make(base.SourceColumnSet)}+ for _, e := range exprs {+ if e == nil {+ continue+ }+ sub, err := q.resolveExpressionNode(e)+ if err != nil {+ return r, err+ }+ r.SourceColumns, _ = base.MergeSourceColumnSet(r.SourceColumns, sub.SourceColumns)+ }+ return r, nil+}++func (q *omniQuerySpanExtractor) mergeListSources(list *ast.List) (base.QuerySpanResult, error) {+ r := base.QuerySpanResult{SourceColumns: make(base.SourceColumnSet)}+ if list == nil {+ return r, nil+ }+ for _, it := range list.Items {+ if e, ok := it.(ast.ExprNode); ok {+ sub, err := q.resolveExpressionNode(e)+ if err != nil {+ return r, err+ }+ r.SourceColumns, _ = base.MergeSourceColumnSet(r.SourceColumns, sub.SourceColumns)+ }+ }+ return r, nil+}++func (q *omniQuerySpanExtractor) mergeOrderBySources(list *ast.List) (base.QuerySpanResult, error) {+ r := base.QuerySpanResult{SourceColumns: make(base.SourceColumnSet)}+ if list == nil {+ return r, nil+ }+ for _, it := range list.Items {+ var expr ast.Node+ switch v := it.(type) {+ case *ast.OrderByItem:+ expr = v.Expr+ case ast.ExprNode:+ expr = v+ default:+ return r, unsupportedNodeError("unsupported ORDER BY item", it)+ }+ sub, err := q.resolveExpressionNode(expr)+ if err != nil {+ return r, err+ }+ r.SourceColumns, _ = base.MergeSourceColumnSet(r.SourceColumns, sub.SourceColumns)+ }+ return r, nil+}++// -------------------- Helpers --------------------++// sliceName returns the whitespace-stripped source text covering a node's Loc.+// Mirrors ANTLR's ctx.GetText() convention for naming expression results.+// For *SubqueryExpr (and similar paren-wrapped nodes) the Loc spans the+// surrounding parens; we strip a matching leading `(` / trailing `)` pair to+// match the ANTLR subquery.getText() output.+func (q *omniQuerySpanExtractor) sliceName(n ast.Node) string {+ loc := omniNodeLoc(n)+ if loc.Start < 0 || loc.End < 0 || loc.Start >= len(q.source) {+ return ""+ }+ end := loc.End+ if end > len(q.source) {+ end = len(q.source)+ }+ text := stripSpaces(q.source[loc.Start:end])+ switch n.(type) {+ case *ast.SubqueryExpr, *ast.ExistsExpr, *ast.SubqueryComparisonExpr:+ if len(text) >= 2 && text[0] == '(' && text[len(text)-1] == ')' {+ text = text[1 : len(text)-1]+ }+ default:+ }+ return text+}++func stripSpaces(s string) string {+ var b strings.Builder+ b.Grow(len(s))+ for _, r := range s {+ if !unicode.IsSpace(r) {+ b.WriteRune(r)+ }+ }+ return b.String()+}++// normIdent lowercases a SQL-text-sourced identifier (table alias, column+// alias, CTE name, ResTarget name). Matches the legacy ANTLR+// NormalizeTSQLIdentifier behavior which lowercases unconditionally. Does not+// apply to identifiers sourced from metadata (physical table/column names);+// those are compared case-insensitively but stored as-is.+func normIdent(s string) string {+ return strings.ToLower(s)+}++// omniNodeLoc extracts the Loc field from an ast.Node via type switching.+// Not every node has a Loc (the Node interface doesn't expose it), so we+// enumerate the types we care about. Returns zero Loc otherwise.+func omniNodeLoc(n ast.Node) ast.Loc {+ if n == nil {+ return ast.NoLoc()+ }+ if loc, ok := omniExpressionNodeLoc(n); ok {+ return loc+ }+ switch v := n.(type) {+ case *ast.SelectStmt:+ return v.Loc+ case *ast.TableRef:+ return v.Loc+ case *ast.ResTarget:+ return v.Loc+ case *ast.SelectAssign:+ return v.Loc+ default:+ return ast.NoLoc()+ }+}++func omniExpressionNodeLoc(n ast.Node) (ast.Loc, bool) {+ switch v := n.(type) {+ case *ast.ColumnRef:+ return v.Loc, true+ case *ast.Literal:+ return v.Loc, true+ case *ast.VariableRef:+ return v.Loc, true+ case *ast.StarExpr:+ return v.Loc, true+ case *ast.BinaryExpr:+ return v.Loc, true+ case *ast.UnaryExpr:+ return v.Loc, true+ case *ast.BetweenExpr:+ return v.Loc, true+ case *ast.LikeExpr:+ return v.Loc, true+ case *ast.IsExpr:+ return v.Loc, true+ case *ast.InExpr:+ return v.Loc, true+ case *ast.CaseExpr:+ return v.Loc, true+ case *ast.CaseWhen:+ return v.Loc, true+ case *ast.IifExpr:+ return v.Loc, true+ case *ast.CoalesceExpr:+ return v.Loc, true+ case *ast.NullifExpr:+ return v.Loc, true+ case *ast.FuncCallExpr:+ return v.Loc, true+ case *ast.MethodCallExpr:+ return v.Loc, true+ case *ast.CastExpr:+ return v.Loc, true+ case *ast.ConvertExpr:+ return v.Loc, true+ case *ast.TryCastExpr:+ return v.Loc, true+ case *ast.TryConvertExpr:+ return v.Loc, true+ case *ast.SubqueryExpr:+ return v.Loc, true+ case *ast.SubqueryComparisonExpr:+ return v.Loc, true+ case *ast.ExistsExpr:+ return v.Loc, true+ case *ast.FullTextPredicate:+ return v.Loc, true+ case *ast.ParenExpr:+ return v.Loc, true+ case *ast.CollateExpr:+ return v.Loc, true+ case *ast.AtTimeZoneExpr:+ return v.Loc, true+ default:+ return ast.NoLoc(), false+ }+}++// -------------------- Access tables --------------------++// collectOmniAccessTables walks the AST and records every table-source+// position reference. Mirrors the ANTLR accessTableListener.+func collectOmniAccessTables(root ast.Node, currentDatabase, currentSchema string) base.SourceColumnSet {+ out := make(base.SourceColumnSet)+ walkAccessTables(root, currentDatabase, currentSchema, out)+ return out+}++func walkAccessTables(n ast.Node, db, schema string, out base.SourceColumnSet) {+ if n == nil {+ return+ }+ switch v := n.(type) {+ case *ast.SelectStmt:+ if v.WithClause != nil {+ walkAccessTables(v.WithClause, db, schema, out)+ }+ if v.FromClause != nil {+ for _, it := range v.FromClause.Items {+ walkAccessTables(it, db, schema, out)+ }+ }+ if v.WhereClause != nil {+ walkAccessTables(v.WhereClause, db, schema, out)+ }+ if v.HavingClause != nil {+ walkAccessTables(v.HavingClause, db, schema, out)+ }+ if v.TargetList != nil {+ for _, it := range v.TargetList.Items {+ walkAccessTables(it, db, schema, out)+ }+ }+ if v.Larg != nil {+ walkAccessTables(v.Larg, db, schema, out)+ }+ if v.Rarg != nil {+ walkAccessTables(v.Rarg, db, schema, out)+ }+ case *ast.WithClause:+ if v.CTEs != nil {+ for _, it := range v.CTEs.Items {+ if c, ok := it.(*ast.CommonTableExpr); ok {+ walkAccessTables(c.Query, db, schema, out)+ }+ }+ }+ case *ast.TableRef:+ addAccessTable(v, db, schema, out)+ case *ast.AliasedTableRef:+ walkAccessTables(v.Table, db, schema, out)+ case *ast.JoinClause:+ walkAccessTables(v.Left, db, schema, out)+ walkAccessTables(v.Right, db, schema, out)+ if v.Condition != nil {+ walkAccessTables(v.Condition, db, schema, out)+ }+ case *ast.SubqueryExpr:+ walkAccessTables(v.Query, db, schema, out)+ case *ast.PivotExpr:+ walkAccessTables(v.Source, db, schema, out)+ case *ast.UnpivotExpr:+ walkAccessTables(v.Source, db, schema, out)+ case *ast.ExistsExpr:+ walkAccessTables(v.Subquery, db, schema, out)+ case *ast.SubqueryComparisonExpr:+ walkAccessTables(v.Left, db, schema, out)+ walkAccessTables(v.Subquery, db, schema, out)+ case *ast.InExpr:+ walkAccessTables(v.Expr, db, schema, out)+ if v.List != nil {+ for _, it := range v.List.Items {+ walkAccessTables(it, db, schema, out)+ }+ }+ walkAccessTables(v.Subquery, db, schema, out)+ case *ast.BinaryExpr:+ walkAccessTables(v.Left, db, schema, out)+ walkAccessTables(v.Right, db, schema, out)+ case *ast.UnaryExpr:+ walkAccessTables(v.Operand, db, schema, out)+ case *ast.BetweenExpr:+ walkAccessTables(v.Expr, db, schema, out)+ walkAccessTables(v.Low, db, schema, out)+ walkAccessTables(v.High, db, schema, out)+ case *ast.LikeExpr:+ walkAccessTables(v.Expr, db, schema, out)+ walkAccessTables(v.Pattern, db, schema, out)+ case *ast.IsExpr:+ walkAccessTables(v.Expr, db, schema, out)+ case *ast.CaseExpr:+ walkAccessTables(v.Arg, db, schema, out)+ walkAccessTables(v.ElseExpr, db, schema, out)+ if v.WhenList != nil {+ for _, it := range v.WhenList.Items {+ walkAccessTables(it, db, schema, out)+ }+ }+ case *ast.CaseWhen:+ walkAccessTables(v.Condition, db, schema, out)+ walkAccessTables(v.Result, db, schema, out)+ case *ast.ParenExpr:+ walkAccessTables(v.Expr, db, schema, out)+ case *ast.CastExpr:+ walkAccessTables(v.Expr, db, schema, out)+ case *ast.ConvertExpr:+ walkAccessTables(v.Expr, db, schema, out)+ case *ast.TryCastExpr:+ walkAccessTables(v.Expr, db, schema, out)+ case *ast.TryConvertExpr:+ walkAccessTables(v.Expr, db, schema, out)+ case *ast.FuncCallExpr:+ if v.Args != nil {+ for _, it := range v.Args.Items {+ walkAccessTables(it, db, schema, out)+ }+ }+ case *ast.ResTarget:+ walkAccessTables(v.Val, db, schema, out)+ case *ast.ValuesClause:+ // No table access.+ case *ast.TableVarRef, *ast.TableVarMethodCallRef:+ // Temp-table var: no physical access.+ default:+ }+}++func addAccessTable(t *ast.TableRef, defDB, defSchema string, out base.SourceColumnSet) {+ if t == nil || strings.HasPrefix(t.Object, "#") {+ return+ }+ database := defDB+ if t.Database != "" {+ database = t.Database+ }+ schema := defSchema+ if t.Schema != "" {+ schema = t.Schema+ }+ out[base.ColumnResource{+ Server: t.Server,+ Database: database,+ Schema: schema,+ Table: t.Object,+ }] = true+}diff --git a/backend/plugin/parser/tsql/query_span_extractor_omni.go b/backend/plugin/parser/tsql/query_span_extractor_omni.godeleted file mode 100644index 0f75539b56..0000000000--- a/backend/plugin/parser/tsql/query_span_extractor_omni.go+++ /dev/null@@ -1,1606 +0,0 @@-package tsql--import (- "context"- "reflect"- "strings"- "unicode"-- "github.com/bytebase/omni/mssql/ast"- "github.com/pkg/errors"-- "github.com/bytebase/bytebase/backend/plugin/parser/base"-)--// omniQuerySpanExtractor extracts query span information from omni MSSQL AST.-// It embeds querySpanExtractor so string-based resolution helpers-// (tsqlIsFieldSensitive, tsqlFindTableSchemaByParts, isIdentifierEqual,-// tsqlGetAllFieldsOfTableInFromOrOuterCTE) are reused directly.-type omniQuerySpanExtractor struct {- *querySpanExtractor- // source is the original SQL text, used to slice expression names via Loc.- source string-}--func newOmniQuerySpanExtractor(defaultDatabase, defaultSchema string, gCtx base.GetQuerySpanContext, ignoreCaseSensitive bool) *omniQuerySpanExtractor {- return &omniQuerySpanExtractor{- querySpanExtractor: newQuerySpanExtractor(defaultDatabase, defaultSchema, gCtx, ignoreCaseSensitive),- }-}--// getOmniQuerySpan is the public entry point. Mirrors the ANTLR getQuerySpan flow.-func (q *omniQuerySpanExtractor) getOmniQuerySpan(ctx context.Context, statement string) (*base.QuerySpan, error) {- q.ctx = ctx- q.source = statement-- stmts, err := ParseTSQLOmni(statement)- if err != nil {- return nil, err- }- if len(stmts) == 0 {- return &base.QuerySpan{- Type: base.Select,- SourceColumns: make(base.SourceColumnSet),- Results: []base.QuerySpanResult{},- }, nil- }- if len(stmts) != 1 {- return nil, errors.Errorf("expected exactly 1 statement, got %d", len(stmts))- }-- root := stmts[0].AST- if root == nil {- // An empty statement. Match ANTLR's zero-AST behavior.- return &base.QuerySpan{- Type: base.Select,- SourceColumns: make(base.SourceColumnSet),- Results: []base.QuerySpanResult{},- }, nil- }- if _, isGo := root.(*ast.GoStmt); isGo {- // A bare "GO" batch separator. ANTLR discards it and returns an empty- // Select span; match that.- return &base.QuerySpan{- Type: base.Select,- SourceColumns: make(base.SourceColumnSet),- Results: []base.QuerySpanResult{},- }, nil- }-- // DECLARE @t TABLE(...) populates gCtx.TempTables so subsequent statements- // in the same session (the caller loops over split statements) can resolve- // @t. Mirrors the legacy ANTLR tsqlSelectOnlyListener.EnterDeclare_statement- // side-effect. Non-table DECLARE (plain scalar variables) is a no-op.- if d, ok := root.(*ast.DeclareStmt); ok {- populateOmniTempTables(d, q.gCtx.TempTables)- }- if c, ok := root.(*ast.CreateTableStmt); ok {- populateOmniCreateTempTable(c, q.gCtx.TempTables)- }-- accessTables := collectOmniAccessTables(root, q.defaultDatabase, q.defaultSchema)- allSystems, mixed := isMixedQuery(accessTables, q.ignoreCaseSensitive)- if mixed {- return nil, base.MixUserSystemTablesError- }-- queryType := classifyQueryType(root, allSystems)- sel, isSelect := root.(*ast.SelectStmt)- // classifyQueryType maps SET/DECLARE/SetOption to base.Select for historical- // reasons; those have no result columns. Return early if the root isn't a- // real SELECT.- if queryType != base.Select || !isSelect {- return &base.QuerySpan{- Type: queryType,- SourceColumns: base.SourceColumnSet{},- Results: []base.QuerySpanResult{},- }, nil- }-- pseudo, err := q.extractFromSelectStmt(sel)- if err != nil {- var resourceNotFound *base.ResourceNotFoundError- if errors.As(err, &resourceNotFound) {- return &base.QuerySpan{- Type: base.Select,- SourceColumns: accessTables,- Results: []base.QuerySpanResult{},- NotFoundError: resourceNotFound,- }, nil- }- return nil, err- }-- return &base.QuerySpan{- Type: base.Select,- SourceColumns: accessTables,- Results: pseudo.GetQuerySpanResult(),- PredicateColumns: q.predicateColumns,- }, nil-}--// -------------------- SELECT processing ----------------------// extractFromSelectStmt processes a full SELECT statement (including set-ops,-// WITH clause) and returns the result column set as a PseudoTable.-func (q *omniQuerySpanExtractor) extractFromSelectStmt(sel *ast.SelectStmt) (*base.PseudoTable, error) {- // WITH clause: populate CTE list BEFORE dispatching set-ops so that both- // arms of a `WITH cte AS (...) SELECT ... FROM cte UNION SELECT ... FROM cte`- // see the CTE in scope. The defer restores q.ctes on exit.- ctesSnapshot := len(q.ctes)- defer func() { q.ctes = q.ctes[:ctesSnapshot] }()- if sel.WithClause != nil {- if err := q.processWithClause(sel.WithClause); err != nil {- return nil, err- }- }-- // Set operations: recurse into arms and union. The WITH clause above is- // already in q.ctes, so both arms resolve CTE references correctly.- if sel.Op != ast.SetOpNone && (sel.Larg != nil || sel.Rarg != nil) {- return q.extractFromSetOp(sel)- }-- // FROM clause — a SELECT without FROM is legal (e.g. SELECT 1).- tableSourcesSnapshot := len(q.tableSourcesFrom)- defer func() { q.tableSourcesFrom = q.tableSourcesFrom[:tableSourcesSnapshot] }()- if sel.FromClause != nil {- for _, item := range sel.FromClause.Items {- ts, err := q.extractTableSource(item)- if err != nil {- return nil, err- }- q.tableSourcesFrom = append(q.tableSourcesFrom, ts...)- }- }-- // WHERE / HAVING predicate columns — resolved in THIS select's scope.- // Subquery expressions encountered during the walk get cloned extractors;- // their results merge back into q.predicateColumns. Errors (including- // ResourceNotFoundError from a subquery referencing a missing table)- // propagate up to getOmniQuerySpan which converts them into a span with- // NotFoundError populated.- if err := q.collectPredicatesInScope(sel.WhereClause); err != nil {- return nil, err- }- if err := q.collectPredicatesInScope(sel.HavingClause); err != nil {- return nil, err- }-- // Target list.- results, err := q.extractTargetList(sel.TargetList)- if err != nil {- return nil, err- }- q.populateSelectIntoTempTable(sel, results)-- return &base.PseudoTable{Columns: results}, nil-}--// collectPredicatesInScope walks a boolean expression in the extractor's-// current scope: plain ColumnRefs resolve against q.tableSourcesFrom +-// q.outerTableSources; subquery nodes trigger a scope clone, and the-// subquery's output-column sources plus its own predicate-column set merge-// back into q.predicateColumns.-//-// Errors from nested subquery extraction (ResourceNotFoundError or real-// parser errors) propagate so the caller can surface them via the top-level-// NotFoundError path instead of producing a silently-partial span.-func (q *omniQuerySpanExtractor) collectPredicatesInScope(expr ast.Node) error {- if expr == nil {- return nil- }- switch v := expr.(type) {- case *ast.ColumnRef:- if r, handled, err := q.resolvePseudoColumnRef(v); handled {- if err != nil {- return errors.Wrapf(err, "failed to resolve predicate column %q", v.Column)- }- q.predicateColumns, _ = base.MergeSourceColumnSet(q.predicateColumns, r.SourceColumns)- return nil- }- r, err := q.tsqlIsFieldSensitive(v.Database, v.Schema, v.Table, v.Column)- if err != nil {- return errors.Wrapf(err, "failed to resolve predicate column %q", v.Column)- }- q.predicateColumns, _ = base.MergeSourceColumnSet(q.predicateColumns, r.SourceColumns)- return nil- case *ast.FullTextPredicate:- if v.Columns != nil {- for _, it := range v.Columns.Items {- if cr, ok := it.(*ast.ColumnRef); ok {- if err := q.collectPredicatesInScope(cr); err != nil {- return err- }- }- }- }- if err := q.collectPredicatesInScope(v.Value); err != nil {- return err- }- return q.collectPredicatesInScope(v.LanguageTerm)- case *ast.SubqueryExpr:- return q.mergeSubqueryIntoPredicates(v.Query)- case *ast.ExistsExpr:- return q.mergeSubqueryIntoPredicates(v.Subquery)- case *ast.SubqueryComparisonExpr:- if err := q.collectPredicatesInScope(v.Left); err != nil {- return err- }- return q.mergeSubqueryIntoPredicates(v.Subquery)- case *ast.InExpr:- if err := q.collectPredicatesInScope(v.Expr); err != nil {- return err- }- if v.List != nil {- for _, it := range v.List.Items {- if err := q.collectPredicatesInScope(it); err != nil {- return err- }- }- }- return q.collectPredicatesInScope(v.Subquery)- case *ast.BinaryExpr:- if err := q.collectPredicatesInScope(v.Left); err != nil {- return err- }- return q.collectPredicatesInScope(v.Right)- case *ast.UnaryExpr:- return q.collectPredicatesInScope(v.Operand)- case *ast.BetweenExpr:- if err := q.collectPredicatesInScope(v.Expr); err != nil {- return err- }- if err := q.collectPredicatesInScope(v.Low); err != nil {- return err- }- return q.collectPredicatesInScope(v.High)- case *ast.LikeExpr:- if err := q.collectPredicatesInScope(v.Expr); err != nil {- return err- }- if err := q.collectPredicatesInScope(v.Pattern); err != nil {- return err- }- return q.collectPredicatesInScope(v.Escape)- case *ast.IsExpr:- return q.collectPredicatesInScope(v.Expr)- case *ast.CaseExpr:- if err := q.collectPredicatesInScope(v.Arg); err != nil {- return err- }- if err := q.collectPredicatesInScope(v.ElseExpr); err != nil {- return err- }- if v.WhenList != nil {- for _, it := range v.WhenList.Items {- if cw, ok := it.(*ast.CaseWhen); ok {- if err := q.collectPredicatesInScope(cw.Condition); err != nil {- return err- }- if err := q.collectPredicatesInScope(cw.Result); err != nil {- return err- }- }- }- }- return nil- case *ast.IifExpr:- if err := q.collectPredicatesInScope(v.Condition); err != nil {- return err- }- if err := q.collectPredicatesInScope(v.TrueVal); err != nil {- return err- }- return q.collectPredicatesInScope(v.FalseVal)- case *ast.CoalesceExpr:- if v.Args != nil {- for _, it := range v.Args.Items {- if err := q.collectPredicatesInScope(it); err != nil {- return err- }- }- }- return nil- case *ast.NullifExpr:- if err := q.collectPredicatesInScope(v.Left); err != nil {- return err- }- return q.collectPredicatesInScope(v.Right)- case *ast.FuncCallExpr:- if v.Args != nil {- for _, it := range v.Args.Items {- if err := q.collectPredicatesInScope(it); err != nil {- return err- }- }- }- return nil- case *ast.MethodCallExpr:- if v.Args != nil {- for _, it := range v.Args.Items {- if err := q.collectPredicatesInScope(it); err != nil {- return err- }- }- }- return nil- case *ast.CastExpr:- return q.collectPredicatesInScope(v.Expr)- case *ast.ConvertExpr:- if err := q.collectPredicatesInScope(v.Expr); err != nil {- return err- }- return q.collectPredicatesInScope(v.Style)- case *ast.TryCastExpr:- return q.collectPredicatesInScope(v.Expr)- case *ast.TryConvertExpr:- if err := q.collectPredicatesInScope(v.Expr); err != nil {- return err- }- return q.collectPredicatesInScope(v.Style)- case *ast.ParenExpr:- return q.collectPredicatesInScope(v.Expr)- case *ast.CollateExpr:- return q.collectPredicatesInScope(v.Expr)- case *ast.AtTimeZoneExpr:- if err := q.collectPredicatesInScope(v.Expr); err != nil {- return err- }- return q.collectPredicatesInScope(v.TimeZone)- default:- // Literal, VariableRef, StarExpr, etc. — nothing to collect.- return nil- }-}--func (q *omniQuerySpanExtractor) mergeSubqueryIntoPredicates(body ast.Node) error {- sel, ok := body.(*ast.SelectStmt)- if !ok {- return nil- }- clone := q.cloneForSubquery()- pseudo, err := clone.extractFromSelectStmt(sel)- if err != nil {- return err- }- // Subquery output columns become outer-scope predicate columns.- for _, c := range pseudo.GetQuerySpanResult() {- q.predicateColumns, _ = base.MergeSourceColumnSet(q.predicateColumns, c.SourceColumns)- }- // And the clone's own predicate columns (from its WHERE etc.) propagate up.- q.predicateColumns, _ = base.MergeSourceColumnSet(q.predicateColumns, clone.predicateColumns)- return nil-}--func (q *omniQuerySpanExtractor) extractFromSetOp(sel *ast.SelectStmt) (*base.PseudoTable, error) {- // Omni puts the WITH clause on the leftmost set-op arm (the parser attaches- // the WITH to the first SELECT expression, not to the outer Op node). Lift- // it into the current scope so the CTE is visible in BOTH arms, then- // recurse into a copy of Larg with WithClause cleared to avoid double- // processing.- larg := sel.Larg- if larg != nil && larg.WithClause != nil {- if err := q.processWithClause(larg.WithClause); err != nil {- return nil, err- }- cp := *larg- cp.WithClause = nil- larg = &cp- }- left, err := q.extractFromSelectStmt(larg)- if err != nil {- return nil, err- }- right, err := q.extractFromSelectStmt(sel.Rarg)- if err != nil {- return nil, err- }- merged, err := unionTableSources(left, right)- if err != nil {- return nil, err- }- return &base.PseudoTable{Columns: merged}, nil-}--func (q *omniQuerySpanExtractor) processWithClause(w *ast.WithClause) error {- if w.CTEs == nil {- return nil- }- for _, item := range w.CTEs.Items {- cte, ok := item.(*ast.CommonTableExpr)- if !ok {- continue- }- body, ok := cte.Query.(*ast.SelectStmt)- if !ok {- return unsupportedNodeError("only SELECT CTE bodies are supported", cte.Query)- }-- cteName := normIdent(cte.Name)- cols, predicates, err := q.extractCTEBody(cteName, body)- if err != nil {- return err- }- if cte.Columns != nil && cte.Columns.Len() > 0 {- if cte.Columns.Len() != len(cols) {- return errors.Errorf("CTE %q column alias count %d does not match body column count %d", cte.Name, cte.Columns.Len(), len(cols))- }- for i, it := range cte.Columns.Items {- if s, ok := it.(*ast.String); ok {- cols[i].Name = normIdent(s.Str)- }- }- }- q.ctes = append(q.ctes, &base.PseudoTable{Name: cteName, Columns: cols})- q.predicateColumns, _ = base.MergeSourceColumnSet(q.predicateColumns, predicates)- }- return nil-}--// extractCTEBody extracts the column set of a CTE body. For recursive CTEs-// (body is a set-op SelectStmt whose recursive arm references the CTE name),-// the extractor iterates until the column sources stabilize.-func (q *omniQuerySpanExtractor) extractCTEBody(cteName string, body *ast.SelectStmt) ([]base.QuerySpanResult, base.SourceColumnSet, error) {- newClone := func() *omniQuerySpanExtractor {- return &omniQuerySpanExtractor{- querySpanExtractor: &querySpanExtractor{- ctx: q.ctx,- defaultDatabase: q.defaultDatabase,- defaultSchema: q.defaultSchema,- ignoreCaseSensitive: q.ignoreCaseSensitive,- gCtx: q.gCtx,- ctes: append([]*base.PseudoTable{}, q.ctes...),- outerTableSources: nil,- predicateColumns: make(base.SourceColumnSet),- viewResolutionStack: cloneViewResolutionStack(q.viewResolutionStack),- },- source: q.source,- }- }-- // Non-set-op CTE: extract directly.- if body.Op == ast.SetOpNone || (body.Larg == nil && body.Rarg == nil) {- clone := newClone()- pseudo, err := clone.extractFromSelectStmt(body)- if err != nil {- return nil, nil, err- }- return pseudo.GetQuerySpanResult(), clone.predicateColumns, nil- }-- // Set-op CTE: extract anchor (Larg), register placeholder, then iterate Rarg- // until the source column sets for the CTE columns stabilize.- anchorClone := newClone()- anchorPseudo, err := anchorClone.extractFromSelectStmt(body.Larg)- if err != nil {- return nil, nil, err- }- cols := append([]base.QuerySpanResult{}, anchorPseudo.GetQuerySpanResult()...)- predicates := base.SourceColumnSet{}- predicates, _ = base.MergeSourceColumnSet(predicates, anchorClone.predicateColumns)-- for iter := 0; iter < 16; iter++ {- placeholder := &base.PseudoTable{Name: cteName, Columns: cols}- clone := newClone()- clone.ctes = append(clone.ctes, placeholder)- rarg, rerr := clone.extractFromSelectStmt(body.Rarg)- if rerr != nil {- // Recursive arm failed to resolve (e.g. ResourceNotFoundError from- // a missing table). Propagate — the top-level getOmniQuerySpan- // converts ResourceNotFoundError into a span with NotFoundError- // populated so callers don't see a silently-partial lineage.- return nil, nil, rerr- }- rcols := rarg.GetQuerySpanResult()- if len(rcols) != len(cols) {- return nil, nil, errors.Errorf("CTE %q recursive arm returns %d columns, anchor returns %d", cteName, len(rcols), len(cols))- }- changed := false- for i := range rcols {- merged, anyChange := base.MergeSourceColumnSet(cols[i].SourceColumns, rcols[i].SourceColumns)- cols[i].SourceColumns = merged- if anyChange {- changed = true- }- }- predicates, _ = base.MergeSourceColumnSet(predicates, clone.predicateColumns)- if !changed {- break- }- }- return cols, predicates, nil-}--// -------------------- FROM / table source ----------------------// extractTableSource returns the TableSource(s) produced by a single FROM item.-// A JoinClause contributes multiple sources (left + right flattened).-func (q *omniQuerySpanExtractor) extractTableSource(node ast.Node) ([]base.TableSource, error) {- switch v := node.(type) {- case *ast.JoinClause:- return q.extractFromJoin(v)- case *ast.TableRef:- ts, err := q.resolveTableRef(v)- if err != nil {- return nil, err- }- return []base.TableSource{ts}, nil- case *ast.AliasedTableRef:- ts, err := q.resolveAliasedTableRef(v)- if err != nil {- return nil, err- }- return []base.TableSource{ts}, nil- case *ast.SubqueryExpr:- ts, err := q.resolveSubqueryAsTable(v, "")- if err != nil {- return nil, err- }- return []base.TableSource{ts}, nil- case *ast.ValuesClause:- ts, err := q.resolveValuesClause(v, "", nil)- if err != nil {- return nil, err- }- return []base.TableSource{ts}, nil- case *ast.TableVarRef:- return q.resolveTableVar(v, v.Alias)- case *ast.TableVarMethodCallRef:- return []base.TableSource{&base.PseudoTable{Name: v.Alias, Columns: xmlNodesColumns(v.Columns)}}, nil- case *ast.PivotExpr:- return nil, unsupportedTableSourceError(node)- case *ast.UnpivotExpr:- return nil, unsupportedTableSourceError(node)- case *ast.FuncCallExpr:- ts, err := q.resolveTableValuedFunction(v, "", nil)- if err != nil {- return nil, err- }- return []base.TableSource{ts}, nil- default:- return nil, unsupportedTableSourceError(node)- }-}--func unsupportedTableSourceError(node ast.Node) error {- return unsupportedNodeError("only full table name, supported TVF, derived table, values clause, and temp table in table source item are supported", node)-}--func unsupportedNodeError(message string, node ast.Node) error {- typeName := "<nil>"- if typ := reflect.TypeOf(node); typ != nil {- typeName = typ.String()- }- return &base.TypeNotSupportedError{- Err: errors.New(message),- Type: typeName,- }-}--func (q *omniQuerySpanExtractor) extractFromJoin(j *ast.JoinClause) ([]base.TableSource, error) {- left, err := q.extractTableSource(j.Left)- if err != nil {- return nil, err- }- if j.Type == ast.JoinCrossApply || j.Type == ast.JoinOuterApply {- tableSourcesSnapshot := len(q.tableSourcesFrom)- q.tableSourcesFrom = append(q.tableSourcesFrom, left...)- defer func() { q.tableSourcesFrom = q.tableSourcesFrom[:tableSourcesSnapshot] }()- }- right, err := q.extractTableSource(j.Right)- if err != nil {- return nil, err- }- return append(left, right...), nil-}--func (q *omniQuerySpanExtractor) resolveTableRef(t *ast.TableRef) (base.TableSource, error) {- ts, err := q.tsqlFindTableSchemaByParts(t.Server, t.Database, t.Schema, t.Object)- if err != nil {- return nil, err- }- if t.Alias != "" {- ts = &base.PseudoTable{- Name: normIdent(t.Alias),- Columns: ts.GetQuerySpanResult(),- }- }- return ts, nil-}--func (q *omniQuerySpanExtractor) resolveAliasedTableRef(at *ast.AliasedTableRef) (base.TableSource, error) {- var columnAliases []string- if at.Columns != nil {- for _, it := range at.Columns.Items {- if s, ok := it.(*ast.String); ok {- columnAliases = append(columnAliases, s.Str)- }- }- }- switch inner := at.Table.(type) {- case *ast.TableRef:- ts, err := q.tsqlFindTableSchemaByParts(inner.Server, inner.Database, inner.Schema, inner.Object)- if err != nil {- return nil, err- }- cols := append([]base.QuerySpanResult{}, ts.GetQuerySpanResult()...)- if err := applyColumnAliases(cols, columnAliases); err != nil {- return nil, err- }- name := inner.Object- if at.Alias != "" {- name = at.Alias- }- return &base.PseudoTable{Name: name, Columns: cols}, nil- case *ast.SubqueryExpr:- return q.resolveSubqueryAsTable(inner, at.Alias, columnAliases...)- case *ast.ValuesClause:- return q.resolveValuesClause(inner, at.Alias, columnAliases)- case *ast.TableVarRef:- inners, err := q.resolveTableVar(inner, at.Alias)- if err != nil {- return nil, err- }- if len(inners) == 1 {- return inners[0], nil- }- return nil, unsupportedNodeError("aliased table variable must produce a single table source", at.Table)- case *ast.FuncCallExpr:- return q.resolveTableValuedFunction(inner, at.Alias, columnAliases)- case *ast.TableVarMethodCallRef:- cols := xmlNodesColumns(inner.Columns)- if err := applyColumnAliases(cols, columnAliases); err != nil {- return nil, err- }- return &base.PseudoTable{Name: normIdent(at.Alias), Columns: cols}, nil- default:- return nil, unsupportedNodeError("unsupported aliased table source item", at.Table)- }-}--func (q *omniQuerySpanExtractor) resolveTableValuedFunction(fn *ast.FuncCallExpr, alias string, columnAliases []string) (base.TableSource, error) {- if fn == nil || fn.Name == nil {- return nil, unsupportedTableSourceError(fn)- }- var columnNames []string- switch strings.ToUpper(fn.Name.Object) {- case "STRING_SPLIT":- columnNames = []string{"value"}- hasOrdinal, err := stringSplitHasOrdinalColumn(fn.Args)- if err != nil {- return nil, err- }- if hasOrdinal {- columnNames = append(columnNames, "ordinal")- }- case "OPENJSON":- columnNames = []string{"key", "value", "type"}- default:- return nil, unsupportedTableSourceError(fn)- }-- argSources, err := q.mergeListSources(fn.Args)- if err != nil {- return nil, err- }- columns := make([]base.QuerySpanResult, 0, len(columnNames))- for _, name := range columnNames {- columns = append(columns, base.QuerySpanResult{- Name: name,- SourceColumns: argSources.SourceColumns,- })- }- if strings.EqualFold(fn.Name.Object, "STRING_SPLIT") && len(columns) > 1 {- columns[1].SourceColumns = make(base.SourceColumnSet)- }- if err := applyColumnAliases(columns, columnAliases); err != nil {- return nil, err- }- return &base.PseudoTable{Name: normIdent(alias), Columns: columns}, nil-}--func stringSplitHasOrdinalColumn(args *ast.List) (bool, error) {- if args == nil || args.Len() < 3 {- return false, nil- }- arg := args.Items[2]- for {- paren, ok := arg.(*ast.ParenExpr)- if !ok {- break- }- arg = paren.Expr- }- literal, ok := arg.(*ast.Literal)- if !ok {- return false, unsupportedNodeError("STRING_SPLIT enable_ordinal must be a constant 0, 1, or NULL", arg)- }- switch literal.Type {- case ast.LitInteger:- switch literal.Ival {- case 0:- return false, nil- case 1:- return true, nil- default:- return false, unsupportedNodeError("STRING_SPLIT enable_ordinal must be 0 or 1", arg)- }- case ast.LitNull:- return false, nil- default:- return false, unsupportedNodeError("STRING_SPLIT enable_ordinal must be a constant 0, 1, or NULL", arg)- }-}--func (q *omniQuerySpanExtractor) resolveSubqueryAsTable(sq *ast.SubqueryExpr, alias string, columnAliases ...string) (base.TableSource, error) {- body, ok := sq.Query.(*ast.SelectStmt)- if !ok {- return nil, unsupportedNodeError("only SELECT subqueries in table source are supported", sq.Query)- }- clone := q.cloneForSubquery()- pseudo, err := clone.extractFromSelectStmt(body)- if err != nil {- return nil, err- }- cols := append([]base.QuerySpanResult{}, pseudo.GetQuerySpanResult()...)- if err := applyColumnAliases(cols, columnAliases); err != nil {- return nil, err- }- q.predicateColumns, _ = base.MergeSourceColumnSet(q.predicateColumns, clone.predicateColumns)- return &base.PseudoTable{Name: normIdent(alias), Columns: cols}, nil-}--func (q *omniQuerySpanExtractor) resolveValuesClause(vc *ast.ValuesClause, alias string, columnAliases []string) (base.TableSource, error) {- name := normIdent(alias)- if vc.Rows == nil || vc.Rows.Len() == 0 {- return &base.PseudoTable{Name: name}, nil- }- firstRow, ok := vc.Rows.Items[0].(*ast.List)- if !ok {- return &base.PseudoTable{Name: name}, nil- }- cols := make([]base.QuerySpanResult, 0, firstRow.Len())- for rowIndex, item := range vc.Rows.Items {- row, ok := item.(*ast.List)- if !ok {- continue- }- if row.Len() != firstRow.Len() {- return nil, errors.Errorf("VALUES row %d has %d columns, first row has %d", rowIndex+1, row.Len(), firstRow.Len())- }- for i, it := range row.Items {- expr, ok := it.(ast.ExprNode)- if !ok {- if rowIndex == 0 {- cols = append(cols, base.QuerySpanResult{})- }- continue- }- r, err := q.resolveExpression(expr)- if err != nil {- return nil, err- }- if rowIndex == 0 {- cols = append(cols, r)- continue- }- cols[i].SourceColumns, _ = base.MergeSourceColumnSet(cols[i].SourceColumns, r.SourceColumns)- }- }- if err := applyColumnAliases(cols, columnAliases); err != nil {- return nil, err- }- return &base.PseudoTable{Name: name, Columns: cols}, nil-}--func (q *omniQuerySpanExtractor) resolveTableVar(tv *ast.TableVarRef, alias string) ([]base.TableSource, error) {- if tv == nil {- return nil, nil- }- name := tv.Name- if temp, ok := q.findTempTable(name); ok {- tableName := name- if alias != "" {- tableName = alias- }- cols := make([]base.QuerySpanResult, 0, len(temp.Columns))- for _, c := range temp.Columns {- cols = append(cols, base.QuerySpanResult{- Name: c,- SourceColumns: base.SourceColumnSet{- base.ColumnResource{- Server: temp.Server,- Database: temp.Database,- Schema: temp.Schema,- Table: temp.Name,- Column: c,- }: true,- },- IsPlainField: true,- })- }- return []base.TableSource{&base.PseudoTable{Name: tableName, Columns: cols}}, nil- }- return nil, &base.ResourceNotFoundError{- Table: &name,- Err: errors.Errorf("temp table %s not found", name),- }-}--// populateOmniTempTables mirrors the ANTLR tempTableColumnDefinitionListener:-// for each VariableDecl of table type, build a PhysicalTable keyed by the-// variable name (including the leading '@') and store it in the shared map.-func populateOmniTempTables(d *ast.DeclareStmt, out map[string]*base.PhysicalTable) {- if d == nil || d.Variables == nil || out == nil {- return- }- for _, it := range d.Variables.Items {- v, ok := it.(*ast.VariableDecl)- if !ok || !v.IsTable || v.TableDef == nil {- continue- }- columns := make([]string, 0, v.TableDef.Len())- for _, cdef := range v.TableDef.Items {- if cd, ok := cdef.(*ast.ColumnDef); ok {- columns = append(columns, cd.Name)- }- }- out[v.Name] = &base.PhysicalTable{- Name: v.Name,- Columns: columns,- }- }-}--func populateOmniCreateTempTable(c *ast.CreateTableStmt, out map[string]*base.PhysicalTable) {- if c == nil || c.Name == nil || out == nil || !strings.HasPrefix(c.Name.Object, "#") {- return- }- var columns []string- if c.Columns != nil {- columns = make([]string, 0, c.Columns.Len())- for _, item := range c.Columns.Items {- if cd, ok := item.(*ast.ColumnDef); ok {- columns = append(columns, cd.Name)- }- }- }- out[c.Name.Object] = &base.PhysicalTable{- Name: c.Name.Object,- Columns: columns,- }-}--func (q *omniQuerySpanExtractor) populateSelectIntoTempTable(sel *ast.SelectStmt, results []base.QuerySpanResult) {- if sel == nil || sel.IntoTable == nil || q.gCtx.TempTables == nil || !strings.HasPrefix(sel.IntoTable.Object, "#") {- return- }- columns := make([]string, 0, len(results))- for i, result := range results {- name := result.Name- if name == "" && sel.TargetList != nil && i < len(sel.TargetList.Items) {- name = q.sliceName(sel.TargetList.Items[i])- }- columns = append(columns, name)- }- q.gCtx.TempTables[sel.IntoTable.Object] = &base.PhysicalTable{- Name: sel.IntoTable.Object,- Columns: columns,- }-}--func xmlNodesColumns(cols []string) []base.QuerySpanResult {- out := make([]base.QuerySpanResult, 0, len(cols))- for _, c := range cols {- out = append(out, base.QuerySpanResult{Name: c})- }- return out-}--func applyColumnAliases(cols []base.QuerySpanResult, aliases []string) error {- if len(aliases) == 0 {- return nil- }- if len(aliases) != len(cols) {- return errors.Errorf("column alias count %d does not match column count %d", len(aliases), len(cols))- }- for i, name := range aliases {- cols[i].Name = normIdent(name)- }- return nil-}--func (q *omniQuerySpanExtractor) cloneForSubquery() *omniQuerySpanExtractor {- clone := &omniQuerySpanExtractor{- querySpanExtractor: &querySpanExtractor{- ctx: q.ctx,- defaultDatabase: q.defaultDatabase,- defaultSchema: q.defaultSchema,- ignoreCaseSensitive: q.ignoreCaseSensitive,- gCtx: q.gCtx,- ctes: append([]*base.PseudoTable{}, q.ctes...),- outerTableSources: append(append([]base.TableSource{}, q.outerTableSources...), q.tableSourcesFrom...),- predicateColumns: make(base.SourceColumnSet),- viewResolutionStack: cloneViewResolutionStack(q.viewResolutionStack),- },- source: q.source,- }- return clone-}--// -------------------- Target list ----------------------func (q *omniQuerySpanExtractor) extractTargetList(list *ast.List) ([]base.QuerySpanResult, error) {- if list == nil {- return nil, nil- }- var results []base.QuerySpanResult- for _, item := range list.Items {- switch v := item.(type) {- case *ast.ResTarget:- if star, ok := v.Val.(*ast.StarExpr); ok {- fields, err := q.expandStar(star)- if err != nil {- return nil, err- }- results = append(results, fields...)- continue- }- r, err := q.resolveExpression(v.Val)- if err != nil {- return nil, err- }- if v.Name != "" {- r.Name = normIdent(v.Name)- }- results = append(results, r)- case *ast.StarExpr:- fields, err := q.expandStar(v)- if err != nil {- return nil, err- }- results = append(results, fields...)- case *ast.SelectAssign:- // SELECT @v = expr — no result column produced; just fold the expr- // for predicate/source tracking (omitted here since it doesn't emit a column).- continue- default:- if expr, ok := item.(ast.ExprNode); ok {- r, err := q.resolveExpression(expr)- if err != nil {- return nil, err- }- results = append(results, r)- continue- }- return nil, unsupportedNodeError("unsupported SELECT target item", item)- }- }- return results, nil-}--func (q *omniQuerySpanExtractor) expandStar(s *ast.StarExpr) ([]base.QuerySpanResult, error) {- if s.Qualifier == "" {- var out []base.QuerySpanResult- for _, ts := range q.tableSourcesFrom {- out = append(out, ts.GetQuerySpanResult()...)- }- return out, nil- }- return q.tsqlGetAllFieldsOfTableInFromOrOuterCTE("", "", s.Qualifier)-}--// -------------------- Expression resolver ----------------------// resolveExpression maps an omni ExprNode to a QuerySpanResult. This is the-// omni equivalent of the ANTLR getQuerySpanResultFromExpr.-func (q *omniQuerySpanExtractor) resolveExpression(expr ast.ExprNode) (base.QuerySpanResult, error) {- return q.resolveExpressionNode(expr)-}--func (q *omniQuerySpanExtractor) resolveExpressionNode(n ast.Node) (base.QuerySpanResult, error) {- if n == nil {- return base.QuerySpanResult{SourceColumns: make(base.SourceColumnSet)}, nil- }- if r, handled, err := q.resolveSimpleExpressionNode(n); handled {- return r, err- }- switch v := n.(type) {- case *ast.ColumnRef:- if r, handled, err := q.resolvePseudoColumnRef(v); handled {- if err != nil {- return base.QuerySpanResult{}, errors.Wrapf(err, "failed to resolve column %q", v.Column)- }- return r, nil- }- r, err := q.tsqlIsFieldSensitive(v.Database, v.Schema, v.Table, v.Column)- if err != nil {- return base.QuerySpanResult{}, errors.Wrapf(err, "failed to resolve column %q", v.Column)- }- r.IsPlainField = true- return r, nil- case *ast.AtTimeZoneExpr:- r, err := q.mergeExprSources(v.Expr, v.TimeZone)- r.Name = q.sliceName(n)- return r, err- case *ast.BinaryExpr:- r, err := q.mergeExprSources(v.Left, v.Right)- r.Name = q.sliceName(n)- return r, err- case *ast.UnaryExpr:- r, err := q.resolveExpressionNode(v.Operand)- if err != nil {- return r, err- }- r.Name = q.sliceName(n)- r.IsPlainField = false- return r, nil- case *ast.BetweenExpr:- r, err := q.mergeExprSources(v.Expr, v.Low, v.High)- r.Name = q.sliceName(n)- return r, err- case *ast.LikeExpr:- r, err := q.mergeExprSources(v.Expr, v.Pattern, v.Escape)- r.Name = q.sliceName(n)- return r, err- case *ast.IsExpr:- r, err := q.resolveExpressionNode(v.Expr)- if err != nil {- return r, err- }- r.Name = q.sliceName(n)- r.IsPlainField = false- return r, nil- case *ast.InExpr:- exprs := []ast.ExprNode{v.Expr}- if v.List != nil {- for _, it := range v.List.Items {- if e, ok := it.(ast.ExprNode); ok {- exprs = append(exprs, e)- }- }- }- if v.Subquery != nil {- exprs = append(exprs, v.Subquery)- }- r, err := q.mergeExprSources(exprs...)- r.Name = q.sliceName(n)- return r, err- case *ast.CaseExpr:- exprs := []ast.ExprNode{v.Arg, v.ElseExpr}- if v.WhenList != nil {- for _, it := range v.WhenList.Items {- if cw, ok := it.(*ast.CaseWhen); ok {- exprs = append(exprs, cw.Condition, cw.Result)- }- }- }- r, err := q.mergeExprSources(exprs...)- r.Name = q.sliceName(n)- return r, err- case *ast.IifExpr:- r, err := q.mergeExprSources(v.Condition, v.TrueVal, v.FalseVal)- r.Name = q.sliceName(n)- return r, err- case *ast.CoalesceExpr:- r, err := q.mergeListSources(v.Args)- r.Name = q.sliceName(n)- return r, err- case *ast.NullifExpr:- r, err := q.mergeExprSources(v.Left, v.Right)- r.Name = q.sliceName(n)- return r, err- case *ast.FuncCallExpr:- r, err := q.mergeListSources(v.Args)- if err != nil {- return r, err- }- // Also merge Over clause partition/order.- if v.Over != nil {- sub, err := q.mergeListSources(v.Over.PartitionBy)- if err != nil {- return r, err- }- r.SourceColumns, _ = base.MergeSourceColumnSet(r.SourceColumns, sub.SourceColumns)- sub, err = q.mergeOrderBySources(v.Over.OrderBy)- if err != nil {- return r, err- }- r.SourceColumns, _ = base.MergeSourceColumnSet(r.SourceColumns, sub.SourceColumns)- }- if v.Within != nil {- sub, err := q.mergeOrderBySources(v.Within)- if err != nil {- return r, err- }- r.SourceColumns, _ = base.MergeSourceColumnSet(r.SourceColumns, sub.SourceColumns)- }- r.Name = q.sliceName(n)- return r, nil- case *ast.MethodCallExpr:- r, err := q.mergeListSources(v.Args)- r.Name = q.sliceName(n)- return r, err- case *ast.CastExpr:- r, err := q.resolveExpressionNode(v.Expr)- if err != nil {- return r, err- }- r.Name = q.sliceName(n)- r.IsPlainField = false- return r, nil- case *ast.ConvertExpr:- r, err := q.mergeExprSources(v.Expr, v.Style)- r.Name = q.sliceName(n)- return r, err- case *ast.TryCastExpr:- r, err := q.resolveExpressionNode(v.Expr)- if err != nil {- return r, err- }- r.Name = q.sliceName(n)- r.IsPlainField = false- return r, nil- case *ast.TryConvertExpr:- r, err := q.mergeExprSources(v.Expr, v.Style)- r.Name = q.sliceName(n)- return r, err- case *ast.SubqueryExpr:- return q.resolveSubqueryExpr(v)- case *ast.SubqueryComparisonExpr:- r, err := q.resolveExpressionNode(v.Left)- if err != nil {- return r, err- }- if body, ok := v.Subquery.(*ast.SelectStmt); ok {- clone := q.cloneForSubquery()- sub, subErr := clone.extractFromSelectStmt(body)- if subErr != nil {- return r, subErr- }- for _, sc := range sub.GetQuerySpanResult() {- r.SourceColumns, _ = base.MergeSourceColumnSet(r.SourceColumns, sc.SourceColumns)- }- q.predicateColumns, _ = base.MergeSourceColumnSet(q.predicateColumns, clone.predicateColumns)- }- r.Name = q.sliceName(n)- r.IsPlainField = false- return r, nil- case *ast.ExistsExpr:- r := base.QuerySpanResult{- Name: q.sliceName(n),- SourceColumns: make(base.SourceColumnSet),- }- if body, ok := v.Subquery.(*ast.SelectStmt); ok {- clone := q.cloneForSubquery()- if _, err := clone.extractFromSelectStmt(body); err != nil {- return r, err- }- q.predicateColumns, _ = base.MergeSourceColumnSet(q.predicateColumns, clone.predicateColumns)- }- return r, nil- case *ast.FullTextPredicate:- r := base.QuerySpanResult{SourceColumns: make(base.SourceColumnSet)}- if v.Columns != nil {- for _, it := range v.Columns.Items {- if cr, ok := it.(*ast.ColumnRef); ok {- sub, err := q.tsqlIsFieldSensitive(cr.Database, cr.Schema, cr.Table, cr.Column)- if err != nil {- return r, errors.Wrapf(err, "failed to resolve full-text predicate column %q", cr.Column)- }- r.SourceColumns, _ = base.MergeSourceColumnSet(r.SourceColumns, sub.SourceColumns)- }- }- }- if v.Value != nil {- sub, err := q.resolveExpressionNode(v.Value)- if err != nil {- return r, err- }- r.SourceColumns, _ = base.MergeSourceColumnSet(r.SourceColumns, sub.SourceColumns)- }- r.Name = q.sliceName(n)- return r, nil- case *ast.StarExpr:- // Star in scalar context: treat as empty (already handled at target-list level).- return base.QuerySpanResult{Name: q.sliceName(n), SourceColumns: make(base.SourceColumnSet)}, nil- case *ast.GroupingSetsExpr, *ast.RollupExpr, *ast.CubeExpr:- // Appear in GROUP BY; not typical targets. Fallback to empty.- return base.QuerySpanResult{Name: q.sliceName(n), SourceColumns: make(base.SourceColumnSet)}, nil- case *ast.ResTarget:- r, err := q.resolveExpressionNode(v.Val)- if err != nil {- return r, err- }- if v.Name != "" {- r.Name = v.Name- }- return r, nil- case *ast.SelectAssign:- return q.resolveExpressionNode(v.Value)- case *ast.CaseWhen:- return q.mergeExprSources(v.Condition, v.Result)- case *ast.CurrentOfExpr:- return base.QuerySpanResult{Name: q.sliceName(n), SourceColumns: make(base.SourceColumnSet)}, nil- default:- return base.QuerySpanResult{Name: q.sliceName(n), SourceColumns: make(base.SourceColumnSet)}, nil- }-}--func (q *omniQuerySpanExtractor) resolveSimpleExpressionNode(n ast.Node) (base.QuerySpanResult, bool, error) {- switch v := n.(type) {- case *ast.Literal, *ast.VariableRef, *ast.Boolean:- return base.QuerySpanResult{Name: q.sliceName(v), SourceColumns: make(base.SourceColumnSet)}, true, nil- case *ast.ParenExpr:- r, err := q.resolveExpressionNode(v.Expr)- return r, true, err- case *ast.CollateExpr:- r, err := q.resolveExpressionNode(v.Expr)- return r, true, err- default:- return base.QuerySpanResult{}, false, nil- }-}--func (q *omniQuerySpanExtractor) resolveSubqueryExpr(sq *ast.SubqueryExpr) (base.QuerySpanResult, error) {- r := base.QuerySpanResult{- Name: q.sliceName(sq),- SourceColumns: make(base.SourceColumnSet),- }- body, ok := sq.Query.(*ast.SelectStmt)- if !ok {- return r, nil- }- clone := q.cloneForSubquery()- pseudo, err := clone.extractFromSelectStmt(body)- if err != nil {- return r, err- }- // Scalar subquery contributes its first result column's source columns.- results := pseudo.GetQuerySpanResult()- for _, c := range results {- r.SourceColumns, _ = base.MergeSourceColumnSet(r.SourceColumns, c.SourceColumns)- }- q.predicateColumns, _ = base.MergeSourceColumnSet(q.predicateColumns, clone.predicateColumns)- return r, nil-}--func (q *omniQuerySpanExtractor) mergeExprSources(exprs ...ast.ExprNode) (base.QuerySpanResult, error) {- r := base.QuerySpanResult{SourceColumns: make(base.SourceColumnSet)}- for _, e := range exprs {- if e == nil {- continue- }- sub, err := q.resolveExpressionNode(e)- if err != nil {- return r, err- }- r.SourceColumns, _ = base.MergeSourceColumnSet(r.SourceColumns, sub.SourceColumns)- }- return r, nil-}--func (q *omniQuerySpanExtractor) mergeListSources(list *ast.List) (base.QuerySpanResult, error) {- r := base.QuerySpanResult{SourceColumns: make(base.SourceColumnSet)}- if list == nil {- return r, nil- }- for _, it := range list.Items {- if e, ok := it.(ast.ExprNode); ok {- sub, err := q.resolveExpressionNode(e)- if err != nil {- return r, err- }- r.SourceColumns, _ = base.MergeSourceColumnSet(r.SourceColumns, sub.SourceColumns)- }- }- return r, nil-}--func (q *omniQuerySpanExtractor) mergeOrderBySources(list *ast.List) (base.QuerySpanResult, error) {- r := base.QuerySpanResult{SourceColumns: make(base.SourceColumnSet)}- if list == nil {- return r, nil- }- for _, it := range list.Items {- var expr ast.Node- switch v := it.(type) {- case *ast.OrderByItem:- expr = v.Expr- case ast.ExprNode:- expr = v- default:- return r, unsupportedNodeError("unsupported ORDER BY item", it)- }- sub, err := q.resolveExpressionNode(expr)- if err != nil {- return r, err- }- r.SourceColumns, _ = base.MergeSourceColumnSet(r.SourceColumns, sub.SourceColumns)- }- return r, nil-}--// -------------------- Helpers ----------------------// sliceName returns the whitespace-stripped source text covering a node's Loc.-// Mirrors ANTLR's ctx.GetText() convention for naming expression results.-// For *SubqueryExpr (and similar paren-wrapped nodes) the Loc spans the-// surrounding parens; we strip a matching leading `(` / trailing `)` pair to-// match the ANTLR subquery.getText() output.-func (q *omniQuerySpanExtractor) sliceName(n ast.Node) string {- loc := omniNodeLoc(n)- if loc.Start < 0 || loc.End < 0 || loc.Start >= len(q.source) {- return ""- }- end := loc.End- if end > len(q.source) {- end = len(q.source)- }- text := stripSpaces(q.source[loc.Start:end])- switch n.(type) {- case *ast.SubqueryExpr, *ast.ExistsExpr, *ast.SubqueryComparisonExpr:- if len(text) >= 2 && text[0] == '(' && text[len(text)-1] == ')' {- text = text[1 : len(text)-1]- }- default:- }- return text-}--func stripSpaces(s string) string {- var b strings.Builder- b.Grow(len(s))- for _, r := range s {- if !unicode.IsSpace(r) {- b.WriteRune(r)- }- }- return b.String()-}--// normIdent lowercases a SQL-text-sourced identifier (table alias, column-// alias, CTE name, ResTarget name). Matches the legacy ANTLR-// NormalizeTSQLIdentifier behavior which lowercases unconditionally. Does not-// apply to identifiers sourced from metadata (physical table/column names);-// those are compared case-insensitively but stored as-is.-func normIdent(s string) string {- return strings.ToLower(s)-}--// omniNodeLoc extracts the Loc field from an ast.Node via type switching.-// Not every node has a Loc (the Node interface doesn't expose it), so we-// enumerate the types we care about. Returns zero Loc otherwise.-func omniNodeLoc(n ast.Node) ast.Loc {- if n == nil {- return ast.NoLoc()- }- if loc, ok := omniExpressionNodeLoc(n); ok {- return loc- }- switch v := n.(type) {- case *ast.SelectStmt:- return v.Loc- case *ast.TableRef:- return v.Loc- case *ast.ResTarget:- return v.Loc- case *ast.SelectAssign:- return v.Loc- default:- return ast.NoLoc()- }-}--func omniExpressionNodeLoc(n ast.Node) (ast.Loc, bool) {- switch v := n.(type) {- case *ast.ColumnRef:- return v.Loc, true- case *ast.Literal:- return v.Loc, true- case *ast.VariableRef:- return v.Loc, true- case *ast.StarExpr:- return v.Loc, true- case *ast.BinaryExpr:- return v.Loc, true- case *ast.UnaryExpr:- return v.Loc, true- case *ast.BetweenExpr:- return v.Loc, true- case *ast.LikeExpr:- return v.Loc, true- case *ast.IsExpr:- return v.Loc, true- case *ast.InExpr:- return v.Loc, true- case *ast.CaseExpr:- return v.Loc, true- case *ast.CaseWhen:- return v.Loc, true- case *ast.IifExpr:- return v.Loc, true- case *ast.CoalesceExpr:- return v.Loc, true- case *ast.NullifExpr:- return v.Loc, true- case *ast.FuncCallExpr:- return v.Loc, true- case *ast.MethodCallExpr:- return v.Loc, true- case *ast.CastExpr:- return v.Loc, true- case *ast.ConvertExpr:- return v.Loc, true- case *ast.TryCastExpr:- return v.Loc, true- case *ast.TryConvertExpr:- return v.Loc, true- case *ast.SubqueryExpr:- return v.Loc, true- case *ast.SubqueryComparisonExpr:- return v.Loc, true- case *ast.ExistsExpr:- return v.Loc, true- case *ast.FullTextPredicate:- return v.Loc, true- case *ast.ParenExpr:- return v.Loc, true- case *ast.CollateExpr:- return v.Loc, true- case *ast.AtTimeZoneExpr:- return v.Loc, true- default:- return ast.NoLoc(), false- }-}--// -------------------- Access tables ----------------------// collectOmniAccessTables walks the AST and records every table-source-// position reference. Mirrors the ANTLR accessTableListener.-func collectOmniAccessTables(root ast.Node, currentDatabase, currentSchema string) base.SourceColumnSet {- out := make(base.SourceColumnSet)- walkAccessTables(root, currentDatabase, currentSchema, out)- return out-}--func walkAccessTables(n ast.Node, db, schema string, out base.SourceColumnSet) {- if n == nil {- return- }- switch v := n.(type) {- case *ast.SelectStmt:- if v.WithClause != nil {- walkAccessTables(v.WithClause, db, schema, out)- }- if v.FromClause != nil {- for _, it := range v.FromClause.Items {- walkAccessTables(it, db, schema, out)- }- }- if v.WhereClause != nil {- walkAccessTables(v.WhereClause, db, schema, out)- }- if v.HavingClause != nil {- walkAccessTables(v.HavingClause, db, schema, out)- }- if v.TargetList != nil {- for _, it := range v.TargetList.Items {- walkAccessTables(it, db, schema, out)- }- }- if v.Larg != nil {- walkAccessTables(v.Larg, db, schema, out)- }- if v.Rarg != nil {- walkAccessTables(v.Rarg, db, schema, out)- }- case *ast.WithClause:- if v.CTEs != nil {- for _, it := range v.CTEs.Items {- if c, ok := it.(*ast.CommonTableExpr); ok {- walkAccessTables(c.Query, db, schema, out)- }- }- }- case *ast.TableRef:- addAccessTable(v, db, schema, out)- case *ast.AliasedTableRef:- walkAccessTables(v.Table, db, schema, out)- case *ast.JoinClause:- walkAccessTables(v.Left, db, schema, out)- walkAccessTables(v.Right, db, schema, out)- if v.Condition != nil {- walkAccessTables(v.Condition, db, schema, out)- }- case *ast.SubqueryExpr:- walkAccessTables(v.Query, db, schema, out)- case *ast.PivotExpr:- walkAccessTables(v.Source, db, schema, out)- case *ast.UnpivotExpr:- walkAccessTables(v.Source, db, schema, out)- case *ast.ExistsExpr:- walkAccessTables(v.Subquery, db, schema, out)- case *ast.SubqueryComparisonExpr:- walkAccessTables(v.Left, db, schema, out)- walkAccessTables(v.Subquery, db, schema, out)- case *ast.InExpr:- walkAccessTables(v.Expr, db, schema, out)- if v.List != nil {- for _, it := range v.List.Items {- walkAccessTables(it, db, schema, out)- }- }- walkAccessTables(v.Subquery, db, schema, out)- case *ast.BinaryExpr:- walkAccessTables(v.Left, db, schema, out)- walkAccessTables(v.Right, db, schema, out)- case *ast.UnaryExpr:- walkAccessTables(v.Operand, db, schema, out)- case *ast.BetweenExpr:- walkAccessTables(v.Expr, db, schema, out)- walkAccessTables(v.Low, db, schema, out)- walkAccessTables(v.High, db, schema, out)- case *ast.LikeExpr:- walkAccessTables(v.Expr, db, schema, out)- walkAccessTables(v.Pattern, db, schema, out)- case *ast.IsExpr:- walkAccessTables(v.Expr, db, schema, out)- case *ast.CaseExpr:- walkAccessTables(v.Arg, db, schema, out)- walkAccessTables(v.ElseExpr, db, schema, out)- if v.WhenList != nil {- for _, it := range v.WhenList.Items {- walkAccessTables(it, db, schema, out)- }- }- case *ast.CaseWhen:- walkAccessTables(v.Condition, db, schema, out)- walkAccessTables(v.Result, db, schema, out)- case *ast.ParenExpr:- walkAccessTables(v.Expr, db, schema, out)- case *ast.CastExpr:- walkAccessTables(v.Expr, db, schema, out)- case *ast.ConvertExpr:- walkAccessTables(v.Expr, db, schema, out)- case *ast.TryCastExpr:- walkAccessTables(v.Expr, db, schema, out)- case *ast.TryConvertExpr:- walkAccessTables(v.Expr, db, schema, out)- case *ast.FuncCallExpr:- if v.Args != nil {- for _, it := range v.Args.Items {- walkAccessTables(it, db, schema, out)- }- }- case *ast.ResTarget:- walkAccessTables(v.Val, db, schema, out)- case *ast.ValuesClause:- // No table access.- case *ast.TableVarRef, *ast.TableVarMethodCallRef:- // Temp-table var: no physical access.- default:- }-}--func addAccessTable(t *ast.TableRef, defDB, defSchema string, out base.SourceColumnSet) {- if t == nil || strings.HasPrefix(t.Object, "#") {- return- }- database := defDB- if t.Database != "" {- database = t.Database- }- schema := defSchema- if t.Schema != "" {- schema = t.Schema- }- out[base.ColumnResource{- Server: t.Server,- Database: database,- Schema: schema,- Table: t.Object,- }] = true-}diff --git a/backend/plugin/parser/tsql/query_span_extractor_omni_test.go b/backend/plugin/parser/tsql/query_span_extractor_test.gosimilarity index 100%rename from backend/plugin/parser/tsql/query_span_extractor_omni_test.gorename to backend/plugin/parser/tsql/query_span_extractor_test.godiff --git a/backend/plugin/parser/tsql/query_span_parser_invariant_test.go b/backend/plugin/parser/tsql/query_span_parser_invariant_test.goindex c5dbf1a83e..7d0e157ca2 100644--- a/backend/plugin/parser/tsql/query_span_parser_invariant_test.go+++ b/backend/plugin/parser/tsql/query_span_parser_invariant_test.go@@ -68,7 +68,7 @@ func querySpanFixtureParseCoverage(t *testing.T) {continue}total++- _, err := ParseTSQLOmni(e.Statement)+ _, err := ParseTSQL(e.Statement)if err != nil {failures = append(failures, failure{fixture: path, index: i, statement: e.Statement, err: err})continue@@ -537,9 +537,9 @@ func querySpanStructuralInvariants(t *testing.T) {name: "table_variable_in_from",sql: "DECLARE @t TABLE(id INT); SELECT id FROM @t",check: func(t *testing.T, _ ast.Node) {- // ParseTSQLOmni gives a slice; this invariant only checks the first stmt (DECLARE).+ // ParseTSQL gives a slice; this invariant only checks the first stmt (DECLARE).// Walk the full parse to confirm the second has @t as TableVarRef.- stmts, err := ParseTSQLOmni("DECLARE @t TABLE(id INT); SELECT id FROM @t")+ stmts, err := ParseTSQL("DECLARE @t TABLE(id INT); SELECT id FROM @t")if err != nil {t.Fatalf("parse: %v", err)}@@ -605,7 +605,7 @@ func querySpanStructuralInvariants(t *testing.T) {for _, p := range invariants {t.Run(p.name, func(t *testing.T) {- stmts, err := ParseTSQLOmni(p.sql)+ stmts, err := ParseTSQL(p.sql)if err != nil {t.Fatalf("parse err: %v\nSQL: %s", err, p.sql)}diff --git a/backend/plugin/parser/tsql/query_span_predicate_omni.go b/backend/plugin/parser/tsql/query_span_predicate.gosimilarity index 97%rename from backend/plugin/parser/tsql/query_span_predicate_omni.gorename to backend/plugin/parser/tsql/query_span_predicate.goindex 85b3df91f0..148c1a2f9e 100644--- a/backend/plugin/parser/tsql/query_span_predicate_omni.go+++ b/backend/plugin/parser/tsql/query_span_predicate.go@@ -4,8 +4,7 @@ import "github.com/bytebase/omni/mssql/ast"// collectOmniPredicateColumnRefs walks an omni expression tree rooted at a// boolean context (WHERE, HAVING, JOIN ON) and returns every *ast.ColumnRef-// reachable through predicate paths. It mirrors the traversal performed by-// the ANTLR-based helpers in query_span_predicate.go.+// reachable through predicate paths.//// Scope it covers:// - direct column references in the expressiondiff --git a/backend/plugin/parser/tsql/query_span_predicate_omni_test.go b/backend/plugin/parser/tsql/query_span_predicate_test.gosimilarity index 98%rename from backend/plugin/parser/tsql/query_span_predicate_omni_test.gorename to backend/plugin/parser/tsql/query_span_predicate_test.goindex 4784f7c680..0e391c17f4 100644--- a/backend/plugin/parser/tsql/query_span_predicate_omni_test.go+++ b/backend/plugin/parser/tsql/query_span_predicate_test.go@@ -62,7 +62,7 @@ func TestCollectOmniSelectPredicateColumnRefs(t *testing.T) {}for _, tc := range cases {t.Run(tc.name, func(t *testing.T) {- stmts, err := ParseTSQLOmni(tc.sql)+ stmts, err := ParseTSQL(tc.sql)require.NoError(t, err, "parse failed for %s", tc.sql)require.NotEmpty(t, stmts)sel, ok := stmts[0].AST.(*ast.SelectStmt)@@ -85,7 +85,7 @@ func TestCollectOmniPredicateColumnRefs_QualifiedRefs(t *testing.T) {// Ensure qualified column refs (db.schema.table.col) are returned with// all qualifier fields intact so the extractor can resolve them later.sql := "SELECT * FROM db1.dbo.t WHERE db1.dbo.t.a = 1"- stmts, err := ParseTSQLOmni(sql)+ stmts, err := ParseTSQL(sql)require.NoError(t, err)sel, ok := stmts[0].AST.(*ast.SelectStmt)require.True(t, ok)@@ -101,7 +101,7 @@ func TestCollectOmniPredicateColumnRefs_QualifiedRefs(t *testing.T) {func TestCollectOmniPredicateColumnRefs_Directly(t *testing.T) {// Exercise the non-Select entry point: caller hands in a bare ExprNode.sql := "SELECT * FROM t WHERE a > b AND c IS NULL"- stmts, err := ParseTSQLOmni(sql)+ stmts, err := ParseTSQL(sql)require.NoError(t, err)sel, ok := stmts[0].AST.(*ast.SelectStmt)require.True(t, ok)diff --git a/backend/plugin/parser/tsql/query_span_pseudo_column_omni.go b/backend/plugin/parser/tsql/query_span_pseudo_column.gosimilarity index 100%rename from backend/plugin/parser/tsql/query_span_pseudo_column_omni.gorename to backend/plugin/parser/tsql/query_span_pseudo_column.godiff --git a/backend/plugin/parser/tsql/query_span_pseudo_column_omni_test.go b/backend/plugin/parser/tsql/query_span_pseudo_column_test.gosimilarity index 100%rename from backend/plugin/parser/tsql/query_span_pseudo_column_omni_test.gorename to backend/plugin/parser/tsql/query_span_pseudo_column_test.godiff --git a/backend/plugin/parser/tsql/tsql.go b/backend/plugin/parser/tsql/tsql.goindex 23de6711ac..5c24d44768 100644--- a/backend/plugin/parser/tsql/tsql.go+++ b/backend/plugin/parser/tsql/tsql.go@@ -30,7 +30,7 @@ func parseTSQLStatements(statement string) ([]base.ParsedStatement, error) {continue}- omniStmts, omniErr := ParseTSQLOmni(stmt.Text)+ omniStmts, omniErr := ParseTSQL(stmt.Text)if omniErr != nil {return nil, convertOmniError(omniErr, stmt)}diff --git a/backend/plugin/schema/mssql/generate_migration.go b/backend/plugin/schema/mssql/generate_migration.goindex 2ee759d033..d405f85643 100644--- a/backend/plugin/schema/mssql/generate_migration.go+++ b/backend/plugin/schema/mssql/generate_migration.go@@ -1066,7 +1066,7 @@ func generateColumnCommentSQL(action, schemaName, tableName, columnName, commentfunc getViewDependencies(viewDef string, schemaName string) ([]string, error) {// Parse the CREATE VIEW statement to extract the query properly// We need to find the AS keyword that's part of CREATE VIEW, not column aliases.- stmts, err := tsql.ParseTSQLOmni(viewDef)+ stmts, err := tsql.ParseTSQL(viewDef)if err != nil {return nil, errors.Wrapf(err, "failed to parse view definition")}diff --git a/backend/plugin/schema/mssql/get_database_metadata_omni.go b/backend/plugin/schema/mssql/get_database_metadata.gosimilarity index 99%rename from backend/plugin/schema/mssql/get_database_metadata_omni.gorename to backend/plugin/schema/mssql/get_database_metadata.goindex 20e5118ac2..228a7bd690 100644--- a/backend/plugin/schema/mssql/get_database_metadata_omni.go+++ b/backend/plugin/schema/mssql/get_database_metadata.go@@ -17,11 +17,7 @@ const noAction = "NO ACTION"// GetDatabaseMetadata parses the SQL schema text and returns the database metadata.func GetDatabaseMetadata(schemaText string) (*storepb.DatabaseSchemaMetadata, error) {- return getDatabaseMetadataOmni(schemaText)-}--func getDatabaseMetadataOmni(schemaText string) (*storepb.DatabaseSchemaMetadata, error) {- stmts, err := tsql.ParseTSQLOmni(schemaText)+ stmts, err := tsql.ParseTSQL(schemaText)if err != nil {return nil, errors.Wrapf(err, "failed to parse SQL schema")}diff --git a/backend/plugin/schema/mssql/get_database_metadata_omni_test.go b/backend/plugin/schema/mssql/get_database_metadata_test.gosimilarity index 89%rename from backend/plugin/schema/mssql/get_database_metadata_omni_test.gorename to backend/plugin/schema/mssql/get_database_metadata_test.goindex 1bce398346..29159d8b14 100644--- a/backend/plugin/schema/mssql/get_database_metadata_omni_test.go+++ b/backend/plugin/schema/mssql/get_database_metadata_test.go@@ -13,8 +13,8 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store")-func TestGetDatabaseMetadataOmniSequenceUsesExplicitSchema(t *testing.T) {- metadata, err := getDatabaseMetadataOmni(`+func TestGetDatabaseMetadataSequenceUsesExplicitSchema(t *testing.T) {+ metadata, err := GetDatabaseMetadata(`CREATE SCHEMA audit;CREATE SEQUENCE audit.EventSeq AS BIGINT;`)@@ -34,8 +34,8 @@ CREATE SEQUENCE audit.EventSeq AS BIGINT;}, metadata.Schemas)}-func TestGetDatabaseMetadataOmniColumnForeignKeyUsesTableSchemaFallback(t *testing.T) {- metadata, err := getDatabaseMetadataOmni(`+func TestGetDatabaseMetadataColumnForeignKeyUsesTableSchemaFallback(t *testing.T) {+ metadata, err := GetDatabaseMetadata(`CREATE SCHEMA sales;CREATE TABLE sales.customers (id INT PRIMARY KEYdiff --git a/backend/plugin/schema/mysql/format_view_body_test.go b/backend/plugin/schema/mysql/format_view_body_test.goindex f75156ffdc..a8b6ee36c1 100644--- a/backend/plugin/schema/mysql/format_view_body_test.go+++ b/backend/plugin/schema/mysql/format_view_body_test.go@@ -272,7 +272,7 @@ func TestMultiFileViewSDLPretty(t *testing.T) {}// TestGetDatabaseMetadataParsesPrettyView proves the SDL→metadata parsers accept the-// pretty-printed view statement: the omni catalog path (GetDatabaseMetadataOmni, the+// pretty-printed view statement: the omni catalog path (GetDatabaseMetadata, the// registered production entry) parses a writeViewSDL-produced multi-line// CREATE OR REPLACE VIEW.func TestGetDatabaseMetadataParsesPrettyView(t *testing.T) {@@ -286,7 +286,7 @@ func TestGetDatabaseMetadataParsesPrettyView(t *testing.T) {require.Contains(t, sdl, "AS\nselect\n `t1`.`a` AS `a`,", "fixture must actually be pretty-printed")t.Run("omni", func(t *testing.T) {- meta, err := GetDatabaseMetadataOmni(sdl)+ meta, err := GetDatabaseMetadata(sdl)require.NoError(t, err)require.Len(t, meta.Schemas, 1)require.Len(t, meta.Schemas[0].Views, 1)diff --git a/backend/plugin/schema/mysql/get_database_metadata_omni.go b/backend/plugin/schema/mysql/get_database_metadata.gosimilarity index 79%rename from backend/plugin/schema/mysql/get_database_metadata_omni.gorename to backend/plugin/schema/mysql/get_database_metadata.goindex ffd39e8e96..fde7952897 100644--- a/backend/plugin/schema/mysql/get_database_metadata_omni.go+++ b/backend/plugin/schema/mysql/get_database_metadata.go@@ -11,13 +11,13 @@ import ()func init() {- schema.RegisterGetDatabaseMetadata(storepb.Engine_MYSQL, GetDatabaseMetadataOmni)- schema.RegisterGetDatabaseMetadata(storepb.Engine_OCEANBASE, GetDatabaseMetadataOmni)+ schema.RegisterGetDatabaseMetadata(storepb.Engine_MYSQL, GetDatabaseMetadata)+ schema.RegisterGetDatabaseMetadata(storepb.Engine_OCEANBASE, GetDatabaseMetadata)}-// GetDatabaseMetadataOmni parses MySQL schema DDL text and returns database metadata-// using the omni catalog. This replaces the ANTLR-based GetDatabaseMetadata.-func GetDatabaseMetadataOmni(schemaText string) (*storepb.DatabaseSchemaMetadata, error) {+// GetDatabaseMetadata parses MySQL schema DDL text and returns database metadata+// using the omni catalog.+func GetDatabaseMetadata(schemaText string) (*storepb.DatabaseSchemaMetadata, error) {if schemaText == "" {return &storepb.DatabaseSchemaMetadata{}, nil}diff --git a/backend/plugin/schema/mysql/get_database_metadata_omni_test.go b/backend/plugin/schema/mysql/get_database_metadata_test.gosimilarity index 99%rename from backend/plugin/schema/mysql/get_database_metadata_omni_test.gorename to backend/plugin/schema/mysql/get_database_metadata_test.goindex da0dbcf912..f043f5f8df 100644--- a/backend/plugin/schema/mysql/get_database_metadata_omni_test.go+++ b/backend/plugin/schema/mysql/get_database_metadata_test.go@@ -530,8 +530,8 @@ CREATE TABLE json_features (require.NoError(t, err)// Get metadata from the omni parser, the function registered for- // the production diff path (see get_database_metadata_omni.go).- parsedMetadata, err := GetDatabaseMetadataOmni(tc.ddl)+ // the production diff path (see get_database_metadata.go).+ parsedMetadata, err := GetDatabaseMetadata(tc.ddl)require.NoError(t, err)// Compare metadatadiff --git a/backend/plugin/schema/mysql/get_multi_file_definition_test.go b/backend/plugin/schema/mysql/get_multi_file_definition_test.goindex 52c966888f..2cab011688 100644--- a/backend/plugin/schema/mysql/get_multi_file_definition_test.go+++ b/backend/plugin/schema/mysql/get_multi_file_definition_test.go@@ -115,7 +115,7 @@ func TestFileNameAllocatorReservesGeneratedSuffix(t *testing.T) {// yields one entry per file.//// Shared helpers (liveServers, loadRealWorld, dumpSDL, statementCount, realWorldSchemas,-// objectCounts) are declared in sdl_migration_omni_test.go.+// objectCounts) are declared in sdl_migration_test.go.// concatMultiFile reproduces the declarative rollout concatenation from// action/command/file.go: sort files by path lexically, then join contents with a singlediff --git a/backend/plugin/schema/mysql/sdl_migration_omni.go b/backend/plugin/schema/mysql/sdl_migration.gosimilarity index 99%rename from backend/plugin/schema/mysql/sdl_migration_omni.gorename to backend/plugin/schema/mysql/sdl_migration.goindex 1e6c2f1aa7..e86176377c 100644--- a/backend/plugin/schema/mysql/sdl_migration_omni.go+++ b/backend/plugin/schema/mysql/sdl_migration.go@@ -328,7 +328,7 @@ func mysqlLineCommentEnd(sql string, i int) int {// mysqlSDLDropAdvices analyzes the version-aware SDL migration plan from the current// (dumped) schema to the user SDL and emits a WARNING advice for each destructive or-// in-place-replace operation, mirroring pg/sdl_migration_omni.go's pgSDLDropAdvices.+// in-place-replace operation, mirroring pg/sdl_migration.go's pgSDLDropAdvices.// engineVersion is threaded so the plan is built against the version-correct stored form// (a 5.7 schema is not phantom-diffed by the utf8mb4 default-collation gap), keeping the// drop set free of false positives.diff --git a/backend/plugin/schema/mysql/sdl_migration_omni_test.go b/backend/plugin/schema/mysql/sdl_migration_test.gosimilarity index 99%rename from backend/plugin/schema/mysql/sdl_migration_omni_test.gorename to backend/plugin/schema/mysql/sdl_migration_test.goindex 5c1dbd4ec4..b1bca794fd 100644--- a/backend/plugin/schema/mysql/sdl_migration_omni_test.go+++ b/backend/plugin/schema/mysql/sdl_migration_test.go@@ -3018,14 +3018,14 @@ func TestSDLStressDropHeavy(t *testing.T) {}// TestSDLStressDropAdvicesViewRoutineGap PINS a third real (B) bug found by the stress-// test: mysqlSDLDropAdvices (backend/plugin/schema/mysql/sdl_migration_omni.go) emits NO+// test: mysqlSDLDropAdvices (backend/plugin/schema/mysql/sdl_migration.go) emits NO// advice at all for any view / function / procedure / trigger / event operation — neither a// DROP advice for a standalone drop nor a REPLACE advice for a redefinition. So a// declarative release that drops or replaces a view/routine/trigger/event gives the user// ZERO destructive-operation warning. Affects both 5.7 and 8.0; the generated migration DDL// itself is correct (it does drop/replace) — only the advice walker is wrong.//-// Two compounding faults in the replace-pair detection (sdl_migration_omni.go L205-294):+// Two compounding faults in the replace-pair detection (sdl_migration.go L205-294)://// 1. The premise is wrong for this omni build. The code assumes a redefinition is rendered// as an OpDrop<Obj> followed by an OpCreate<Obj> of the same name, and classifies thediff --git a/backend/plugin/schema/mysql/walk_through_omni.go b/backend/plugin/schema/mysql/walk_through.gosimilarity index 99%rename from backend/plugin/schema/mysql/walk_through_omni.gorename to backend/plugin/schema/mysql/walk_through.goindex 80f9702135..f794328252 100644--- a/backend/plugin/schema/mysql/walk_through_omni.go+++ b/backend/plugin/schema/mysql/walk_through.go@@ -19,12 +19,12 @@ import ()func init() {- schema.RegisterWalkThroughWithContext(storepb.Engine_MYSQL, WalkThroughOmni)- schema.RegisterWalkThroughWithContext(storepb.Engine_MARIADB, WalkThroughOmni)- schema.RegisterWalkThroughWithContext(storepb.Engine_OCEANBASE, WalkThroughOmni)+ schema.RegisterWalkThroughWithContext(storepb.Engine_MYSQL, WalkThroughWithContext)+ schema.RegisterWalkThroughWithContext(storepb.Engine_MARIADB, WalkThroughWithContext)+ schema.RegisterWalkThroughWithContext(storepb.Engine_OCEANBASE, WalkThroughWithContext)}-// WalkThroughOmni performs DDL simulation using the omni MySQL catalog.+// WalkThroughWithContext performs DDL simulation using the omni MySQL catalog.// Flow:// 1. Create the catalog and select the target database.// 2. loadWalkThroughCatalog: install each object individually with per-object@@ -33,7 +33,7 @@ func init() {// 3. catalog.Exec(userSQL) → execute user DDL// 4. Map errors → *storepb.Advice// 5. Convert updated catalog → DatabaseMetadata (for downstream rules)-func WalkThroughOmni(ctx schema.WalkThroughContext, d *model.DatabaseMetadata, asts []base.AST) *storepb.Advice {+func WalkThroughWithContext(ctx schema.WalkThroughContext, d *model.DatabaseMetadata, asts []base.AST) *storepb.Advice {if ctx.RawSQL == "" {return nil}diff --git a/backend/plugin/schema/mysql/walk_through_loader_test.go b/backend/plugin/schema/mysql/walk_through_loader_test.goindex 9cae3f27b8..8126cae1a7 100644--- a/backend/plugin/schema/mysql/walk_through_loader_test.go+++ b/backend/plugin/schema/mysql/walk_through_loader_test.go@@ -17,7 +17,7 @@ import (const testDBName = "testdb"// newLoaderTestCatalog returns a catalog with the test database created and-// selected, matching the setup WalkThroughOmni performs before the loader runs.+// selected, matching the setup WalkThroughWithContext performs before the loader runs.func newLoaderTestCatalog(t *testing.T) *catalog.Catalog {t.Helper()c := catalog.New()diff --git a/backend/plugin/schema/mysql/walk_through_omni_test.go b/backend/plugin/schema/mysql/walk_through_test.gosimilarity index 90%rename from backend/plugin/schema/mysql/walk_through_omni_test.gorename to backend/plugin/schema/mysql/walk_through_test.goindex c6c0c2e418..06e37f0ac6 100644--- a/backend/plugin/schema/mysql/walk_through_omni_test.go+++ b/backend/plugin/schema/mysql/walk_through_test.go@@ -57,7 +57,7 @@ func TestWalkThrough(t *testing.T) {stmts, _ := sm.GetStatementsForChecks(storepb.Engine_MYSQL, test.Statement)asts := base.ExtractASTs(stmts)- advice := WalkThroughOmni(schema.WalkThroughContext{RawSQL: test.Statement}, state, asts)+ advice := WalkThroughWithContext(schema.WalkThroughContext{RawSQL: test.Statement}, state, asts)if advice != nil {// Compare the advice fieldsrequire.NotNil(t, test.Advice, "unexpected advice for statement %q: %+v", test.Statement, advice)@@ -84,7 +84,7 @@ func TestWalkThrough(t *testing.T) {}}-func TestWalkThroughOmniCreateTableIfNotExistsCTASExistingTable(t *testing.T) {+func TestWalkThroughCreateTableIfNotExistsCTASExistingTable(t *testing.T) {originDatabase := &storepb.DatabaseSchemaMetadata{Name: "test",Schemas: []*storepb.SchemaMetadata{@@ -118,17 +118,17 @@ func TestWalkThroughOmniCreateTableIfNotExistsCTASExistingTable(t *testing.T) {require.True(t, ok)require.True(t, createTable.IfNotExists)- advice := WalkThroughOmni(schema.WalkThroughContext{RawSQL: statement}, state, asts)+ advice := WalkThroughWithContext(schema.WalkThroughContext{RawSQL: statement}, state, asts)require.Nil(t, advice)require.NotNil(t, state.GetSchemaMetadata("").GetTable("t1"))}-// TestWalkThroughOmniSRIDInvisible verifies the omni catalog -> storepb.ColumnMetadata+// TestWalkThroughSRIDInvisible verifies the omni catalog -> storepb.ColumnMetadata// conversion (tableToProto) carries the spatial SRID (presence + value, including the-// valid explicit SRID 0) and the INVISIBLE flag. Without this the WalkThroughOmni+// valid explicit SRID 0) and the INVISIBLE flag. Without this the WalkThroughWithContext// simulation path — used to compute the schema a changeset would produce — would silently// drop these attributes, mirroring the v1-converter gap.-func TestWalkThroughOmniSRIDInvisible(t *testing.T) {+func TestWalkThroughSRIDInvisible(t *testing.T) {state := model.NewDatabaseMetadata(&storepb.DatabaseSchemaMetadata{Name: "test"}, nil, nil, storepb.Engine_MYSQL, true)statement := "CREATE TABLE t (" +"id INT PRIMARY KEY, " +@@ -140,7 +140,7 @@ func TestWalkThroughOmniSRIDInvisible(t *testing.T) {stmts, _ := sm.GetStatementsForChecks(storepb.Engine_MYSQL, statement)asts := base.ExtractASTs(stmts)- advice := WalkThroughOmni(schema.WalkThroughContext{RawSQL: statement}, state, asts)+ advice := WalkThroughWithContext(schema.WalkThroughContext{RawSQL: statement}, state, asts)require.Nil(t, advice)cols := map[string]*storepb.ColumnMetadata{}@@ -161,14 +161,14 @@ func TestWalkThroughOmniSRIDInvisible(t *testing.T) {require.False(t, cols["g4326"].IsInvisible)}-// TestWalkThroughOmniSRIDInvisibleSeeded verifies the reverse leg of the WalkThroughOmni+// TestWalkThroughSRIDInvisibleSeeded verifies the reverse leg of the WalkThroughWithContext// round-trip: when the walk-through starts from already-synced metadata that carries SRID// / INVISIBLE columns, the proto->catalog seeding (wtBuildColumnDef) must install those// attributes into the omni catalog so that running an UNRELATED DDL does not strip them// from the resulting proto. Without seeding, the pre-existing columns load as// plain/no-SRID and — because columnsEqual now compares these fields — surface as phantom// changes.-func TestWalkThroughOmniSRIDInvisibleSeeded(t *testing.T) {+func TestWalkThroughSRIDInvisibleSeeded(t *testing.T) {origin := &storepb.DatabaseSchemaMetadata{Name: "test",Schemas: []*storepb.SchemaMetadata{{@@ -195,7 +195,7 @@ func TestWalkThroughOmniSRIDInvisibleSeeded(t *testing.T) {sm := sheet.NewManager()stmts, _ := sm.GetStatementsForChecks(storepb.Engine_MYSQL, statement)asts := base.ExtractASTs(stmts)- advice := WalkThroughOmni(schema.WalkThroughContext{RawSQL: statement}, state, asts)+ advice := WalkThroughWithContext(schema.WalkThroughContext{RawSQL: statement}, state, asts)require.Nil(t, advice)geo := state.GetSchemaMetadata("").GetTable("geo")diff --git a/backend/plugin/schema/oracle/get_database_metadata.go b/backend/plugin/schema/oracle/get_database_metadata.goindex f88693b9ac..ea5ba7cc64 100644--- a/backend/plugin/schema/oracle/get_database_metadata.go+++ b/backend/plugin/schema/oracle/get_database_metadata.go@@ -1,7 +1,15 @@package oracleimport (+ "fmt"+ "slices"+ "strings"++ "github.com/bytebase/omni/oracle/ast"+ "github.com/pkg/errors"+storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ plsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/plsql""github.com/bytebase/bytebase/backend/plugin/schema")@@ -9,7 +17,892 @@ func init() {schema.RegisterGetDatabaseMetadata(storepb.Engine_ORACLE, GetDatabaseMetadata)}-// GetDatabaseMetadata parses the Oracle schema text and returns the database metadata.+// GetDatabaseMetadata parses Oracle schema DDL text and returns database metadata+// using the omni parser AST.func GetDatabaseMetadata(schemaText string) (*storepb.DatabaseSchemaMetadata, error) {- return GetDatabaseMetadataOmni(schemaText)+ list, err := plsqlparser.ParsePLSQL(schemaText)+ if err != nil {+ return nil, errors.Wrapf(err, "failed to parse Oracle schema")+ }+ if list == nil || len(list.Items) == 0 {+ return nil, errors.New("no parse results")+ }++ extractor := &oracleOmniMetadataExtractor{+ 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),+ checkNames: make(map[string]map[string]bool),+ checkNameNext: make(map[string]map[string]int),+ schemaText: schemaText,+ }++ for _, item := range list.Items {+ raw, ok := item.(*ast.RawStmt)+ if !ok || raw.Stmt == nil {+ continue+ }+ extractor.extractStatement(raw.Stmt)+ }++ return extractor.databaseMetadata(), nil+}++type oracleOmniMetadataExtractor struct {+ currentDatabase string+ currentSchema string+ 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+ checkNames map[string]map[string]bool+ checkNameNext map[string]map[string]int+ schemaText string+}++func (e *oracleOmniMetadataExtractor) databaseMetadata() *storepb.DatabaseSchemaMetadata {+ e.resolveForeignKeyReferencedColumns()++ schemaMetadata := &storepb.DatabaseSchemaMetadata{+ Name: e.currentDatabase,+ Schemas: []*storepb.SchemaMetadata{},+ }+ schema := &storepb.SchemaMetadata{+ Name: e.currentSchema,+ Tables: []*storepb.TableMetadata{},+ Views: []*storepb.ViewMetadata{},+ MaterializedViews: []*storepb.MaterializedViewMetadata{},+ Procedures: []*storepb.ProcedureMetadata{},+ Functions: []*storepb.FunctionMetadata{},+ Sequences: []*storepb.SequenceMetadata{},+ Packages: []*storepb.PackageMetadata{},+ }++ var tableNames []string+ for name := range e.tables {+ if _, ok := e.materializedViews[name]; !ok {+ tableNames = append(tableNames, name)+ }+ }+ slices.Sort(tableNames)+ for _, name := range tableNames {+ schema.Tables = append(schema.Tables, e.tables[name])+ }++ var viewNames []string+ for name := range e.views {+ viewNames = append(viewNames, name)+ }+ slices.Sort(viewNames)+ for _, name := range viewNames {+ schema.Views = append(schema.Views, e.views[name])+ }++ var materializedViewNames []string+ for name := range e.materializedViews {+ materializedViewNames = append(materializedViewNames, name)+ }+ slices.Sort(materializedViewNames)+ for _, name := range materializedViewNames {+ schema.MaterializedViews = append(schema.MaterializedViews, e.materializedViews[name])+ }++ var functionNames []string+ for name := range e.functions {+ functionNames = append(functionNames, name)+ }+ slices.Sort(functionNames)+ for _, name := range functionNames {+ schema.Functions = append(schema.Functions, e.functions[name])+ }++ var procedureNames []string+ for name := range e.procedures {+ procedureNames = append(procedureNames, name)+ }+ slices.Sort(procedureNames)+ for _, name := range procedureNames {+ schema.Procedures = append(schema.Procedures, e.procedures[name])+ }++ var sequenceNames []string+ for name := range e.sequences {+ sequenceNames = append(sequenceNames, name)+ }+ slices.Sort(sequenceNames)+ for _, name := range sequenceNames {+ schema.Sequences = append(schema.Sequences, e.sequences[name])+ }++ var packageNames []string+ for name := range e.packages {+ packageNames = append(packageNames, name)+ }+ slices.Sort(packageNames)+ for _, name := range packageNames {+ schema.Packages = append(schema.Packages, e.packages[name])+ }++ schemaMetadata.Schemas = append(schemaMetadata.Schemas, schema)+ return schemaMetadata+}++func (e *oracleOmniMetadataExtractor) getOrCreateTable(tableName string) *storepb.TableMetadata {+ if table, ok := e.tables[tableName]; ok {+ 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+}++func (e *oracleOmniMetadataExtractor) extractStatement(stmt ast.StmtNode) {+ switch n := stmt.(type) {+ case *ast.CreateTableStmt:+ e.extractCreateTable(n)+ case *ast.CreateIndexStmt:+ e.extractCreateIndex(n)+ case *ast.CreateViewStmt:+ e.extractCreateView(n)+ case *ast.CreateSchemaStmt:+ e.extractCreateSchema(n)+ case *ast.CreateSequenceStmt:+ e.extractCreateSequence(n)+ case *ast.CreateProcedureStmt:+ if name := objectName(n.Name); name != "" {+ e.procedures[name] = &storepb.ProcedureMetadata{Name: name, Definition: e.definitionText(n)}+ }+ case *ast.CreateFunctionStmt:+ if name := objectName(n.Name); name != "" {+ e.functions[name] = &storepb.FunctionMetadata{Name: name, Definition: e.functionDefinitionText(n)}+ }+ case *ast.CreatePackageStmt:+ if name := objectName(n.Name); name != "" {+ e.extractCreatePackage(name, n)+ }+ case *ast.CreateTriggerStmt:+ e.extractCreateTrigger(n)+ case *ast.AlterTableStmt:+ e.extractAlterTable(n)+ case *ast.CommentStmt:+ e.extractComment(n)+ default:+ }+}++func (e *oracleOmniMetadataExtractor) extractCreateSchema(n *ast.CreateSchemaStmt) {+ if n.SchemaName != "" {+ e.currentSchema = n.SchemaName+ }+ for _, item := range listItems(n.Stmts) {+ stmt, ok := item.(ast.StmtNode)+ if !ok {+ continue+ }+ e.extractStatement(stmt)+ }+}++func (e *oracleOmniMetadataExtractor) extractCreateTable(n *ast.CreateTableStmt) {+ tableName := objectName(n.Name)+ if tableName == "" {+ return+ }+ if n.Name.Schema != "" {+ e.currentSchema = n.Name.Schema+ }++ table := e.getOrCreateTable(tableName)+ for _, item := range listItems(n.Columns) {+ column, ok := item.(*ast.ColumnDef)+ if !ok {+ continue+ }+ e.extractColumn(column, table)+ }+ for _, item := range listItems(n.Constraints) {+ constraint, ok := item.(*ast.TableConstraint)+ if !ok {+ continue+ }+ e.extractTableConstraint(constraint, table)+ }+}++func (e *oracleOmniMetadataExtractor) extractColumn(n *ast.ColumnDef, table *storepb.TableMetadata) {+ column := &storepb.ColumnMetadata{+ Name: n.Name,+ Type: "VARCHAR2(100)",+ Nullable: true,+ Position: int32(len(table.Columns) + 1),+ }+ if n.TypeName != nil {+ column.Type = normalizeDataTypeText(e.nodeText(n.TypeName))+ } else if n.Domain != nil {+ column.Type = objectName(n.Domain)+ }+ if n.Default != nil {+ column.Default = e.nodeText(n.Default)+ }+ if n.Virtual != nil {+ if n.TypeName == nil && n.Domain == nil {+ column.Type = "NUMBER"+ }+ column.Default = e.exprText(n.Virtual)+ }+ column.DefaultOnNull = n.DefaultOnNull+ if n.Collation != "" {+ column.Collation = n.Collation+ }+ if n.Identity != nil {+ column.IsIdentity = true+ column.Nullable = false+ }+ if n.NotNull {+ column.Nullable = false+ }+ if n.Null {+ column.Nullable = true+ }++ for _, item := range listItems(n.Constraints) {+ constraint, ok := item.(*ast.ColumnConstraint)+ if !ok {+ continue+ }+ e.extractColumnConstraint(constraint, table, column)+ }++ table.Columns = append(table.Columns, column)+}++func (e *oracleOmniMetadataExtractor) extractColumnConstraint(n *ast.ColumnConstraint, table *storepb.TableMetadata, column *storepb.ColumnMetadata) {+ switch n.Type {+ case ast.CONSTRAINT_NOT_NULL:+ column.Nullable = false+ case ast.CONSTRAINT_NULL:+ column.Nullable = true+ case ast.CONSTRAINT_DEFAULT:+ if n.Expr != nil {+ column.Default = e.nodeText(n.Expr)+ }+ case ast.CONSTRAINT_PRIMARY:+ column.Nullable = false+ if !hasPrimaryIndex(table) {+ table.Indexes = append(table.Indexes, &storepb.IndexMetadata{+ Name: fallbackName(n.Name, fmt.Sprintf("PK_%s", table.Name)),+ Primary: true,+ Unique: true,+ Type: "NORMAL",+ Expressions: []string{column.Name},+ Visible: true,+ IsConstraint: true,+ })+ }+ case ast.CONSTRAINT_UNIQUE:+ name := fallbackName(n.Name, fmt.Sprintf("UK_%s_%s", table.Name, column.Name))+ if !hasUniqueIndex(table, []string{column.Name}) {+ table.Indexes = append(table.Indexes, &storepb.IndexMetadata{+ Name: name,+ Unique: true,+ Type: "NORMAL",+ Expressions: []string{column.Name},+ Visible: true,+ IsConstraint: true,+ })+ }+ case ast.CONSTRAINT_CHECK:+ e.appendCheckConstraint(table, e.checkConstraintName(table, n.Name, fmt.Sprintf("CHK_%s_%s", table.Name, column.Name)), n.Expr)+ case ast.CONSTRAINT_FOREIGN:+ e.appendForeignKey(table, fallbackName(n.Name, fmt.Sprintf("FK_%s_%s", table.Name, column.Name)), []string{column.Name}, n.RefTable, n.RefColumns, n.OnDelete)+ default:+ }+}++func (e *oracleOmniMetadataExtractor) extractTableConstraint(n *ast.TableConstraint, table *storepb.TableMetadata) {+ columns := stringList(n.Columns)+ switch n.Type {+ case ast.CONSTRAINT_PRIMARY:+ if len(columns) == 0 {+ return+ }+ table.Indexes = append(table.Indexes, &storepb.IndexMetadata{+ Name: fallbackName(n.Name, fmt.Sprintf("PK_%s", table.Name)),+ Primary: true,+ Unique: true,+ Type: "NORMAL",+ Expressions: columns,+ Visible: true,+ IsConstraint: true,+ })+ markColumnsNotNull(table, columns)+ case ast.CONSTRAINT_UNIQUE:+ if len(columns) == 0 {+ return+ }+ table.Indexes = append(table.Indexes, &storepb.IndexMetadata{+ Name: fallbackName(n.Name, fmt.Sprintf("UK_%s_%d", table.Name, len(table.Indexes)+1)),+ Unique: true,+ Type: "NORMAL",+ Expressions: columns,+ Visible: false,+ IsConstraint: true,+ })+ case ast.CONSTRAINT_CHECK:+ e.appendCheckConstraint(table, e.checkConstraintName(table, n.Name, fmt.Sprintf("CHK_%s_%d", table.Name, len(table.CheckConstraints)+1)), n.Expr)+ case ast.CONSTRAINT_FOREIGN:+ e.appendForeignKey(table, fallbackName(n.Name, fmt.Sprintf("FK_%s_%d", table.Name, len(table.ForeignKeys)+1)), columns, n.RefTable, n.RefColumns, n.OnDelete)+ default:+ }+}++func (e *oracleOmniMetadataExtractor) extractAlterTable(n *ast.AlterTableStmt) {+ tableName := objectName(n.Name)+ if tableName == "" {+ return+ }+ table := e.getOrCreateTable(tableName)+ for _, item := range listItems(n.Actions) {+ action, ok := item.(*ast.AlterTableCmd)+ if !ok {+ continue+ }+ switch action.Action {+ case ast.AT_ADD_COLUMN:+ if action.ColumnDef != nil {+ e.extractColumn(action.ColumnDef, table)+ }+ for _, item := range listItems(action.ColumnDefs) {+ column, ok := item.(*ast.ColumnDef)+ if !ok {+ continue+ }+ e.extractColumn(column, table)+ }+ case ast.AT_ADD_CONSTRAINT:+ if action.Constraint != nil {+ e.extractTableConstraint(action.Constraint, table)+ }+ default:+ }+ }+}++func (e *oracleOmniMetadataExtractor) appendCheckConstraint(table *storepb.TableMetadata, name string, expr ast.ExprNode) {+ if expr == nil {+ return+ }+ e.reserveCheckConstraintName(table, name)+ table.CheckConstraints = append(table.CheckConstraints, &storepb.CheckConstraintMetadata{+ Name: name,+ Expression: e.exprText(expr),+ })+}++func (e *oracleOmniMetadataExtractor) checkConstraintName(table *storepb.TableMetadata, name string, fallback string) string {+ if name != "" {+ return name+ }+ return e.uniqueCheckConstraintName(table, fallback)+}++func (e *oracleOmniMetadataExtractor) uniqueCheckConstraintName(table *storepb.TableMetadata, fallback string) string {+ used := e.checkConstraintNameSet(table)+ if !used[fallback] {+ return fallback+ }+ nextByFallback := e.checkConstraintNameNextSet(table)+ next := nextByFallback[fallback]+ if next < 2 {+ next = 2+ }+ for {+ candidate := fmt.Sprintf("%s_%d", fallback, next)+ next+++ if !used[candidate] {+ nextByFallback[fallback] = next+ return candidate+ }+ }+}++func (e *oracleOmniMetadataExtractor) reserveCheckConstraintName(table *storepb.TableMetadata, name string) {+ e.checkConstraintNameSet(table)[name] = true+}++func (e *oracleOmniMetadataExtractor) checkConstraintNameSet(table *storepb.TableMetadata) map[string]bool {+ used := e.checkNames[table.Name]+ if used != nil {+ return used+ }+ used = make(map[string]bool)+ for _, check := range table.CheckConstraints {+ used[check.Name] = true+ }+ e.checkNames[table.Name] = used+ return used+}++func (e *oracleOmniMetadataExtractor) checkConstraintNameNextSet(table *storepb.TableMetadata) map[string]int {+ next := e.checkNameNext[table.Name]+ if next != nil {+ return next+ }+ next = make(map[string]int)+ e.checkNameNext[table.Name] = next+ return next+}++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 == "" {+ return+ }+ foreignKey := &storepb.ForeignKeyMetadata{+ Name: name,+ Columns: columns,+ ReferencedTable: referencedTable,+ ReferencedColumns: referencedColumns,+ OnDelete: onDelete,+ }+ table.ForeignKeys = append(table.ForeignKeys, foreignKey)+}++func (e *oracleOmniMetadataExtractor) resolveForeignKeyReferencedColumns() {+ for _, table := range e.tables {+ var foreignKeys []*storepb.ForeignKeyMetadata+ for _, foreignKey := range table.ForeignKeys {+ if len(foreignKey.ReferencedColumns) == 0 {+ referencedTable := e.tables[foreignKey.ReferencedTable]+ foreignKey.ReferencedColumns = primaryKeyColumns(referencedTable)+ }+ if len(foreignKey.ReferencedColumns) == 0 {+ continue+ }+ foreignKeys = append(foreignKeys, foreignKey)+ }+ table.ForeignKeys = foreignKeys+ }+}++func (e *oracleOmniMetadataExtractor) extractCreateIndex(n *ast.CreateIndexStmt) {+ tableName := objectName(n.Table)+ indexName := objectName(n.Name)+ if tableName == "" || indexName == "" {+ return+ }+ if n.Name.Schema != "" {+ e.currentSchema = n.Name.Schema+ }++ index := &storepb.IndexMetadata{+ Name: indexName,+ Unique: n.Unique,+ Type: "NORMAL",+ Expressions: []string{},+ Visible: !n.Invisible,+ }+ if n.Bitmap {+ index.Type = "BITMAP"+ }++ isFunctionBased := false+ for _, item := range listItems(n.Columns) {+ column, ok := item.(*ast.IndexColumn)+ if !ok {+ continue+ }+ expression := e.indexExpression(column.Expr)+ if expression == "" {+ continue+ }+ if _, ok := column.Expr.(*ast.ColumnRef); !ok {+ isFunctionBased = true+ }+ index.Expressions = append(index.Expressions, expression)+ index.Descending = append(index.Descending, column.Dir == ast.SORTBY_DESC)+ }+ for _, desc := range index.Descending {+ if desc && index.Type == "NORMAL" {+ index.Type = "FUNCTION-BASED NORMAL"+ break+ }+ }+ if isFunctionBased && index.Type == "NORMAL" {+ index.Type = "FUNCTION-BASED NORMAL"+ } else if isFunctionBased && index.Type == "BITMAP" {+ index.Type = "FUNCTION-BASED BITMAP"+ }++ if materializedView := e.materializedViews[tableName]; materializedView != nil {+ materializedView.Indexes = append(materializedView.Indexes, index)+ return+ }+ table := e.getOrCreateTable(tableName)+ table.Indexes = append(table.Indexes, index)+}++func (e *oracleOmniMetadataExtractor) extractCreateView(n *ast.CreateViewStmt) {+ viewName := objectName(n.Name)+ if viewName == "" {+ return+ }+ if n.Name.Schema != "" {+ e.currentSchema = n.Name.Schema+ }++ definition := e.nodeText(n.Query)+ if n.Materialized {+ materializedView := &storepb.MaterializedViewMetadata{+ Name: viewName,+ Definition: definition,+ }+ if table := e.tables[viewName]; table != nil {+ materializedView.Triggers = append(materializedView.Triggers, table.Triggers...)+ materializedView.Indexes = append(materializedView.Indexes, table.Indexes...)+ }+ if definition != "" && !strings.HasSuffix(definition, "\n") {+ materializedView.Definition += "\n"+ }+ e.materializedViews[viewName] = materializedView+ delete(e.tables, viewName)+ return+ }++ view := &storepb.ViewMetadata{+ Name: viewName,+ Definition: definition,+ }+ if table := e.tables[viewName]; table != nil {+ view.Triggers = append(view.Triggers, table.Triggers...)+ delete(e.tables, viewName)+ }+ e.views[viewName] = view+}++func (e *oracleOmniMetadataExtractor) extractCreateSequence(n *ast.CreateSequenceStmt) {+ sequenceName := objectName(n.Name)+ if sequenceName == "" {+ return+ }+ sequence := &storepb.SequenceMetadata{Name: sequenceName}+ if start := e.nodeText(n.StartWith); start != "" {+ sequence.Start = start+ }+ if increment := e.nodeText(n.IncrementBy); increment != "" && increment != "1" {+ sequence.Increment = increment+ }+ e.sequences[sequenceName] = sequence+}++func (e *oracleOmniMetadataExtractor) extractCreatePackage(name string, n *ast.CreatePackageStmt) {+ definition := e.definitionText(n)+ if definition == "" {+ return+ }+ pkg := e.packages[name]+ if pkg == nil {+ e.packages[name] = &storepb.PackageMetadata{Name: name, Definition: definition}+ return+ }+ if pkg.Definition == "" {+ pkg.Definition = definition+ return+ }+ pkg.Definition += "\n\n" + definition+}++func (e *oracleOmniMetadataExtractor) extractCreateTrigger(n *ast.CreateTriggerStmt) {+ triggerName := objectName(n.Name)+ tableName := objectName(n.Table)+ if triggerName == "" || tableName == "" {+ return+ }+ trigger := &storepb.TriggerMetadata{+ Name: triggerName,+ Body: e.definitionText(n),+ }+ e.triggers[triggerName] = trigger+ if view := e.views[tableName]; view != nil {+ view.Triggers = append(view.Triggers, trigger)+ return+ }+ if materializedView := e.materializedViews[tableName]; materializedView != nil {+ materializedView.Triggers = append(materializedView.Triggers, trigger)+ return+ }+ table := e.getOrCreateTable(tableName)+ table.Triggers = append(table.Triggers, trigger)+}++func (e *oracleOmniMetadataExtractor) extractComment(n *ast.CommentStmt) {+ if n.Column != "" {+ table := e.tables[objectName(n.Object)]+ if table == nil {+ return+ }+ for _, column := range table.Columns {+ if column.Name == n.Column {+ column.Comment = n.Comment+ return+ }+ }+ return+ }++ switch n.ObjectType {+ case ast.OBJECT_TABLE, ast.OBJECT_VIEW:+ name := objectName(n.Object)+ if table := e.tables[name]; table != nil {+ table.Comment = n.Comment+ return+ }+ if view := e.views[name]; view != nil {+ view.Comment = n.Comment+ }+ case ast.OBJECT_MATERIALIZED_VIEW:+ if materializedView := e.materializedViews[objectName(n.Object)]; materializedView != nil {+ materializedView.Comment = n.Comment+ }+ default:+ }+}++func (e *oracleOmniMetadataExtractor) indexExpression(expr ast.ExprNode) string {+ switch n := expr.(type) {+ case *ast.ColumnRef:+ return n.Column+ default:+ return e.nodeText(expr)+ }+}++func (e *oracleOmniMetadataExtractor) exprText(expr ast.ExprNode) string {+ switch n := expr.(type) {+ case *ast.BinaryExpr:+ return e.exprText(n.Left) + n.Op + e.exprText(n.Right)+ case *ast.BoolExpr:+ var parts []string+ for _, item := range listItems(n.Args) {+ expr, ok := item.(ast.ExprNode)+ if !ok {+ continue+ }+ parts = append(parts, e.exprText(expr))+ }+ switch n.Boolop {+ case ast.BOOL_AND:+ return strings.Join(parts, "AND")+ case ast.BOOL_OR:+ return strings.Join(parts, "OR")+ case ast.BOOL_NOT:+ return "NOT" + strings.Join(parts, "")+ default:+ return strings.Join(parts, "")+ }+ case *ast.ColumnRef:+ if n.Table != "" {+ return n.Table + "." + n.Column+ }+ return n.Column+ case *ast.InExpr:+ operator := "IN"+ if n.Not {+ operator = "NOTIN"+ }+ return e.exprText(n.Expr) + operator + "(" + strings.Join(e.exprListText(n.List), ",") + ")"+ case *ast.BetweenExpr:+ operator := "BETWEEN"+ if n.Not {+ operator = "NOTBETWEEN"+ }+ return e.exprText(n.Expr) + operator + e.exprText(n.Low) + "AND" + e.exprText(n.High)+ case *ast.LikeExpr:+ operator := "LIKE"+ if n.Not {+ operator = "NOTLIKE"+ }+ result := e.exprText(n.Expr) + operator + e.exprText(n.Pattern)+ if n.Escape != nil {+ result += "ESCAPE" + e.exprText(n.Escape)+ }+ return result+ case *ast.IsExpr:+ operator := "IS"+ if n.Not {+ operator = "ISNOT"+ }+ return e.exprText(n.Expr) + operator + n.Test+ case *ast.ParenExpr:+ return "(" + e.exprText(n.Expr) + ")"+ case *ast.StringLiteral:+ prefix := ""+ if n.IsNChar {+ prefix = "N"+ }+ return prefix + "'" + strings.ReplaceAll(n.Val, "'", "''") + "'"+ case *ast.NumberLiteral:+ return n.Val+ case *ast.NullLiteral:+ return "NULL"+ case *ast.FuncCallExpr:+ return objectName(n.FuncName) + "(" + strings.Join(e.exprListText(n.Args), ",") + ")"+ default:+ return strings.ReplaceAll(e.nodeText(expr), " ", "")+ }+}++func (e *oracleOmniMetadataExtractor) exprListText(list *ast.List) []string {+ var result []string+ for _, item := range listItems(list) {+ expr, ok := item.(ast.ExprNode)+ if !ok {+ continue+ }+ result = append(result, e.exprText(expr))+ }+ return result+}++func (e *oracleOmniMetadataExtractor) functionDefinitionText(node ast.Node) string {+ definition := e.definitionText(node)+ upper := strings.ToUpper(definition)+ if strings.HasPrefix(upper, "CREATE OR REPLACE ") {+ definition = definition[len("CREATE OR REPLACE "):]+ } else if strings.HasPrefix(upper, "CREATE ") {+ definition = definition[len("CREATE "):]+ }+ if definition != "" && !strings.HasPrefix(strings.ToUpper(definition), "FUNCTION") {+ definition = "FUNCTION " + definition+ }+ return definition+}++func (e *oracleOmniMetadataExtractor) definitionText(node ast.Node) string {+ loc := ast.NodeLoc(node)+ if loc.Start < 0 || loc.End < 0 || loc.Start > loc.End || loc.End > len(e.schemaText) {+ return ""+ }+ end := loc.End+ for end < len(e.schemaText) {+ switch e.schemaText[end] {+ case ' ', '\t', '\r', '\n':+ end+++ default:+ if e.schemaText[end] == ';' {+ end+++ }+ return strings.TrimSpace(e.schemaText[loc.Start:end])+ }+ }+ return strings.TrimSpace(e.schemaText[loc.Start:end])+}++func (e *oracleOmniMetadataExtractor) nodeText(node ast.Node) string {+ loc := ast.NodeLoc(node)+ if loc.Start < 0 || loc.End < 0 || loc.Start > loc.End || loc.End > len(e.schemaText) {+ return ""+ }+ return e.schemaText[loc.Start:loc.End]+}++func objectName(name *ast.ObjectName) string {+ if name == nil {+ return ""+ }+ return name.Name+}++func listItems(list *ast.List) []ast.Node {+ if list == nil {+ return nil+ }+ return list.Items+}++func stringList(list *ast.List) []string {+ var result []string+ for _, item := range listItems(list) {+ switch n := item.(type) {+ case *ast.String:+ result = append(result, n.Str)+ case *ast.ColumnRef:+ result = append(result, n.Column)+ default:+ }+ }+ return result+}++func fallbackName(name, fallback string) string {+ if name != "" {+ return name+ }+ return fallback+}++func hasPrimaryIndex(table *storepb.TableMetadata) bool {+ for _, index := range table.Indexes {+ if index.Primary {+ return true+ }+ }+ return false+}++func primaryKeyColumns(table *storepb.TableMetadata) []string {+ if table == nil {+ return nil+ }+ for _, index := range table.Indexes {+ if index.Primary {+ return append([]string(nil), index.Expressions...)+ }+ }+ return nil+}++func hasUniqueIndex(table *storepb.TableMetadata, columns []string) bool {+ for _, index := range table.Indexes {+ if !index.Unique || index.Primary || len(index.Expressions) != len(columns) {+ continue+ }+ matches := true+ for i, column := range columns {+ if index.Expressions[i] != column {+ matches = false+ break+ }+ }+ if matches {+ return true+ }+ }+ return false+}++func markColumnsNotNull(table *storepb.TableMetadata, columns []string) {+ for _, column := range table.Columns {+ if slices.Contains(columns, column.Name) {+ column.Nullable = false+ }+ }}diff --git a/backend/plugin/schema/oracle/get_database_metadata_omni.go b/backend/plugin/schema/oracle/get_database_metadata_omni.godeleted file mode 100644index f9128d1483..0000000000--- a/backend/plugin/schema/oracle/get_database_metadata_omni.go+++ /dev/null@@ -1,903 +0,0 @@-package oracle--import (- "fmt"- "slices"- "strings"-- "github.com/bytebase/omni/oracle/ast"- "github.com/pkg/errors"-- storepb "github.com/bytebase/bytebase/backend/generated-go/store"- plsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/plsql"-)--// GetDatabaseMetadataOmni parses Oracle schema DDL text and returns database metadata-// using the omni parser AST.-func GetDatabaseMetadataOmni(schemaText string) (*storepb.DatabaseSchemaMetadata, error) {- list, err := plsqlparser.ParsePLSQLOmni(schemaText)- if err != nil {- return nil, errors.Wrapf(err, "failed to parse Oracle schema")- }- if list == nil || len(list.Items) == 0 {- return nil, errors.New("no parse results")- }-- extractor := &oracleOmniMetadataExtractor{- 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),- checkNames: make(map[string]map[string]bool),- checkNameNext: make(map[string]map[string]int),- schemaText: schemaText,- }-- for _, item := range list.Items {- raw, ok := item.(*ast.RawStmt)- if !ok || raw.Stmt == nil {- continue- }- extractor.extractStatement(raw.Stmt)- }-- return extractor.databaseMetadata(), nil-}--type oracleOmniMetadataExtractor struct {- currentDatabase string- currentSchema string- 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- checkNames map[string]map[string]bool- checkNameNext map[string]map[string]int- schemaText string-}--func (e *oracleOmniMetadataExtractor) databaseMetadata() *storepb.DatabaseSchemaMetadata {- e.resolveForeignKeyReferencedColumns()-- schemaMetadata := &storepb.DatabaseSchemaMetadata{- Name: e.currentDatabase,- Schemas: []*storepb.SchemaMetadata{},- }- schema := &storepb.SchemaMetadata{- Name: e.currentSchema,- Tables: []*storepb.TableMetadata{},- Views: []*storepb.ViewMetadata{},- MaterializedViews: []*storepb.MaterializedViewMetadata{},- Procedures: []*storepb.ProcedureMetadata{},- Functions: []*storepb.FunctionMetadata{},- Sequences: []*storepb.SequenceMetadata{},- Packages: []*storepb.PackageMetadata{},- }-- var tableNames []string- for name := range e.tables {- if _, ok := e.materializedViews[name]; !ok {- tableNames = append(tableNames, name)- }- }- slices.Sort(tableNames)- for _, name := range tableNames {- schema.Tables = append(schema.Tables, e.tables[name])- }-- var viewNames []string- for name := range e.views {- viewNames = append(viewNames, name)- }- slices.Sort(viewNames)- for _, name := range viewNames {- schema.Views = append(schema.Views, e.views[name])- }-- var materializedViewNames []string- for name := range e.materializedViews {- materializedViewNames = append(materializedViewNames, name)- }- slices.Sort(materializedViewNames)- for _, name := range materializedViewNames {- schema.MaterializedViews = append(schema.MaterializedViews, e.materializedViews[name])- }-- var functionNames []string- for name := range e.functions {- functionNames = append(functionNames, name)- }- slices.Sort(functionNames)- for _, name := range functionNames {- schema.Functions = append(schema.Functions, e.functions[name])- }-- var procedureNames []string- for name := range e.procedures {- procedureNames = append(procedureNames, name)- }- slices.Sort(procedureNames)- for _, name := range procedureNames {- schema.Procedures = append(schema.Procedures, e.procedures[name])- }-- var sequenceNames []string- for name := range e.sequences {- sequenceNames = append(sequenceNames, name)- }- slices.Sort(sequenceNames)- for _, name := range sequenceNames {- schema.Sequences = append(schema.Sequences, e.sequences[name])- }-- var packageNames []string- for name := range e.packages {- packageNames = append(packageNames, name)- }- slices.Sort(packageNames)- for _, name := range packageNames {- schema.Packages = append(schema.Packages, e.packages[name])- }-- schemaMetadata.Schemas = append(schemaMetadata.Schemas, schema)- return schemaMetadata-}--func (e *oracleOmniMetadataExtractor) getOrCreateTable(tableName string) *storepb.TableMetadata {- if table, ok := e.tables[tableName]; ok {- 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-}--func (e *oracleOmniMetadataExtractor) extractStatement(stmt ast.StmtNode) {- switch n := stmt.(type) {- case *ast.CreateTableStmt:- e.extractCreateTable(n)- case *ast.CreateIndexStmt:- e.extractCreateIndex(n)- case *ast.CreateViewStmt:- e.extractCreateView(n)- case *ast.CreateSchemaStmt:- e.extractCreateSchema(n)- case *ast.CreateSequenceStmt:- e.extractCreateSequence(n)- case *ast.CreateProcedureStmt:- if name := objectName(n.Name); name != "" {- e.procedures[name] = &storepb.ProcedureMetadata{Name: name, Definition: e.definitionText(n)}- }- case *ast.CreateFunctionStmt:- if name := objectName(n.Name); name != "" {- e.functions[name] = &storepb.FunctionMetadata{Name: name, Definition: e.functionDefinitionText(n)}- }- case *ast.CreatePackageStmt:- if name := objectName(n.Name); name != "" {- e.extractCreatePackage(name, n)- }- case *ast.CreateTriggerStmt:- e.extractCreateTrigger(n)- case *ast.AlterTableStmt:- e.extractAlterTable(n)- case *ast.CommentStmt:- e.extractComment(n)- default:- }-}--func (e *oracleOmniMetadataExtractor) extractCreateSchema(n *ast.CreateSchemaStmt) {- if n.SchemaName != "" {- e.currentSchema = n.SchemaName- }- for _, item := range listItems(n.Stmts) {- stmt, ok := item.(ast.StmtNode)- if !ok {- continue- }- e.extractStatement(stmt)- }-}--func (e *oracleOmniMetadataExtractor) extractCreateTable(n *ast.CreateTableStmt) {- tableName := objectName(n.Name)- if tableName == "" {- return- }- if n.Name.Schema != "" {- e.currentSchema = n.Name.Schema- }-- table := e.getOrCreateTable(tableName)- for _, item := range listItems(n.Columns) {- column, ok := item.(*ast.ColumnDef)- if !ok {- continue- }- e.extractColumn(column, table)- }- for _, item := range listItems(n.Constraints) {- constraint, ok := item.(*ast.TableConstraint)- if !ok {- continue- }- e.extractTableConstraint(constraint, table)- }-}--func (e *oracleOmniMetadataExtractor) extractColumn(n *ast.ColumnDef, table *storepb.TableMetadata) {- column := &storepb.ColumnMetadata{- Name: n.Name,- Type: "VARCHAR2(100)",- Nullable: true,- Position: int32(len(table.Columns) + 1),- }- if n.TypeName != nil {- column.Type = normalizeDataTypeText(e.nodeText(n.TypeName))- } else if n.Domain != nil {- column.Type = objectName(n.Domain)- }- if n.Default != nil {- column.Default = e.nodeText(n.Default)- }- if n.Virtual != nil {- if n.TypeName == nil && n.Domain == nil {- column.Type = "NUMBER"- }- column.Default = e.exprText(n.Virtual)- }- column.DefaultOnNull = n.DefaultOnNull- if n.Collation != "" {- column.Collation = n.Collation- }- if n.Identity != nil {- column.IsIdentity = true- column.Nullable = false- }- if n.NotNull {- column.Nullable = false- }- if n.Null {- column.Nullable = true- }-- for _, item := range listItems(n.Constraints) {- constraint, ok := item.(*ast.ColumnConstraint)- if !ok {- continue- }- e.extractColumnConstraint(constraint, table, column)- }-- table.Columns = append(table.Columns, column)-}--func (e *oracleOmniMetadataExtractor) extractColumnConstraint(n *ast.ColumnConstraint, table *storepb.TableMetadata, column *storepb.ColumnMetadata) {- switch n.Type {- case ast.CONSTRAINT_NOT_NULL:- column.Nullable = false- case ast.CONSTRAINT_NULL:- column.Nullable = true- case ast.CONSTRAINT_DEFAULT:- if n.Expr != nil {- column.Default = e.nodeText(n.Expr)- }- case ast.CONSTRAINT_PRIMARY:- column.Nullable = false- if !hasPrimaryIndex(table) {- table.Indexes = append(table.Indexes, &storepb.IndexMetadata{- Name: fallbackName(n.Name, fmt.Sprintf("PK_%s", table.Name)),- Primary: true,- Unique: true,- Type: "NORMAL",- Expressions: []string{column.Name},- Visible: true,- IsConstraint: true,- })- }- case ast.CONSTRAINT_UNIQUE:- name := fallbackName(n.Name, fmt.Sprintf("UK_%s_%s", table.Name, column.Name))- if !hasUniqueIndex(table, []string{column.Name}) {- table.Indexes = append(table.Indexes, &storepb.IndexMetadata{- Name: name,- Unique: true,- Type: "NORMAL",- Expressions: []string{column.Name},- Visible: true,- IsConstraint: true,- })- }- case ast.CONSTRAINT_CHECK:- e.appendCheckConstraint(table, e.checkConstraintName(table, n.Name, fmt.Sprintf("CHK_%s_%s", table.Name, column.Name)), n.Expr)- case ast.CONSTRAINT_FOREIGN:- e.appendForeignKey(table, fallbackName(n.Name, fmt.Sprintf("FK_%s_%s", table.Name, column.Name)), []string{column.Name}, n.RefTable, n.RefColumns, n.OnDelete)- default:- }-}--func (e *oracleOmniMetadataExtractor) extractTableConstraint(n *ast.TableConstraint, table *storepb.TableMetadata) {- columns := stringList(n.Columns)- switch n.Type {- case ast.CONSTRAINT_PRIMARY:- if len(columns) == 0 {- return- }- table.Indexes = append(table.Indexes, &storepb.IndexMetadata{- Name: fallbackName(n.Name, fmt.Sprintf("PK_%s", table.Name)),- Primary: true,- Unique: true,- Type: "NORMAL",- Expressions: columns,- Visible: true,- IsConstraint: true,- })- markColumnsNotNull(table, columns)- case ast.CONSTRAINT_UNIQUE:- if len(columns) == 0 {- return- }- table.Indexes = append(table.Indexes, &storepb.IndexMetadata{- Name: fallbackName(n.Name, fmt.Sprintf("UK_%s_%d", table.Name, len(table.Indexes)+1)),- Unique: true,- Type: "NORMAL",- Expressions: columns,- Visible: false,- IsConstraint: true,- })- case ast.CONSTRAINT_CHECK:- e.appendCheckConstraint(table, e.checkConstraintName(table, n.Name, fmt.Sprintf("CHK_%s_%d", table.Name, len(table.CheckConstraints)+1)), n.Expr)- case ast.CONSTRAINT_FOREIGN:- e.appendForeignKey(table, fallbackName(n.Name, fmt.Sprintf("FK_%s_%d", table.Name, len(table.ForeignKeys)+1)), columns, n.RefTable, n.RefColumns, n.OnDelete)- default:- }-}--func (e *oracleOmniMetadataExtractor) extractAlterTable(n *ast.AlterTableStmt) {- tableName := objectName(n.Name)- if tableName == "" {- return- }- table := e.getOrCreateTable(tableName)- for _, item := range listItems(n.Actions) {- action, ok := item.(*ast.AlterTableCmd)- if !ok {- continue- }- switch action.Action {- case ast.AT_ADD_COLUMN:- if action.ColumnDef != nil {- e.extractColumn(action.ColumnDef, table)- }- for _, item := range listItems(action.ColumnDefs) {- column, ok := item.(*ast.ColumnDef)- if !ok {- continue- }- e.extractColumn(column, table)- }- case ast.AT_ADD_CONSTRAINT:- if action.Constraint != nil {- e.extractTableConstraint(action.Constraint, table)- }- default:- }- }-}--func (e *oracleOmniMetadataExtractor) appendCheckConstraint(table *storepb.TableMetadata, name string, expr ast.ExprNode) {- if expr == nil {- return- }- e.reserveCheckConstraintName(table, name)- table.CheckConstraints = append(table.CheckConstraints, &storepb.CheckConstraintMetadata{- Name: name,- Expression: e.exprText(expr),- })-}--func (e *oracleOmniMetadataExtractor) checkConstraintName(table *storepb.TableMetadata, name string, fallback string) string {- if name != "" {- return name- }- return e.uniqueCheckConstraintName(table, fallback)-}--func (e *oracleOmniMetadataExtractor) uniqueCheckConstraintName(table *storepb.TableMetadata, fallback string) string {- used := e.checkConstraintNameSet(table)- if !used[fallback] {- return fallback- }- nextByFallback := e.checkConstraintNameNextSet(table)- next := nextByFallback[fallback]- if next < 2 {- next = 2- }- for {- candidate := fmt.Sprintf("%s_%d", fallback, next)- next++- if !used[candidate] {- nextByFallback[fallback] = next- return candidate- }- }-}--func (e *oracleOmniMetadataExtractor) reserveCheckConstraintName(table *storepb.TableMetadata, name string) {- e.checkConstraintNameSet(table)[name] = true-}--func (e *oracleOmniMetadataExtractor) checkConstraintNameSet(table *storepb.TableMetadata) map[string]bool {- used := e.checkNames[table.Name]- if used != nil {- return used- }- used = make(map[string]bool)- for _, check := range table.CheckConstraints {- used[check.Name] = true- }- e.checkNames[table.Name] = used- return used-}--func (e *oracleOmniMetadataExtractor) checkConstraintNameNextSet(table *storepb.TableMetadata) map[string]int {- next := e.checkNameNext[table.Name]- if next != nil {- return next- }- next = make(map[string]int)- e.checkNameNext[table.Name] = next- return next-}--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 == "" {- return- }- foreignKey := &storepb.ForeignKeyMetadata{- Name: name,- Columns: columns,- ReferencedTable: referencedTable,- ReferencedColumns: referencedColumns,- OnDelete: onDelete,- }- table.ForeignKeys = append(table.ForeignKeys, foreignKey)-}--func (e *oracleOmniMetadataExtractor) resolveForeignKeyReferencedColumns() {- for _, table := range e.tables {- var foreignKeys []*storepb.ForeignKeyMetadata- for _, foreignKey := range table.ForeignKeys {- if len(foreignKey.ReferencedColumns) == 0 {- referencedTable := e.tables[foreignKey.ReferencedTable]- foreignKey.ReferencedColumns = primaryKeyColumns(referencedTable)- }- if len(foreignKey.ReferencedColumns) == 0 {- continue- }- foreignKeys = append(foreignKeys, foreignKey)- }- table.ForeignKeys = foreignKeys- }-}--func (e *oracleOmniMetadataExtractor) extractCreateIndex(n *ast.CreateIndexStmt) {- tableName := objectName(n.Table)- indexName := objectName(n.Name)- if tableName == "" || indexName == "" {- return- }- if n.Name.Schema != "" {- e.currentSchema = n.Name.Schema- }-- index := &storepb.IndexMetadata{- Name: indexName,- Unique: n.Unique,- Type: "NORMAL",- Expressions: []string{},- Visible: !n.Invisible,- }- if n.Bitmap {- index.Type = "BITMAP"- }-- isFunctionBased := false- for _, item := range listItems(n.Columns) {- column, ok := item.(*ast.IndexColumn)- if !ok {- continue- }- expression := e.indexExpression(column.Expr)- if expression == "" {- continue- }- if _, ok := column.Expr.(*ast.ColumnRef); !ok {- isFunctionBased = true- }- index.Expressions = append(index.Expressions, expression)- index.Descending = append(index.Descending, column.Dir == ast.SORTBY_DESC)- }- for _, desc := range index.Descending {- if desc && index.Type == "NORMAL" {- index.Type = "FUNCTION-BASED NORMAL"- break- }- }- if isFunctionBased && index.Type == "NORMAL" {- index.Type = "FUNCTION-BASED NORMAL"- } else if isFunctionBased && index.Type == "BITMAP" {- index.Type = "FUNCTION-BASED BITMAP"- }-- if materializedView := e.materializedViews[tableName]; materializedView != nil {- materializedView.Indexes = append(materializedView.Indexes, index)- return- }- table := e.getOrCreateTable(tableName)- table.Indexes = append(table.Indexes, index)-}--func (e *oracleOmniMetadataExtractor) extractCreateView(n *ast.CreateViewStmt) {- viewName := objectName(n.Name)- if viewName == "" {- return- }- if n.Name.Schema != "" {- e.currentSchema = n.Name.Schema- }-- definition := e.nodeText(n.Query)- if n.Materialized {- materializedView := &storepb.MaterializedViewMetadata{- Name: viewName,- Definition: definition,- }- if table := e.tables[viewName]; table != nil {- materializedView.Triggers = append(materializedView.Triggers, table.Triggers...)- materializedView.Indexes = append(materializedView.Indexes, table.Indexes...)- }- if definition != "" && !strings.HasSuffix(definition, "\n") {- materializedView.Definition += "\n"- }- e.materializedViews[viewName] = materializedView- delete(e.tables, viewName)- return- }-- view := &storepb.ViewMetadata{- Name: viewName,- Definition: definition,- }- if table := e.tables[viewName]; table != nil {- view.Triggers = append(view.Triggers, table.Triggers...)- delete(e.tables, viewName)- }- e.views[viewName] = view-}--func (e *oracleOmniMetadataExtractor) extractCreateSequence(n *ast.CreateSequenceStmt) {- sequenceName := objectName(n.Name)- if sequenceName == "" {- return- }- sequence := &storepb.SequenceMetadata{Name: sequenceName}- if start := e.nodeText(n.StartWith); start != "" {- sequence.Start = start- }- if increment := e.nodeText(n.IncrementBy); increment != "" && increment != "1" {- sequence.Increment = increment- }- e.sequences[sequenceName] = sequence-}--func (e *oracleOmniMetadataExtractor) extractCreatePackage(name string, n *ast.CreatePackageStmt) {- definition := e.definitionText(n)- if definition == "" {- return- }- pkg := e.packages[name]- if pkg == nil {- e.packages[name] = &storepb.PackageMetadata{Name: name, Definition: definition}- return- }- if pkg.Definition == "" {- pkg.Definition = definition- return- }- pkg.Definition += "\n\n" + definition-}--func (e *oracleOmniMetadataExtractor) extractCreateTrigger(n *ast.CreateTriggerStmt) {- triggerName := objectName(n.Name)- tableName := objectName(n.Table)- if triggerName == "" || tableName == "" {- return- }- trigger := &storepb.TriggerMetadata{- Name: triggerName,- Body: e.definitionText(n),- }- e.triggers[triggerName] = trigger- if view := e.views[tableName]; view != nil {- view.Triggers = append(view.Triggers, trigger)- return- }- if materializedView := e.materializedViews[tableName]; materializedView != nil {- materializedView.Triggers = append(materializedView.Triggers, trigger)- return- }- table := e.getOrCreateTable(tableName)- table.Triggers = append(table.Triggers, trigger)-}--func (e *oracleOmniMetadataExtractor) extractComment(n *ast.CommentStmt) {- if n.Column != "" {- table := e.tables[objectName(n.Object)]- if table == nil {- return- }- for _, column := range table.Columns {- if column.Name == n.Column {- column.Comment = n.Comment- return- }- }- return- }-- switch n.ObjectType {- case ast.OBJECT_TABLE, ast.OBJECT_VIEW:- name := objectName(n.Object)- if table := e.tables[name]; table != nil {- table.Comment = n.Comment- return- }- if view := e.views[name]; view != nil {- view.Comment = n.Comment- }- case ast.OBJECT_MATERIALIZED_VIEW:- if materializedView := e.materializedViews[objectName(n.Object)]; materializedView != nil {- materializedView.Comment = n.Comment- }- default:- }-}--func (e *oracleOmniMetadataExtractor) indexExpression(expr ast.ExprNode) string {- switch n := expr.(type) {- case *ast.ColumnRef:- return n.Column- default:- return e.nodeText(expr)- }-}--func (e *oracleOmniMetadataExtractor) exprText(expr ast.ExprNode) string {- switch n := expr.(type) {- case *ast.BinaryExpr:- return e.exprText(n.Left) + n.Op + e.exprText(n.Right)- case *ast.BoolExpr:- var parts []string- for _, item := range listItems(n.Args) {- expr, ok := item.(ast.ExprNode)- if !ok {- continue- }- parts = append(parts, e.exprText(expr))- }- switch n.Boolop {- case ast.BOOL_AND:- return strings.Join(parts, "AND")- case ast.BOOL_OR:- return strings.Join(parts, "OR")- case ast.BOOL_NOT:- return "NOT" + strings.Join(parts, "")- default:- return strings.Join(parts, "")- }- case *ast.ColumnRef:- if n.Table != "" {- return n.Table + "." + n.Column- }- return n.Column- case *ast.InExpr:- operator := "IN"- if n.Not {- operator = "NOTIN"- }- return e.exprText(n.Expr) + operator + "(" + strings.Join(e.exprListText(n.List), ",") + ")"- case *ast.BetweenExpr:- operator := "BETWEEN"- if n.Not {- operator = "NOTBETWEEN"- }- return e.exprText(n.Expr) + operator + e.exprText(n.Low) + "AND" + e.exprText(n.High)- case *ast.LikeExpr:- operator := "LIKE"- if n.Not {- operator = "NOTLIKE"- }- result := e.exprText(n.Expr) + operator + e.exprText(n.Pattern)- if n.Escape != nil {- result += "ESCAPE" + e.exprText(n.Escape)- }- return result- case *ast.IsExpr:- operator := "IS"- if n.Not {- operator = "ISNOT"- }- return e.exprText(n.Expr) + operator + n.Test- case *ast.ParenExpr:- return "(" + e.exprText(n.Expr) + ")"- case *ast.StringLiteral:- prefix := ""- if n.IsNChar {- prefix = "N"- }- return prefix + "'" + strings.ReplaceAll(n.Val, "'", "''") + "'"- case *ast.NumberLiteral:- return n.Val- case *ast.NullLiteral:- return "NULL"- case *ast.FuncCallExpr:- return objectName(n.FuncName) + "(" + strings.Join(e.exprListText(n.Args), ",") + ")"- default:- return strings.ReplaceAll(e.nodeText(expr), " ", "")- }-}--func (e *oracleOmniMetadataExtractor) exprListText(list *ast.List) []string {- var result []string- for _, item := range listItems(list) {- expr, ok := item.(ast.ExprNode)- if !ok {- continue- }- result = append(result, e.exprText(expr))- }- return result-}--func (e *oracleOmniMetadataExtractor) functionDefinitionText(node ast.Node) string {- definition := e.definitionText(node)- upper := strings.ToUpper(definition)- if strings.HasPrefix(upper, "CREATE OR REPLACE ") {- definition = definition[len("CREATE OR REPLACE "):]- } else if strings.HasPrefix(upper, "CREATE ") {- definition = definition[len("CREATE "):]- }- if definition != "" && !strings.HasPrefix(strings.ToUpper(definition), "FUNCTION") {- definition = "FUNCTION " + definition- }- return definition-}--func (e *oracleOmniMetadataExtractor) definitionText(node ast.Node) string {- loc := ast.NodeLoc(node)- if loc.Start < 0 || loc.End < 0 || loc.Start > loc.End || loc.End > len(e.schemaText) {- return ""- }- end := loc.End- for end < len(e.schemaText) {- switch e.schemaText[end] {- case ' ', '\t', '\r', '\n':- end++- default:- if e.schemaText[end] == ';' {- end++- }- return strings.TrimSpace(e.schemaText[loc.Start:end])- }- }- return strings.TrimSpace(e.schemaText[loc.Start:end])-}--func (e *oracleOmniMetadataExtractor) nodeText(node ast.Node) string {- loc := ast.NodeLoc(node)- if loc.Start < 0 || loc.End < 0 || loc.Start > loc.End || loc.End > len(e.schemaText) {- return ""- }- return e.schemaText[loc.Start:loc.End]-}--func objectName(name *ast.ObjectName) string {- if name == nil {- return ""- }- return name.Name-}--func listItems(list *ast.List) []ast.Node {- if list == nil {- return nil- }- return list.Items-}--func stringList(list *ast.List) []string {- var result []string- for _, item := range listItems(list) {- switch n := item.(type) {- case *ast.String:- result = append(result, n.Str)- case *ast.ColumnRef:- result = append(result, n.Column)- default:- }- }- return result-}--func fallbackName(name, fallback string) string {- if name != "" {- return name- }- return fallback-}--func hasPrimaryIndex(table *storepb.TableMetadata) bool {- for _, index := range table.Indexes {- if index.Primary {- return true- }- }- return false-}--func primaryKeyColumns(table *storepb.TableMetadata) []string {- if table == nil {- return nil- }- for _, index := range table.Indexes {- if index.Primary {- return append([]string(nil), index.Expressions...)- }- }- return nil-}--func hasUniqueIndex(table *storepb.TableMetadata, columns []string) bool {- for _, index := range table.Indexes {- if !index.Unique || index.Primary || len(index.Expressions) != len(columns) {- continue- }- matches := true- for i, column := range columns {- if index.Expressions[i] != column {- matches = false- break- }- }- if matches {- return true- }- }- return false-}--func markColumnsNotNull(table *storepb.TableMetadata, columns []string) {- for _, column := range table.Columns {- if slices.Contains(columns, column.Name) {- column.Nullable = false- }- }-}diff --git a/backend/plugin/schema/oracle/get_database_metadata_omni_test.go b/backend/plugin/schema/oracle/get_database_metadata_omni_test.godeleted file mode 100644index e87b05411d..0000000000--- a/backend/plugin/schema/oracle/get_database_metadata_omni_test.go+++ /dev/null@@ -1,487 +0,0 @@-package oracle--import (- "testing"-- "github.com/stretchr/testify/require"-- storepb "github.com/bytebase/bytebase/backend/generated-go/store"- "github.com/bytebase/bytebase/backend/plugin/schema"-)--func TestGetDatabaseMetadataOmni(t *testing.T) {- tests := []struct {- name string- ddl string- verify func(*testing.T, *storepb.DatabaseSchemaMetadata)- }{- {- name: "table_constraints_indexes_view_sequence",- ddl: `-CREATE TABLE DEPARTMENTS (- DEPT_ID NUMBER PRIMARY KEY,- DEPT_NAME VARCHAR2(100) NOT NULL UNIQUE,- MANAGER_ID NUMBER,- CONSTRAINT chk_dept_name CHECK (DEPT_NAME IS NOT NULL)-);--CREATE TABLE EMPLOYEES (- EMP_ID NUMBER,- DEPT_ID NUMBER,- EMAIL VARCHAR2(100) UNIQUE,- SALARY NUMBER(10,2) DEFAULT 0,- CONSTRAINT pk_employees PRIMARY KEY (EMP_ID),- CONSTRAINT fk_emp_dept FOREIGN KEY (DEPT_ID) REFERENCES DEPARTMENTS(DEPT_ID) ON DELETE SET NULL,- CONSTRAINT chk_salary CHECK (SALARY >= 0)-);--CREATE INDEX idx_emp_dept ON EMPLOYEES(DEPT_ID);--CREATE VIEW ACTIVE_EMPLOYEES AS-SELECT EMP_ID, DEPT_ID, EMAIL-FROM EMPLOYEES-WHERE EMAIL IS NOT NULL;--CREATE SEQUENCE emp_seq START WITH 1 INCREMENT BY 1;-`,- verify: func(t *testing.T, metadata *storepb.DatabaseSchemaMetadata) {- schemaMetadata := requireSingleSchema(t, metadata)-- departments := requireTable(t, schemaMetadata, "DEPARTMENTS")- require.Len(t, departments.Columns, 3)- require.Equal(t, "NUMBER", departments.Columns[0].Type)- require.False(t, departments.Columns[0].Nullable)- require.Equal(t, "VARCHAR2(100 BYTE)", departments.Columns[1].Type)- require.False(t, departments.Columns[1].Nullable)- requireIndex(t, departments, "PK_DEPARTMENTS", []string{"DEPT_ID"}, true, true)- requireIndex(t, departments, "UK_DEPARTMENTS_DEPT_NAME", []string{"DEPT_NAME"}, false, true)- requireCheckConstraint(t, departments, "CHK_DEPT_NAME", "DEPT_NAMEISNOTNULL")-- employees := requireTable(t, schemaMetadata, "EMPLOYEES")- require.Len(t, employees.Columns, 4)- require.Equal(t, "0", employees.Columns[3].Default)- requireIndex(t, employees, "PK_EMPLOYEES", []string{"EMP_ID"}, true, true)- 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"}, "SET NULL")-- require.Len(t, schemaMetadata.Views, 1)- require.Equal(t, "ACTIVE_EMPLOYEES", schemaMetadata.Views[0].Name)- require.Contains(t, schemaMetadata.Views[0].Definition, "SELECT EMP_ID, DEPT_ID, EMAIL")-- require.Len(t, schemaMetadata.Sequences, 1)- require.Equal(t, "EMP_SEQ", schemaMetadata.Sequences[0].Name)- require.Equal(t, "1", schemaMetadata.Sequences[0].Start)- },- },- {- name: "create_schema_wrapper",- ddl: `-CREATE SCHEMA AUTHORIZATION HR-CREATE TABLE EMPLOYEES (- EMP_ID NUMBER PRIMARY KEY,- EMAIL VARCHAR2(100)-)-CREATE VIEW EMPLOYEE_VIEW AS-SELECT EMP_ID, EMAIL FROM EMPLOYEES;-`,- verify: func(t *testing.T, metadata *storepb.DatabaseSchemaMetadata) {- schemaMetadata := requireSingleSchema(t, metadata)- require.Equal(t, "HR", schemaMetadata.Name)- employees := requireTable(t, schemaMetadata, "EMPLOYEES")- require.Len(t, employees.Columns, 2)- requireIndex(t, employees, "PK_EMPLOYEES", []string{"EMP_ID"}, true, true)- view := requireView(t, schemaMetadata, "EMPLOYEE_VIEW")- require.Contains(t, view.Definition, "SELECT EMP_ID, EMAIL FROM EMPLOYEES")- },- },- {- name: "comments_on_views_and_materialized_views",- ddl: `-CREATE TABLE PRODUCT_SALES (- PRODUCT_ID NUMBER NOT NULL,- CATEGORY VARCHAR2(50) NOT NULL,- SALES_AMOUNT NUMBER(12,2) NOT NULL-);--CREATE VIEW PRODUCT_SALES_VIEW AS-SELECT PRODUCT_ID, CATEGORY, SALES_AMOUNT-FROM PRODUCT_SALES;--CREATE MATERIALIZED VIEW PRODUCT_SALES_MV-BUILD IMMEDIATE-REFRESH COMPLETE ON DEMAND-AS-SELECT PRODUCT_ID, CATEGORY, SUM(SALES_AMOUNT) AS TOTAL_REVENUE-FROM PRODUCT_SALES-GROUP BY PRODUCT_ID, CATEGORY;--COMMENT ON VIEW PRODUCT_SALES_VIEW IS 'Product sales view';-COMMENT ON MATERIALIZED VIEW PRODUCT_SALES_MV IS 'Product sales materialized view';-`,- verify: func(t *testing.T, metadata *storepb.DatabaseSchemaMetadata) {- schemaMetadata := requireSingleSchema(t, metadata)- require.Equal(t, "Product sales view", requireView(t, schemaMetadata, "PRODUCT_SALES_VIEW").Comment)- require.Len(t, schemaMetadata.MaterializedViews, 1)- require.Equal(t, "PRODUCT_SALES_MV", schemaMetadata.MaterializedViews[0].Name)- require.Equal(t, "Product sales materialized view", schemaMetadata.MaterializedViews[0].Comment)- },- },- {- name: "index_visibility_and_function_based_bitmap",- ddl: `-CREATE TABLE ORDERS (- ID NUMBER PRIMARY KEY,- STATUS VARCHAR2(20)-);--CREATE INDEX idx_orders_status_invisible ON ORDERS(STATUS) INVISIBLE;-CREATE BITMAP INDEX idx_orders_lower_status ON ORDERS(LOWER(STATUS));-`,- verify: func(t *testing.T, metadata *storepb.DatabaseSchemaMetadata) {- orders := requireTable(t, requireSingleSchema(t, metadata), "ORDERS")- invisibleIndex := requireIndexMetadata(t, orders, "IDX_ORDERS_STATUS_INVISIBLE")- require.False(t, invisibleIndex.Visible)- functionBasedBitmapIndex := requireIndexMetadata(t, orders, "IDX_ORDERS_LOWER_STATUS")- require.Equal(t, "FUNCTION-BASED BITMAP", functionBasedBitmapIndex.Type)- require.True(t, functionBasedBitmapIndex.Visible)- },- },- {- name: "instead_of_trigger_on_view",- ddl: `-CREATE TABLE EMPLOYEES (- EMP_ID NUMBER PRIMARY KEY,- EMAIL VARCHAR2(100)-);--CREATE VIEW EMPLOYEE_VIEW AS-SELECT EMP_ID, EMAIL-FROM EMPLOYEES;--CREATE OR REPLACE TRIGGER employee_view_insert_trg-INSTEAD OF INSERT ON EMPLOYEE_VIEW-FOR EACH ROW-BEGIN- NULL;-END;-/-`,- verify: func(t *testing.T, metadata *storepb.DatabaseSchemaMetadata) {- schemaMetadata := requireSingleSchema(t, metadata)- view := requireView(t, schemaMetadata, "EMPLOYEE_VIEW")- require.Len(t, view.Triggers, 1)- require.Equal(t, "EMPLOYEE_VIEW_INSERT_TRG", view.Triggers[0].Name)- require.Nil(t, findTable(schemaMetadata, "EMPLOYEE_VIEW"))- },- },- {- name: "materialized_view_with_index",- ddl: `-CREATE TABLE PRODUCT_SALES (- PRODUCT_ID NUMBER NOT NULL,- CATEGORY VARCHAR2(50) NOT NULL,- SALES_AMOUNT NUMBER(12,2) NOT NULL-);--CREATE MATERIALIZED VIEW PRODUCT_SALES_MV-BUILD IMMEDIATE-REFRESH COMPLETE ON DEMAND-AS-SELECT PRODUCT_ID, CATEGORY, SUM(SALES_AMOUNT) AS TOTAL_REVENUE-FROM PRODUCT_SALES-GROUP BY PRODUCT_ID, CATEGORY;--CREATE INDEX idx_mv_category ON PRODUCT_SALES_MV(CATEGORY);-`,- verify: func(t *testing.T, metadata *storepb.DatabaseSchemaMetadata) {- schemaMetadata := requireSingleSchema(t, metadata)- requireTable(t, schemaMetadata, "PRODUCT_SALES")- require.Len(t, schemaMetadata.MaterializedViews, 1)- require.Equal(t, "PRODUCT_SALES_MV", schemaMetadata.MaterializedViews[0].Name)- require.Contains(t, schemaMetadata.MaterializedViews[0].Definition, "SUM(SALES_AMOUNT)")- requireMaterializedViewIndex(t, schemaMetadata.MaterializedViews[0], "IDX_MV_CATEGORY", []string{"CATEGORY"}, false, false)- require.Nil(t, findTable(schemaMetadata, "PRODUCT_SALES_MV"))- },- },- {- name: "alter_table_add_foreign_key",- ddl: `-CREATE TABLE DEPARTMENTS (- DEPT_ID NUMBER PRIMARY KEY,- MANAGER_ID NUMBER-);--CREATE TABLE EMPLOYEES (- EMP_ID NUMBER PRIMARY KEY-);--ALTER TABLE DEPARTMENTS ADD CONSTRAINT fk_dept_manager- FOREIGN KEY (MANAGER_ID) REFERENCES EMPLOYEES(EMP_ID) ON DELETE SET NULL;-`,- 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"}, "SET NULL")- },- },- {- name: "alter_table_add_column",- ddl: `-CREATE TABLE EMPLOYEES (- EMP_ID NUMBER PRIMARY KEY-);--ALTER TABLE EMPLOYEES ADD (- EMAIL VARCHAR2(100) NOT NULL,- STATUS VARCHAR2(20) DEFAULT 'ACTIVE'-);-`,- verify: func(t *testing.T, metadata *storepb.DatabaseSchemaMetadata) {- employees := requireTable(t, requireSingleSchema(t, metadata), "EMPLOYEES")- require.Len(t, employees.Columns, 3)- require.Equal(t, "EMAIL", employees.Columns[1].Name)- require.Equal(t, "VARCHAR2(100 BYTE)", employees.Columns[1].Type)- require.False(t, employees.Columns[1].Nullable)- require.Equal(t, "STATUS", employees.Columns[2].Name)- require.Equal(t, "VARCHAR2(20 BYTE)", employees.Columns[2].Type)- require.Equal(t, "'ACTIVE'", employees.Columns[2].Default)- },- },- {- name: "inline_constraints_and_omitted_reference_columns",- ddl: `-CREATE TABLE DEPARTMENTS (- DEPT_ID NUMBER PRIMARY KEY-);--CREATE TABLE EMPLOYEES (- EMP_ID NUMBER PRIMARY KEY,- SALARY NUMBER CHECK (SALARY > 0) CHECK (SALARY < 1000000),- DEPT_ID NUMBER REFERENCES DEPARTMENTS,- MANAGER_DEPT_ID NUMBER,- CONSTRAINT fk_manager_dept FOREIGN KEY (MANAGER_DEPT_ID) REFERENCES DEPARTMENTS-);-`,- verify: func(t *testing.T, metadata *storepb.DatabaseSchemaMetadata) {- 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"}, "")- },- },- {- name: "virtual_column",- ddl: `-CREATE TABLE ORDER_ITEMS (- QTY NUMBER,- PRICE NUMBER,- TOTAL AS (QTY * PRICE)-);-`,- verify: func(t *testing.T, metadata *storepb.DatabaseSchemaMetadata) {- orderItems := requireTable(t, requireSingleSchema(t, metadata), "ORDER_ITEMS")- require.Len(t, orderItems.Columns, 3)- require.Equal(t, "TOTAL", orderItems.Columns[2].Name)- require.Equal(t, "NUMBER", orderItems.Columns[2].Type)- require.Equal(t, "QTY*PRICE", orderItems.Columns[2].Default)- },- },- {- name: "escaped_string_literals_in_expressions",- ddl: `-CREATE TABLE AUTHORS (- NAME VARCHAR2(100),- IS_REILLY AS (CASE WHEN NAME = 'O''Reilly' THEN 1 ELSE 0 END),- CONSTRAINT chk_author_name CHECK (NAME <> 'O''Reilly')-);-`,- verify: func(t *testing.T, metadata *storepb.DatabaseSchemaMetadata) {- authors := requireTable(t, requireSingleSchema(t, metadata), "AUTHORS")- require.Len(t, authors.Columns, 2)- require.Equal(t, "CASEWHENNAME='O''Reilly'THEN1ELSE0END", authors.Columns[1].Default)- requireCheckConstraint(t, authors, "CHK_AUTHOR_NAME", "NAME<>'O''Reilly'")- },- },- {- name: "default_on_null_column",- ddl: `-CREATE TABLE ORDERS (- ID NUMBER PRIMARY KEY,- STATUS VARCHAR2(20) DEFAULT ON NULL 'PENDING'-);-`,- verify: func(t *testing.T, metadata *storepb.DatabaseSchemaMetadata) {- orders := requireTable(t, requireSingleSchema(t, metadata), "ORDERS")- require.Len(t, orders.Columns, 2)- require.Equal(t, "STATUS", orders.Columns[1].Name)- require.Equal(t, "'PENDING'", orders.Columns[1].Default)- require.True(t, orders.Columns[1].DefaultOnNull)- },- },- {- name: "package_metadata",- ddl: `-CREATE OR REPLACE PACKAGE financial_utils AS- c_default_currency CONSTANT VARCHAR2(3) := 'USD';- FUNCTION format_currency(p_amount NUMBER) RETURN VARCHAR2;-END financial_utils;-/--CREATE OR REPLACE PACKAGE BODY financial_utils AS- FUNCTION format_currency(p_amount NUMBER) RETURN VARCHAR2 IS- BEGIN- RETURN TO_CHAR(p_amount, 'FM9999990.00');- END format_currency;-END financial_utils;-/-`,- verify: func(t *testing.T, metadata *storepb.DatabaseSchemaMetadata) {- schemaMetadata := requireSingleSchema(t, metadata)- require.Len(t, schemaMetadata.Packages, 1)- require.Equal(t, "FINANCIAL_UTILS", schemaMetadata.Packages[0].Name)- require.Contains(t, schemaMetadata.Packages[0].Definition, "c_default_currency")- require.Contains(t, schemaMetadata.Packages[0].Definition, "FUNCTION format_currency")- require.Contains(t, schemaMetadata.Packages[0].Definition, "PACKAGE BODY financial_utils")- require.Contains(t, schemaMetadata.Packages[0].Definition, "RETURN TO_CHAR")- },- },- }-- for _, tc := range tests {- t.Run(tc.name, func(t *testing.T) {- metadata, err := GetDatabaseMetadataOmni(tc.ddl)- require.NoError(t, err)- tc.verify(t, metadata)- })- }-}--func TestGetDatabaseMetadataUsesOmni(t *testing.T) {- metadata, err := schema.GetDatabaseMetadata(storepb.Engine_ORACLE, `-CREATE TABLE T (- ID NUMBER PRIMARY KEY-);-`)- require.NoError(t, err)-- table := requireTable(t, requireSingleSchema(t, metadata), "T")- require.Len(t, table.Columns, 1)- requireIndex(t, table, "PK_T", []string{"ID"}, true, true)-}--func TestGetDatabaseMetadataOmniParsesSlashTerminatedPLSQLScript(t *testing.T) {- metadata, err := GetDatabaseMetadataOmni(`-CREATE TABLE AUDIT_LOG (- LOG_ID NUMBER PRIMARY KEY-);--CREATE OR REPLACE TRIGGER audit_log_trigger- BEFORE INSERT ON AUDIT_LOG- FOR EACH ROW-BEGIN- NULL;-END;-/-`)- require.NoError(t, err)-- table := requireTable(t, requireSingleSchema(t, metadata), "AUDIT_LOG")- require.Len(t, table.Columns, 1)- requireIndex(t, table, "PK_AUDIT_LOG", []string{"LOG_ID"}, true, true)-}--func requireSingleSchema(t *testing.T, metadata *storepb.DatabaseSchemaMetadata) *storepb.SchemaMetadata {- t.Helper()- require.Len(t, metadata.Schemas, 1)- return metadata.Schemas[0]-}--func requireTable(t *testing.T, schemaMetadata *storepb.SchemaMetadata, name string) *storepb.TableMetadata {- t.Helper()- table := findTable(schemaMetadata, name)- require.NotNil(t, table)- return table-}--func requireView(t *testing.T, schemaMetadata *storepb.SchemaMetadata, name string) *storepb.ViewMetadata {- t.Helper()- for _, view := range schemaMetadata.Views {- if view.Name == name {- return view- }- }- t.Fatalf("view %q not found", name)- return nil-}--func findTable(schemaMetadata *storepb.SchemaMetadata, name string) *storepb.TableMetadata {- for _, table := range schemaMetadata.Tables {- if table.Name == name {- return table- }- }- return nil-}--func requireIndex(t *testing.T, table *storepb.TableMetadata, name string, expressions []string, primary bool, unique bool) {- t.Helper()- index := requireIndexMetadata(t, table, name)- require.Equal(t, expressions, index.Expressions)- require.Equal(t, primary, index.Primary)- require.Equal(t, unique, index.Unique)-}--func requireIndexMetadata(t *testing.T, table *storepb.TableMetadata, name string) *storepb.IndexMetadata {- t.Helper()- for _, index := range table.Indexes {- if index.Name == name {- return index- }- }- t.Fatalf("index %q not found in table %q", name, table.Name)- return nil-}--func requireMaterializedViewIndex(t *testing.T, materializedView *storepb.MaterializedViewMetadata, name string, expressions []string, primary bool, unique bool) {- t.Helper()- for _, index := range materializedView.Indexes {- if index.Name != name {- continue- }- require.Equal(t, expressions, index.Expressions)- require.Equal(t, primary, index.Primary)- require.Equal(t, unique, index.Unique)- return- }- t.Fatalf("index %q not found in materialized view %q", name, materializedView.Name)-}--func requireCheckConstraint(t *testing.T, table *storepb.TableMetadata, name string, expression string) {- t.Helper()- for _, check := range table.CheckConstraints {- if check.Name != name {- continue- }- require.Equal(t, expression, check.Expression)- return- }- 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, onDelete string) {- t.Helper()- for _, fk := range table.ForeignKeys {- if fk.Name != name {- continue- }- require.Equal(t, columns, fk.Columns)- require.Equal(t, referencedTable, fk.ReferencedTable)- require.Equal(t, referencedColumns, fk.ReferencedColumns)- require.Equal(t, onDelete, fk.OnDelete)- return- }- t.Fatalf("foreign key %q not found in table %q", name, table.Name)-}diff --git a/backend/plugin/schema/oracle/get_database_metadata_test.go b/backend/plugin/schema/oracle/get_database_metadata_test.goindex 578557ccfd..09cc9f49d9 100644--- a/backend/plugin/schema/oracle/get_database_metadata_test.go+++ b/backend/plugin/schema/oracle/get_database_metadata_test.go@@ -12,6 +12,7 @@ import ("github.com/bytebase/bytebase/backend/common/testcontainer"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/db"+ "github.com/bytebase/bytebase/backend/plugin/schema")type oracleMetadataTestCase struct {@@ -1502,3 +1503,480 @@ func normalizeDefaultExpression(expr string) string {return expr}++func TestGetDatabaseMetadata(t *testing.T) {+ tests := []struct {+ name string+ ddl string+ verify func(*testing.T, *storepb.DatabaseSchemaMetadata)+ }{+ {+ name: "table_constraints_indexes_view_sequence",+ ddl: `+CREATE TABLE DEPARTMENTS (+ DEPT_ID NUMBER PRIMARY KEY,+ DEPT_NAME VARCHAR2(100) NOT NULL UNIQUE,+ MANAGER_ID NUMBER,+ CONSTRAINT chk_dept_name CHECK (DEPT_NAME IS NOT NULL)+);++CREATE TABLE EMPLOYEES (+ EMP_ID NUMBER,+ DEPT_ID NUMBER,+ EMAIL VARCHAR2(100) UNIQUE,+ SALARY NUMBER(10,2) DEFAULT 0,+ CONSTRAINT pk_employees PRIMARY KEY (EMP_ID),+ CONSTRAINT fk_emp_dept FOREIGN KEY (DEPT_ID) REFERENCES DEPARTMENTS(DEPT_ID) ON DELETE SET NULL,+ CONSTRAINT chk_salary CHECK (SALARY >= 0)+);++CREATE INDEX idx_emp_dept ON EMPLOYEES(DEPT_ID);++CREATE VIEW ACTIVE_EMPLOYEES AS+SELECT EMP_ID, DEPT_ID, EMAIL+FROM EMPLOYEES+WHERE EMAIL IS NOT NULL;++CREATE SEQUENCE emp_seq START WITH 1 INCREMENT BY 1;+`,+ verify: func(t *testing.T, metadata *storepb.DatabaseSchemaMetadata) {+ schemaMetadata := requireSingleSchema(t, metadata)++ departments := requireTable(t, schemaMetadata, "DEPARTMENTS")+ require.Len(t, departments.Columns, 3)+ require.Equal(t, "NUMBER", departments.Columns[0].Type)+ require.False(t, departments.Columns[0].Nullable)+ require.Equal(t, "VARCHAR2(100 BYTE)", departments.Columns[1].Type)+ require.False(t, departments.Columns[1].Nullable)+ requireIndex(t, departments, "PK_DEPARTMENTS", []string{"DEPT_ID"}, true, true)+ requireIndex(t, departments, "UK_DEPARTMENTS_DEPT_NAME", []string{"DEPT_NAME"}, false, true)+ requireCheckConstraint(t, departments, "CHK_DEPT_NAME", "DEPT_NAMEISNOTNULL")++ employees := requireTable(t, schemaMetadata, "EMPLOYEES")+ require.Len(t, employees.Columns, 4)+ require.Equal(t, "0", employees.Columns[3].Default)+ requireIndex(t, employees, "PK_EMPLOYEES", []string{"EMP_ID"}, true, true)+ 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"}, "SET NULL")++ require.Len(t, schemaMetadata.Views, 1)+ require.Equal(t, "ACTIVE_EMPLOYEES", schemaMetadata.Views[0].Name)+ require.Contains(t, schemaMetadata.Views[0].Definition, "SELECT EMP_ID, DEPT_ID, EMAIL")++ require.Len(t, schemaMetadata.Sequences, 1)+ require.Equal(t, "EMP_SEQ", schemaMetadata.Sequences[0].Name)+ require.Equal(t, "1", schemaMetadata.Sequences[0].Start)+ },+ },+ {+ name: "create_schema_wrapper",+ ddl: `+CREATE SCHEMA AUTHORIZATION HR+CREATE TABLE EMPLOYEES (+ EMP_ID NUMBER PRIMARY KEY,+ EMAIL VARCHAR2(100)+)+CREATE VIEW EMPLOYEE_VIEW AS+SELECT EMP_ID, EMAIL FROM EMPLOYEES;+`,+ verify: func(t *testing.T, metadata *storepb.DatabaseSchemaMetadata) {+ schemaMetadata := requireSingleSchema(t, metadata)+ require.Equal(t, "HR", schemaMetadata.Name)+ employees := requireTable(t, schemaMetadata, "EMPLOYEES")+ require.Len(t, employees.Columns, 2)+ requireIndex(t, employees, "PK_EMPLOYEES", []string{"EMP_ID"}, true, true)+ view := requireView(t, schemaMetadata, "EMPLOYEE_VIEW")+ require.Contains(t, view.Definition, "SELECT EMP_ID, EMAIL FROM EMPLOYEES")+ },+ },+ {+ name: "comments_on_views_and_materialized_views",+ ddl: `+CREATE TABLE PRODUCT_SALES (+ PRODUCT_ID NUMBER NOT NULL,+ CATEGORY VARCHAR2(50) NOT NULL,+ SALES_AMOUNT NUMBER(12,2) NOT NULL+);++CREATE VIEW PRODUCT_SALES_VIEW AS+SELECT PRODUCT_ID, CATEGORY, SALES_AMOUNT+FROM PRODUCT_SALES;++CREATE MATERIALIZED VIEW PRODUCT_SALES_MV+BUILD IMMEDIATE+REFRESH COMPLETE ON DEMAND+AS+SELECT PRODUCT_ID, CATEGORY, SUM(SALES_AMOUNT) AS TOTAL_REVENUE+FROM PRODUCT_SALES+GROUP BY PRODUCT_ID, CATEGORY;++COMMENT ON VIEW PRODUCT_SALES_VIEW IS 'Product sales view';+COMMENT ON MATERIALIZED VIEW PRODUCT_SALES_MV IS 'Product sales materialized view';+`,+ verify: func(t *testing.T, metadata *storepb.DatabaseSchemaMetadata) {+ schemaMetadata := requireSingleSchema(t, metadata)+ require.Equal(t, "Product sales view", requireView(t, schemaMetadata, "PRODUCT_SALES_VIEW").Comment)+ require.Len(t, schemaMetadata.MaterializedViews, 1)+ require.Equal(t, "PRODUCT_SALES_MV", schemaMetadata.MaterializedViews[0].Name)+ require.Equal(t, "Product sales materialized view", schemaMetadata.MaterializedViews[0].Comment)+ },+ },+ {+ name: "index_visibility_and_function_based_bitmap",+ ddl: `+CREATE TABLE ORDERS (+ ID NUMBER PRIMARY KEY,+ STATUS VARCHAR2(20)+);++CREATE INDEX idx_orders_status_invisible ON ORDERS(STATUS) INVISIBLE;+CREATE BITMAP INDEX idx_orders_lower_status ON ORDERS(LOWER(STATUS));+`,+ verify: func(t *testing.T, metadata *storepb.DatabaseSchemaMetadata) {+ orders := requireTable(t, requireSingleSchema(t, metadata), "ORDERS")+ invisibleIndex := requireIndexMetadata(t, orders, "IDX_ORDERS_STATUS_INVISIBLE")+ require.False(t, invisibleIndex.Visible)+ functionBasedBitmapIndex := requireIndexMetadata(t, orders, "IDX_ORDERS_LOWER_STATUS")+ require.Equal(t, "FUNCTION-BASED BITMAP", functionBasedBitmapIndex.Type)+ require.True(t, functionBasedBitmapIndex.Visible)+ },+ },+ {+ name: "instead_of_trigger_on_view",+ ddl: `+CREATE TABLE EMPLOYEES (+ EMP_ID NUMBER PRIMARY KEY,+ EMAIL VARCHAR2(100)+);++CREATE VIEW EMPLOYEE_VIEW AS+SELECT EMP_ID, EMAIL+FROM EMPLOYEES;++CREATE OR REPLACE TRIGGER employee_view_insert_trg+INSTEAD OF INSERT ON EMPLOYEE_VIEW+FOR EACH ROW+BEGIN+ NULL;+END;+/+`,+ verify: func(t *testing.T, metadata *storepb.DatabaseSchemaMetadata) {+ schemaMetadata := requireSingleSchema(t, metadata)+ view := requireView(t, schemaMetadata, "EMPLOYEE_VIEW")+ require.Len(t, view.Triggers, 1)+ require.Equal(t, "EMPLOYEE_VIEW_INSERT_TRG", view.Triggers[0].Name)+ require.Nil(t, findTable(schemaMetadata, "EMPLOYEE_VIEW"))+ },+ },+ {+ name: "materialized_view_with_index",+ ddl: `+CREATE TABLE PRODUCT_SALES (+ PRODUCT_ID NUMBER NOT NULL,+ CATEGORY VARCHAR2(50) NOT NULL,+ SALES_AMOUNT NUMBER(12,2) NOT NULL+);++CREATE MATERIALIZED VIEW PRODUCT_SALES_MV+BUILD IMMEDIATE+REFRESH COMPLETE ON DEMAND+AS+SELECT PRODUCT_ID, CATEGORY, SUM(SALES_AMOUNT) AS TOTAL_REVENUE+FROM PRODUCT_SALES+GROUP BY PRODUCT_ID, CATEGORY;++CREATE INDEX idx_mv_category ON PRODUCT_SALES_MV(CATEGORY);+`,+ verify: func(t *testing.T, metadata *storepb.DatabaseSchemaMetadata) {+ schemaMetadata := requireSingleSchema(t, metadata)+ requireTable(t, schemaMetadata, "PRODUCT_SALES")+ require.Len(t, schemaMetadata.MaterializedViews, 1)+ require.Equal(t, "PRODUCT_SALES_MV", schemaMetadata.MaterializedViews[0].Name)+ require.Contains(t, schemaMetadata.MaterializedViews[0].Definition, "SUM(SALES_AMOUNT)")+ requireMaterializedViewIndex(t, schemaMetadata.MaterializedViews[0], "IDX_MV_CATEGORY", []string{"CATEGORY"}, false, false)+ require.Nil(t, findTable(schemaMetadata, "PRODUCT_SALES_MV"))+ },+ },+ {+ name: "alter_table_add_foreign_key",+ ddl: `+CREATE TABLE DEPARTMENTS (+ DEPT_ID NUMBER PRIMARY KEY,+ MANAGER_ID NUMBER+);++CREATE TABLE EMPLOYEES (+ EMP_ID NUMBER PRIMARY KEY+);++ALTER TABLE DEPARTMENTS ADD CONSTRAINT fk_dept_manager+ FOREIGN KEY (MANAGER_ID) REFERENCES EMPLOYEES(EMP_ID) ON DELETE SET NULL;+`,+ 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"}, "SET NULL")+ },+ },+ {+ name: "alter_table_add_column",+ ddl: `+CREATE TABLE EMPLOYEES (+ EMP_ID NUMBER PRIMARY KEY+);++ALTER TABLE EMPLOYEES ADD (+ EMAIL VARCHAR2(100) NOT NULL,+ STATUS VARCHAR2(20) DEFAULT 'ACTIVE'+);+`,+ verify: func(t *testing.T, metadata *storepb.DatabaseSchemaMetadata) {+ employees := requireTable(t, requireSingleSchema(t, metadata), "EMPLOYEES")+ require.Len(t, employees.Columns, 3)+ require.Equal(t, "EMAIL", employees.Columns[1].Name)+ require.Equal(t, "VARCHAR2(100 BYTE)", employees.Columns[1].Type)+ require.False(t, employees.Columns[1].Nullable)+ require.Equal(t, "STATUS", employees.Columns[2].Name)+ require.Equal(t, "VARCHAR2(20 BYTE)", employees.Columns[2].Type)+ require.Equal(t, "'ACTIVE'", employees.Columns[2].Default)+ },+ },+ {+ name: "inline_constraints_and_omitted_reference_columns",+ ddl: `+CREATE TABLE DEPARTMENTS (+ DEPT_ID NUMBER PRIMARY KEY+);++CREATE TABLE EMPLOYEES (+ EMP_ID NUMBER PRIMARY KEY,+ SALARY NUMBER CHECK (SALARY > 0) CHECK (SALARY < 1000000),+ DEPT_ID NUMBER REFERENCES DEPARTMENTS,+ MANAGER_DEPT_ID NUMBER,+ CONSTRAINT fk_manager_dept FOREIGN KEY (MANAGER_DEPT_ID) REFERENCES DEPARTMENTS+);+`,+ verify: func(t *testing.T, metadata *storepb.DatabaseSchemaMetadata) {+ 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"}, "")+ },+ },+ {+ name: "virtual_column",+ ddl: `+CREATE TABLE ORDER_ITEMS (+ QTY NUMBER,+ PRICE NUMBER,+ TOTAL AS (QTY * PRICE)+);+`,+ verify: func(t *testing.T, metadata *storepb.DatabaseSchemaMetadata) {+ orderItems := requireTable(t, requireSingleSchema(t, metadata), "ORDER_ITEMS")+ require.Len(t, orderItems.Columns, 3)+ require.Equal(t, "TOTAL", orderItems.Columns[2].Name)+ require.Equal(t, "NUMBER", orderItems.Columns[2].Type)+ require.Equal(t, "QTY*PRICE", orderItems.Columns[2].Default)+ },+ },+ {+ name: "escaped_string_literals_in_expressions",+ ddl: `+CREATE TABLE AUTHORS (+ NAME VARCHAR2(100),+ IS_REILLY AS (CASE WHEN NAME = 'O''Reilly' THEN 1 ELSE 0 END),+ CONSTRAINT chk_author_name CHECK (NAME <> 'O''Reilly')+);+`,+ verify: func(t *testing.T, metadata *storepb.DatabaseSchemaMetadata) {+ authors := requireTable(t, requireSingleSchema(t, metadata), "AUTHORS")+ require.Len(t, authors.Columns, 2)+ require.Equal(t, "CASEWHENNAME='O''Reilly'THEN1ELSE0END", authors.Columns[1].Default)+ requireCheckConstraint(t, authors, "CHK_AUTHOR_NAME", "NAME<>'O''Reilly'")+ },+ },+ {+ name: "default_on_null_column",+ ddl: `+CREATE TABLE ORDERS (+ ID NUMBER PRIMARY KEY,+ STATUS VARCHAR2(20) DEFAULT ON NULL 'PENDING'+);+`,+ verify: func(t *testing.T, metadata *storepb.DatabaseSchemaMetadata) {+ orders := requireTable(t, requireSingleSchema(t, metadata), "ORDERS")+ require.Len(t, orders.Columns, 2)+ require.Equal(t, "STATUS", orders.Columns[1].Name)+ require.Equal(t, "'PENDING'", orders.Columns[1].Default)+ require.True(t, orders.Columns[1].DefaultOnNull)+ },+ },+ {+ name: "package_metadata",+ ddl: `+CREATE OR REPLACE PACKAGE financial_utils AS+ c_default_currency CONSTANT VARCHAR2(3) := 'USD';+ FUNCTION format_currency(p_amount NUMBER) RETURN VARCHAR2;+END financial_utils;+/++CREATE OR REPLACE PACKAGE BODY financial_utils AS+ FUNCTION format_currency(p_amount NUMBER) RETURN VARCHAR2 IS+ BEGIN+ RETURN TO_CHAR(p_amount, 'FM9999990.00');+ END format_currency;+END financial_utils;+/+`,+ verify: func(t *testing.T, metadata *storepb.DatabaseSchemaMetadata) {+ schemaMetadata := requireSingleSchema(t, metadata)+ require.Len(t, schemaMetadata.Packages, 1)+ require.Equal(t, "FINANCIAL_UTILS", schemaMetadata.Packages[0].Name)+ require.Contains(t, schemaMetadata.Packages[0].Definition, "c_default_currency")+ require.Contains(t, schemaMetadata.Packages[0].Definition, "FUNCTION format_currency")+ require.Contains(t, schemaMetadata.Packages[0].Definition, "PACKAGE BODY financial_utils")+ require.Contains(t, schemaMetadata.Packages[0].Definition, "RETURN TO_CHAR")+ },+ },+ }++ for _, tc := range tests {+ t.Run(tc.name, func(t *testing.T) {+ metadata, err := GetDatabaseMetadata(tc.ddl)+ require.NoError(t, err)+ tc.verify(t, metadata)+ })+ }+}++func TestGetDatabaseMetadataUsesOmni(t *testing.T) {+ metadata, err := schema.GetDatabaseMetadata(storepb.Engine_ORACLE, `+CREATE TABLE T (+ ID NUMBER PRIMARY KEY+);+`)+ require.NoError(t, err)++ table := requireTable(t, requireSingleSchema(t, metadata), "T")+ require.Len(t, table.Columns, 1)+ requireIndex(t, table, "PK_T", []string{"ID"}, true, true)+}++func TestGetDatabaseMetadataParsesSlashTerminatedPLSQLScript(t *testing.T) {+ metadata, err := GetDatabaseMetadata(`+CREATE TABLE AUDIT_LOG (+ LOG_ID NUMBER PRIMARY KEY+);++CREATE OR REPLACE TRIGGER audit_log_trigger+ BEFORE INSERT ON AUDIT_LOG+ FOR EACH ROW+BEGIN+ NULL;+END;+/+`)+ require.NoError(t, err)++ table := requireTable(t, requireSingleSchema(t, metadata), "AUDIT_LOG")+ require.Len(t, table.Columns, 1)+ requireIndex(t, table, "PK_AUDIT_LOG", []string{"LOG_ID"}, true, true)+}++func requireSingleSchema(t *testing.T, metadata *storepb.DatabaseSchemaMetadata) *storepb.SchemaMetadata {+ t.Helper()+ require.Len(t, metadata.Schemas, 1)+ return metadata.Schemas[0]+}++func requireTable(t *testing.T, schemaMetadata *storepb.SchemaMetadata, name string) *storepb.TableMetadata {+ t.Helper()+ table := findTable(schemaMetadata, name)+ require.NotNil(t, table)+ return table+}++func requireView(t *testing.T, schemaMetadata *storepb.SchemaMetadata, name string) *storepb.ViewMetadata {+ t.Helper()+ for _, view := range schemaMetadata.Views {+ if view.Name == name {+ return view+ }+ }+ t.Fatalf("view %q not found", name)+ return nil+}++func findTable(schemaMetadata *storepb.SchemaMetadata, name string) *storepb.TableMetadata {+ for _, table := range schemaMetadata.Tables {+ if table.Name == name {+ return table+ }+ }+ return nil+}++func requireIndex(t *testing.T, table *storepb.TableMetadata, name string, expressions []string, primary bool, unique bool) {+ t.Helper()+ index := requireIndexMetadata(t, table, name)+ require.Equal(t, expressions, index.Expressions)+ require.Equal(t, primary, index.Primary)+ require.Equal(t, unique, index.Unique)+}++func requireIndexMetadata(t *testing.T, table *storepb.TableMetadata, name string) *storepb.IndexMetadata {+ t.Helper()+ for _, index := range table.Indexes {+ if index.Name == name {+ return index+ }+ }+ t.Fatalf("index %q not found in table %q", name, table.Name)+ return nil+}++func requireMaterializedViewIndex(t *testing.T, materializedView *storepb.MaterializedViewMetadata, name string, expressions []string, primary bool, unique bool) {+ t.Helper()+ for _, index := range materializedView.Indexes {+ if index.Name != name {+ continue+ }+ require.Equal(t, expressions, index.Expressions)+ require.Equal(t, primary, index.Primary)+ require.Equal(t, unique, index.Unique)+ return+ }+ t.Fatalf("index %q not found in materialized view %q", name, materializedView.Name)+}++func requireCheckConstraint(t *testing.T, table *storepb.TableMetadata, name string, expression string) {+ t.Helper()+ for _, check := range table.CheckConstraints {+ if check.Name != name {+ continue+ }+ require.Equal(t, expression, check.Expression)+ return+ }+ 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, onDelete string) {+ t.Helper()+ for _, fk := range table.ForeignKeys {+ if fk.Name != name {+ continue+ }+ require.Equal(t, columns, fk.Columns)+ require.Equal(t, referencedTable, fk.ReferencedTable)+ require.Equal(t, referencedColumns, fk.ReferencedColumns)+ require.Equal(t, onDelete, fk.OnDelete)+ return+ }+ t.Fatalf("foreign key %q not found in table %q", name, table.Name)+}diff --git a/backend/plugin/schema/pg/sdl_migration_omni.go b/backend/plugin/schema/pg/sdl_migration.gosimilarity index 100%rename from backend/plugin/schema/pg/sdl_migration_omni.gorename to backend/plugin/schema/pg/sdl_migration.godiff --git a/backend/plugin/schema/pg/sdl_migration_omni_test.go b/backend/plugin/schema/pg/sdl_migration_test.gosimilarity index 100%rename from backend/plugin/schema/pg/sdl_migration_omni_test.gorename to backend/plugin/schema/pg/sdl_migration_test.godiff --git a/backend/plugin/schema/pg/walk_through.go b/backend/plugin/schema/pg/walk_through.goindex 512c4d2b14..20008eced5 100644--- a/backend/plugin/schema/pg/walk_through.go+++ b/backend/plugin/schema/pg/walk_through.go@@ -1,7 +1,12 @@package pgimport (+ "context"++ "github.com/bytebase/omni/pg/catalog"+storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/plugin/advisor/code""github.com/bytebase/bytebase/backend/plugin/parser/base""github.com/bytebase/bytebase/backend/plugin/schema""github.com/bytebase/bytebase/backend/store/model"@@ -12,7 +17,7 @@ const ()func init() {- schema.RegisterWalkThroughWithContext(storepb.Engine_POSTGRES, WalkThroughOmni)+ schema.RegisterWalkThroughWithContext(storepb.Engine_POSTGRES, WalkThroughWithContext)}// WalkThrough walks through the PostgreSQL DDL and builds catalog metadata.@@ -20,7 +25,349 @@ func WalkThrough(d *model.DatabaseMetadata, ast []base.AST) *storepb.Advice {return WalkThroughWithContext(schema.WalkThroughContext{}, d, ast)}-// WalkThroughWithContext walks through the PostgreSQL DDL and builds catalog metadata.-func WalkThroughWithContext(ctx schema.WalkThroughContext, d *model.DatabaseMetadata, ast []base.AST) *storepb.Advice {- return WalkThroughOmni(ctx, d, ast)+// WalkThroughWithContext performs DDL simulation using the omni catalog.+// 1. loadWalkThroughCatalog(metadata) → load existing schema into catalog+// 2. catalog.Exec(userSQL) → execute user DDL, collect per-statement Changes+// 3. Map exec errors → *storepb.Advice+// 4. Merge Changes into original metadata → FinalMetadata for downstream rules+func WalkThroughWithContext(ctx schema.WalkThroughContext, d *model.DatabaseMetadata, _ []base.AST) *storepb.Advice {+ if ctx.RawSQL == "" {+ return nil+ }++ // Step 1: Load existing schema into two catalogs — one as snapshot, one for exec.+ // TODO(BYT-9215): Thread a real context.Context through the call chain instead of using context.Background().+ // WalkThroughContext is not a context.Context and the caller does not pass one.+ catBefore := catalog.New()+ if ctx.SessionUser != "" {+ catBefore.SetSessionUser(ctx.SessionUser)+ }+ if searchPath := getConfiguredSearchPath(d); len(searchPath) > 0 {+ catBefore.SetSearchPath(searchPath)+ }+ if err := loadWalkThroughCatalog(context.Background(), catBefore, d.GetProto()); err != nil {+ return &storepb.Advice{+ Status: storepb.Advice_ERROR,+ Code: code.DDLSimulationFailed.Int32(),+ Title: "Failed to load schema",+ Content: err.Error(),+ StartPosition: &storepb.Position{Line: 0},+ }+ }++ catAfter := catBefore.Clone()++ // Step 2: Execute user SQL on catAfter.+ results, execErr := catAfter.Exec(ctx.RawSQL, &catalog.ExecOptions{ContinueOnError: true})+ if execErr != nil {+ return &storepb.Advice{+ Status: storepb.Advice_ERROR,+ Code: code.DDLSimulationFailed.Int32(),+ Title: "DDL simulation failed",+ Content: execErr.Error(),+ StartPosition: &storepb.Position{Line: 0},+ }+ }++ // Step 3: Report the first exec error.+ for _, r := range results {+ if r.Error == nil {+ continue+ }+ errCode := mapSQLSTATEToCode(r.Error)+ return &storepb.Advice{+ Status: storepb.Advice_ERROR,+ Code: errCode.Int32(),+ Title: "DDL simulation failed",+ Content: r.Error.Error(),+ StartPosition: &storepb.Position{+ Line: int32(r.Line),+ },+ }+ }++ // Step 4: Diff before/after catalogs and apply to original metadata.+ diff := catalog.Diff(catBefore, catAfter)+ if diff != nil && !diff.IsEmpty() {+ newProto := applyDiffToMetadata(d.GetProto(), catBefore, catAfter, diff)+ newMetadata := model.NewDatabaseMetadata(newProto, nil, d.GetConfig(), storepb.Engine_POSTGRES, true)+ d.ReplaceFrom(newMetadata)+ }++ return nil+}++// mapSQLSTATEToCode converts an omni catalog error to a bytebase error code.+func mapSQLSTATEToCode(err error) code.Code {+ catErr, ok := err.(*catalog.Error)+ if !ok {+ return code.DDLSimulationFailed+ }++ switch catErr.Code {+ // Table/relation errors+ case catalog.CodeDuplicateTable:+ return code.TableExists+ case catalog.CodeUndefinedTable:+ return code.TableNotExists++ // Column errors+ case catalog.CodeDuplicateColumn:+ return code.ColumnExists+ case catalog.CodeUndefinedColumn, catalog.CodeInvalidColumnDefinition:+ return code.ColumnNotExists++ // Schema errors+ case catalog.CodeDuplicateSchema:+ return code.RelationExists+ case catalog.CodeUndefinedSchema:+ return code.SchemaNotExists++ // Index/constraint errors+ case catalog.CodeDuplicateObject, catalog.CodeUniqueViolation:+ return code.IndexExists+ case catalog.CodeUndefinedObject:+ return code.IndexNotExists++ // FK errors+ case catalog.CodeInvalidFK, catalog.CodeForeignKeyViolation:+ return code.TableHasFK++ // PK/table definition errors+ case catalog.CodeDuplicatePKey:+ return code.PrimaryKeyExists++ // Type/expression errors+ case catalog.CodeDatatypeMismatch:+ return code.ChangeColumnType+ case catalog.CodeNotNullViolation:+ return code.ColumnCannotNull++ // Syntax+ case catalog.CodeSyntaxError:+ return code.StatementSyntaxError++ // Naming+ case catalog.CodeReservedName:+ return code.NameIsKeywordIdentifier++ default:+ return code.DDLSimulationFailed+ }+}++func getConfiguredSearchPath(d *model.DatabaseMetadata) []string {+ configured := d.GetConfiguredSearchPath()+ if len(configured) == 0 {+ return nil+ }++ searchPath := make([]string, 0, len(configured))+ for _, item := range configured {+ if item.CurrentUser {+ searchPath = append(searchPath, "$user")+ continue+ }+ if item.Schema == "" {+ continue+ }+ searchPath = append(searchPath, item.Schema)+ }+ return searchPath+}++// relationToTableProto converts an omni Relation to a storepb.TableMetadata.+func relationToTableProto(c *catalog.Catalog, rel *catalog.Relation) *storepb.TableMetadata {+ table := &storepb.TableMetadata{+ Name: rel.Name,+ }++ // Columns.+ for _, col := range rel.Columns {+ colMeta := &storepb.ColumnMetadata{+ Name: col.Name,+ Position: int32(col.AttNum),+ Type: c.FormatType(col.TypeOID, col.TypeMod),+ Nullable: !col.NotNull,+ Default: col.Default,+ }+ if col.Generated == 's' {+ colMeta.Generation = &storepb.GenerationMetadata{+ Type: storepb.GenerationMetadata_TYPE_STORED,+ Expression: col.GenerationExpr,+ }+ }+ if col.Identity != 0 {+ colMeta.IsIdentity = true+ switch col.Identity {+ case 'a':+ colMeta.IdentityGeneration = storepb.ColumnMetadata_ALWAYS+ case 'd':+ colMeta.IdentityGeneration = storepb.ColumnMetadata_BY_DEFAULT+ default:+ }+ }+ table.Columns = append(table.Columns, colMeta)+ }++ // Indexes.+ for _, idx := range c.IndexesOf(rel.OID) {+ idxMeta := &storepb.IndexMetadata{+ Name: idx.Name,+ Type: idx.AccessMethod,+ Unique: idx.IsUnique,+ Primary: idx.IsPrimary,+ }++ // Build expressions list.+ exprIdx := 0+ for i, attnum := range idx.Columns {+ if attnum == 0 {+ // Expression column.+ if exprIdx < len(idx.Exprs) {+ idxMeta.Expressions = append(idxMeta.Expressions, idx.Exprs[exprIdx])+ exprIdx+++ }+ } else {+ // Regular column — find name.+ colName := ""+ for _, col := range rel.Columns {+ if col.AttNum == attnum {+ colName = col.Name+ break+ }+ }+ idxMeta.Expressions = append(idxMeta.Expressions, colName)+ }++ // Descending flag.+ if i < len(idx.IndOption) {+ idxMeta.Descending = append(idxMeta.Descending, idx.IndOption[i]&1 != 0)+ }+ }++ // IsConstraint: index backs a constraint if ConstraintOID != 0.+ if idx.ConstraintOID != 0 {+ idxMeta.IsConstraint = true+ }++ table.Indexes = append(table.Indexes, idxMeta)+ }++ // Foreign keys and check constraints from constraints.+ for _, con := range c.ConstraintsOf(rel.OID) {+ switch con.Type {+ case 'f': // FK+ fk := &storepb.ForeignKeyMetadata{+ Name: con.Name,+ }+ // Columns.+ for _, attnum := range con.Columns {+ for _, col := range rel.Columns {+ if col.AttNum == attnum {+ fk.Columns = append(fk.Columns, col.Name)+ break+ }+ }+ }+ // Referenced table.+ fRel := c.GetRelationByOID(con.FRelOID)+ if fRel != nil {+ if fRel.Schema != nil {+ fk.ReferencedSchema = fRel.Schema.Name+ }+ fk.ReferencedTable = fRel.Name+ for _, attnum := range con.FColumns {+ for _, col := range fRel.Columns {+ if col.AttNum == attnum {+ fk.ReferencedColumns = append(fk.ReferencedColumns, col.Name)+ break+ }+ }+ }+ }+ // Actions.+ fk.OnUpdate = wtFKActionToString(con.FKUpdAction)+ fk.OnDelete = wtFKActionToString(con.FKDelAction)+ fk.MatchType = wtFKMatchToString(con.FKMatchType)+ table.ForeignKeys = append(table.ForeignKeys, fk)+ case 'c': // CHECK+ table.CheckConstraints = append(table.CheckConstraints, &storepb.CheckConstraintMetadata{+ Name: con.Name,+ Expression: con.CheckExpr,+ })+ case 'x': // EXCLUDE+ table.ExcludeConstraints = append(table.ExcludeConstraints, &storepb.ExcludeConstraintMetadata{+ Name: con.Name,+ Expression: con.CheckExpr,+ })+ default:+ }+ }++ return table+}++// relationToViewProto converts an omni Relation (view) to a storepb.ViewMetadata.+func relationToViewProto(c *catalog.Catalog, rel *catalog.Relation) *storepb.ViewMetadata {+ view := &storepb.ViewMetadata{+ Name: rel.Name,+ }+ if rel.Schema != nil {+ if def, err := c.GetViewDefinition(rel.Schema.Name, rel.Name); err == nil {+ view.Definition = def+ }+ }+ return view+}++// relationToMatViewProto converts an omni Relation (materialized view) to a storepb.MaterializedViewMetadata.+func relationToMatViewProto(c *catalog.Catalog, rel *catalog.Relation) *storepb.MaterializedViewMetadata {+ mv := &storepb.MaterializedViewMetadata{+ Name: rel.Name,+ }+ if rel.Schema != nil {+ if def, err := c.GetMatViewDefinition(rel.Schema.Name, rel.Name); err == nil {+ mv.Definition = def+ }+ }++ // Materialized view indexes.+ for _, idx := range c.IndexesOf(rel.OID) {+ idxMeta := &storepb.IndexMetadata{+ Name: idx.Name,+ Type: idx.AccessMethod,+ Unique: idx.IsUnique,+ Primary: idx.IsPrimary,+ }+ exprIdx := 0+ for i, attnum := range idx.Columns {+ if attnum == 0 {+ if exprIdx < len(idx.Exprs) {+ idxMeta.Expressions = append(idxMeta.Expressions, idx.Exprs[exprIdx])+ exprIdx+++ }+ } else {+ for _, col := range rel.Columns {+ if col.AttNum == attnum {+ idxMeta.Expressions = append(idxMeta.Expressions, col.Name)+ break+ }+ }+ }++ // Descending flag.+ if i < len(idx.IndOption) {+ idxMeta.Descending = append(idxMeta.Descending, idx.IndOption[i]&1 != 0)+ }+ }++ if idx.ConstraintOID != 0 {+ idxMeta.IsConstraint = true+ }++ mv.Indexes = append(mv.Indexes, idxMeta)+ }++ return mv}diff --git a/backend/plugin/schema/pg/walk_through_loader_test.go b/backend/plugin/schema/pg/walk_through_loader_test.goindex b738b06abd..79ba60fd00 100644--- a/backend/plugin/schema/pg/walk_through_loader_test.go+++ b/backend/plugin/schema/pg/walk_through_loader_test.go@@ -172,9 +172,9 @@ func TestClone_SearchPath(t *testing.T) {require.True(t, foundAliceTable, "diff should show alice.my_table as added")}-// TestClone_WalkThroughOmniFunction tests the actual WalkThroughOmni function+// TestClone_WalkThroughFunction tests the actual WalkThroughWithContext function// using Clone (if enabled) produces correct FinalMetadata.-func TestClone_WalkThroughOmniFunction(t *testing.T) {+func TestClone_WalkThroughFunction(t *testing.T) {meta := &storepb.DatabaseSchemaMetadata{Name: "postgres",Schemas: []*storepb.SchemaMetadata{@@ -201,7 +201,7 @@ func TestClone_WalkThroughOmniFunction(t *testing.T) {RawSQL: `CREATE TABLE public.new_table (id int PRIMARY KEY, val text);`,}- advice := WalkThroughOmni(ctx, state, nil)+ advice := WalkThroughWithContext(ctx, state, nil)require.Nil(t, advice, "walk-through should succeed")// Check FinalMetadata has the new tablediff --git a/backend/plugin/schema/pg/walk_through_omni.go b/backend/plugin/schema/pg/walk_through_omni.godeleted file mode 100644index 39843c045b..0000000000--- a/backend/plugin/schema/pg/walk_through_omni.go+++ /dev/null@@ -1,360 +0,0 @@-package pg--import (- "context"-- "github.com/bytebase/omni/pg/catalog"-- storepb "github.com/bytebase/bytebase/backend/generated-go/store"- "github.com/bytebase/bytebase/backend/plugin/advisor/code"- "github.com/bytebase/bytebase/backend/plugin/parser/base"- "github.com/bytebase/bytebase/backend/plugin/schema"- "github.com/bytebase/bytebase/backend/store/model"-)--// WalkThroughOmni performs DDL simulation using omni catalog.-// 1. loadWalkThroughCatalog(metadata) → load existing schema into catalog-// 2. catalog.Exec(userSQL) → execute user DDL, collect per-statement Changes-// 3. Map exec errors → *storepb.Advice-// 4. Merge Changes into original metadata → FinalMetadata for downstream rules-func WalkThroughOmni(ctx schema.WalkThroughContext, d *model.DatabaseMetadata, _ []base.AST) *storepb.Advice {- if ctx.RawSQL == "" {- return nil- }-- // Step 1: Load existing schema into two catalogs — one as snapshot, one for exec.- // TODO(BYT-9215): Thread a real context.Context through the call chain instead of using context.Background().- // WalkThroughContext is not a context.Context and the caller does not pass one.- catBefore := catalog.New()- if ctx.SessionUser != "" {- catBefore.SetSessionUser(ctx.SessionUser)- }- if searchPath := getConfiguredSearchPath(d); len(searchPath) > 0 {- catBefore.SetSearchPath(searchPath)- }- if err := loadWalkThroughCatalog(context.Background(), catBefore, d.GetProto()); err != nil {- return &storepb.Advice{- Status: storepb.Advice_ERROR,- Code: code.DDLSimulationFailed.Int32(),- Title: "Failed to load schema",- Content: err.Error(),- StartPosition: &storepb.Position{Line: 0},- }- }-- catAfter := catBefore.Clone()-- // Step 2: Execute user SQL on catAfter.- results, execErr := catAfter.Exec(ctx.RawSQL, &catalog.ExecOptions{ContinueOnError: true})- if execErr != nil {- return &storepb.Advice{- Status: storepb.Advice_ERROR,- Code: code.DDLSimulationFailed.Int32(),- Title: "DDL simulation failed",- Content: execErr.Error(),- StartPosition: &storepb.Position{Line: 0},- }- }-- // Step 3: Report the first exec error.- for _, r := range results {- if r.Error == nil {- continue- }- errCode := mapSQLSTATEToCode(r.Error)- return &storepb.Advice{- Status: storepb.Advice_ERROR,- Code: errCode.Int32(),- Title: "DDL simulation failed",- Content: r.Error.Error(),- StartPosition: &storepb.Position{- Line: int32(r.Line),- },- }- }-- // Step 4: Diff before/after catalogs and apply to original metadata.- diff := catalog.Diff(catBefore, catAfter)- if diff != nil && !diff.IsEmpty() {- newProto := applyDiffToMetadata(d.GetProto(), catBefore, catAfter, diff)- newMetadata := model.NewDatabaseMetadata(newProto, nil, d.GetConfig(), storepb.Engine_POSTGRES, true)- d.ReplaceFrom(newMetadata)- }-- return nil-}--// mapSQLSTATEToCode converts an omni catalog error to a bytebase error code.-func mapSQLSTATEToCode(err error) code.Code {- catErr, ok := err.(*catalog.Error)- if !ok {- return code.DDLSimulationFailed- }-- switch catErr.Code {- // Table/relation errors- case catalog.CodeDuplicateTable:- return code.TableExists- case catalog.CodeUndefinedTable:- return code.TableNotExists-- // Column errors- case catalog.CodeDuplicateColumn:- return code.ColumnExists- case catalog.CodeUndefinedColumn, catalog.CodeInvalidColumnDefinition:- return code.ColumnNotExists-- // Schema errors- case catalog.CodeDuplicateSchema:- return code.RelationExists- case catalog.CodeUndefinedSchema:- return code.SchemaNotExists-- // Index/constraint errors- case catalog.CodeDuplicateObject, catalog.CodeUniqueViolation:- return code.IndexExists- case catalog.CodeUndefinedObject:- return code.IndexNotExists-- // FK errors- case catalog.CodeInvalidFK, catalog.CodeForeignKeyViolation:- return code.TableHasFK-- // PK/table definition errors- case catalog.CodeDuplicatePKey:- return code.PrimaryKeyExists-- // Type/expression errors- case catalog.CodeDatatypeMismatch:- return code.ChangeColumnType- case catalog.CodeNotNullViolation:- return code.ColumnCannotNull-- // Syntax- case catalog.CodeSyntaxError:- return code.StatementSyntaxError-- // Naming- case catalog.CodeReservedName:- return code.NameIsKeywordIdentifier-- default:- return code.DDLSimulationFailed- }-}--func getConfiguredSearchPath(d *model.DatabaseMetadata) []string {- configured := d.GetConfiguredSearchPath()- if len(configured) == 0 {- return nil- }-- searchPath := make([]string, 0, len(configured))- for _, item := range configured {- if item.CurrentUser {- searchPath = append(searchPath, "$user")- continue- }- if item.Schema == "" {- continue- }- searchPath = append(searchPath, item.Schema)- }- return searchPath-}--// relationToTableProto converts an omni Relation to a storepb.TableMetadata.-func relationToTableProto(c *catalog.Catalog, rel *catalog.Relation) *storepb.TableMetadata {- table := &storepb.TableMetadata{- Name: rel.Name,- }-- // Columns.- for _, col := range rel.Columns {- colMeta := &storepb.ColumnMetadata{- Name: col.Name,- Position: int32(col.AttNum),- Type: c.FormatType(col.TypeOID, col.TypeMod),- Nullable: !col.NotNull,- Default: col.Default,- }- if col.Generated == 's' {- colMeta.Generation = &storepb.GenerationMetadata{- Type: storepb.GenerationMetadata_TYPE_STORED,- Expression: col.GenerationExpr,- }- }- if col.Identity != 0 {- colMeta.IsIdentity = true- switch col.Identity {- case 'a':- colMeta.IdentityGeneration = storepb.ColumnMetadata_ALWAYS- case 'd':- colMeta.IdentityGeneration = storepb.ColumnMetadata_BY_DEFAULT- default:- }- }- table.Columns = append(table.Columns, colMeta)- }-- // Indexes.- for _, idx := range c.IndexesOf(rel.OID) {- idxMeta := &storepb.IndexMetadata{- Name: idx.Name,- Type: idx.AccessMethod,- Unique: idx.IsUnique,- Primary: idx.IsPrimary,- }-- // Build expressions list.- exprIdx := 0- for i, attnum := range idx.Columns {- if attnum == 0 {- // Expression column.- if exprIdx < len(idx.Exprs) {- idxMeta.Expressions = append(idxMeta.Expressions, idx.Exprs[exprIdx])- exprIdx++- }- } else {- // Regular column — find name.- colName := ""- for _, col := range rel.Columns {- if col.AttNum == attnum {- colName = col.Name- break- }- }- idxMeta.Expressions = append(idxMeta.Expressions, colName)- }-- // Descending flag.- if i < len(idx.IndOption) {- idxMeta.Descending = append(idxMeta.Descending, idx.IndOption[i]&1 != 0)- }- }-- // IsConstraint: index backs a constraint if ConstraintOID != 0.- if idx.ConstraintOID != 0 {- idxMeta.IsConstraint = true- }-- table.Indexes = append(table.Indexes, idxMeta)- }-- // Foreign keys and check constraints from constraints.- for _, con := range c.ConstraintsOf(rel.OID) {- switch con.Type {- case 'f': // FK- fk := &storepb.ForeignKeyMetadata{- Name: con.Name,- }- // Columns.- for _, attnum := range con.Columns {- for _, col := range rel.Columns {- if col.AttNum == attnum {- fk.Columns = append(fk.Columns, col.Name)- break- }- }- }- // Referenced table.- fRel := c.GetRelationByOID(con.FRelOID)- if fRel != nil {- if fRel.Schema != nil {- fk.ReferencedSchema = fRel.Schema.Name- }- fk.ReferencedTable = fRel.Name- for _, attnum := range con.FColumns {- for _, col := range fRel.Columns {- if col.AttNum == attnum {- fk.ReferencedColumns = append(fk.ReferencedColumns, col.Name)- break- }- }- }- }- // Actions.- fk.OnUpdate = wtFKActionToString(con.FKUpdAction)- fk.OnDelete = wtFKActionToString(con.FKDelAction)- fk.MatchType = wtFKMatchToString(con.FKMatchType)- table.ForeignKeys = append(table.ForeignKeys, fk)- case 'c': // CHECK- table.CheckConstraints = append(table.CheckConstraints, &storepb.CheckConstraintMetadata{- Name: con.Name,- Expression: con.CheckExpr,- })- case 'x': // EXCLUDE- table.ExcludeConstraints = append(table.ExcludeConstraints, &storepb.ExcludeConstraintMetadata{- Name: con.Name,- Expression: con.CheckExpr,- })- default:- }- }-- return table-}--// relationToViewProto converts an omni Relation (view) to a storepb.ViewMetadata.-func relationToViewProto(c *catalog.Catalog, rel *catalog.Relation) *storepb.ViewMetadata {- view := &storepb.ViewMetadata{- Name: rel.Name,- }- if rel.Schema != nil {- if def, err := c.GetViewDefinition(rel.Schema.Name, rel.Name); err == nil {- view.Definition = def- }- }- return view-}--// relationToMatViewProto converts an omni Relation (materialized view) to a storepb.MaterializedViewMetadata.-func relationToMatViewProto(c *catalog.Catalog, rel *catalog.Relation) *storepb.MaterializedViewMetadata {- mv := &storepb.MaterializedViewMetadata{- Name: rel.Name,- }- if rel.Schema != nil {- if def, err := c.GetMatViewDefinition(rel.Schema.Name, rel.Name); err == nil {- mv.Definition = def- }- }-- // Materialized view indexes.- for _, idx := range c.IndexesOf(rel.OID) {- idxMeta := &storepb.IndexMetadata{- Name: idx.Name,- Type: idx.AccessMethod,- Unique: idx.IsUnique,- Primary: idx.IsPrimary,- }- exprIdx := 0- for i, attnum := range idx.Columns {- if attnum == 0 {- if exprIdx < len(idx.Exprs) {- idxMeta.Expressions = append(idxMeta.Expressions, idx.Exprs[exprIdx])- exprIdx++- }- } else {- for _, col := range rel.Columns {- if col.AttNum == attnum {- idxMeta.Expressions = append(idxMeta.Expressions, col.Name)- break- }- }- }-- // Descending flag.- if i < len(idx.IndOption) {- idxMeta.Descending = append(idxMeta.Descending, idx.IndOption[i]&1 != 0)- }- }-- if idx.ConstraintOID != 0 {- idxMeta.IsConstraint = true- }-- mv.Indexes = append(mv.Indexes, idxMeta)- }-- return mv-}diff --git a/docs/plans/2026-04-23-mssql-query-span-omni-migration.md b/docs/plans/2026-04-23-mssql-query-span-omni-migration.mdindex ac5ae98a4e..c0688f3d37 100644--- a/docs/plans/2026-04-23-mssql-query-span-omni-migration.md+++ b/docs/plans/2026-04-23-mssql-query-span-omni-migration.md@@ -18,7 +18,7 @@ Single extractor. No dual-parse. Omni produces the AST; extractor consumes it.```GetQuerySpan- → ParseTSQLOmni(stmt) → []omnimssql.Statement+ → ParseTSQL(stmt) → []omnimssql.Statement→ pre-pass: collect DECLARE @t TABLE into gCtx.TempTables→ omniQuerySpanExtractor.run(stmts)→ classifyQueryType(stmts[0].AST) (already omni)diff --git a/docs/plans/2026-04-27-mysql-query-span-omni-migration.md b/docs/plans/2026-04-27-mysql-query-span-omni-migration.mdindex 505d15ca4f..b79a53e442 100644--- a/docs/plans/2026-04-27-mysql-query-span-omni-migration.md+++ b/docs/plans/2026-04-27-mysql-query-span-omni-migration.md@@ -38,7 +38,7 @@ The final MySQL query-span implementation should look like this:GetQuerySpan-> newQuerySpanExtractor(...)-> q.getQuerySpan(ctx, stmt.Text)- -> ParseMySQLOmni(stmt)+ -> ParseMySQL(stmt)-> collectOmniAccessTables(root)-> isMixedQuery(...)-> classifyOmniQueryType(root, allSystems)diff --git a/docs/plans/SCENARIOS-mysql-advisor-omni.md b/docs/plans/SCENARIOS-mysql-advisor-omni.mdindex 6c5c5cbf22..4019607a17 100644--- a/docs/plans/SCENARIOS-mysql-advisor-omni.md+++ b/docs/plans/SCENARIOS-mysql-advisor-omni.md@@ -19,7 +19,7 @@ Build the omni rule infrastructure and prove it works with one representative ru- [x] `SetStatement(baseLine int, stmtText string)` sets context for position calculations- [x] `AddAdvice()` adds advice with BaseLine offset adjustment- [x] `LocToLine(loc ast.Loc)` converts omni byte offset to 1-based line number-- [x] `RunOmniRules()` dispatcher iterates statements, extracts omni node, dispatches to rules+- [x] `RunRules()` dispatcher iterates statements, extracts omni node, dispatches to rules- [x] `FindLineByName(name string)` searches identifier in statement text, returns line### 1.2 Utility Functions