Skip to content

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

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.go
index 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.go
similarity index 95%
rename from backend/plugin/advisor/mssql/generic_checker_omni.go
rename to backend/plugin/advisor/mssql/generic_checker.go
index 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 {
continue
diff --git a/backend/plugin/advisor/mssql/rule_builtin_prior_backup_check.go b/backend/plugin/advisor/mssql/rule_builtin_prior_backup_check.go
index 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 adv
ddlRule := &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.go
index 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.ParsedStatement
diff --git a/backend/plugin/advisor/mssql/rule_column_maximum_varchar_length.go b/backend/plugin/advisor/mssql/rule_column_maximum_varchar_length.go
index 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.go
index 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.go
index 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.go
index 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.go
index 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 a
return 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.go
index 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.Contex
curDB: 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.go
index 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.go
index 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 advis
rule := &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.go
index 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.go
index 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.Co
rule := &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.go
index 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, checkCtx
return 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.go
index 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.Conte
return 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.go
index 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.go
index 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 advis
rule := &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.go
index 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 adv
rule.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.go
index 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 advis
return 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.go
index 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, checkCtx
return 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.go
index 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.Contex
OmniBaseRule: 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.go
index 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.Contex
OmniBaseRule: 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.go
index 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 advis
OmniBaseRule: 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.go
index 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.Conte
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/rule_table_require_pk.go b/backend/plugin/advisor/mssql/rule_table_require_pk.go
index 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.go
similarity index 100%
rename from backend/plugin/advisor/mssql/utils_omni.go
rename to backend/plugin/advisor/mssql/utils.go
diff --git a/backend/plugin/advisor/mysql/generic_checker_omni.go b/backend/plugin/advisor/mysql/generic_checker.go
similarity index 96%
rename from backend/plugin/advisor/mysql/generic_checker_omni.go
rename to backend/plugin/advisor/mysql/generic_checker.go
index 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 {
continue
diff --git a/backend/plugin/advisor/mysql/rule_charset_allowlist.go b/backend/plugin/advisor/mysql/rule_charset_allowlist.go
index 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.Contex
allowList: 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.go
index 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.Cont
allowList: 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.go
index 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 advisor
payload: 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.go
index 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.go
index 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.go
index 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 advi
originalMetadata: 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.go
index 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.go
index 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 advis
originalMetadata: 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.go
index 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.go
index 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.go
index 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.go
index 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.go
index 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.go
index 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.Conte
line: 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.go
index 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.go
index 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 adviso
originMetadata: 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.go
index 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.go
index 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.go
index 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.go
index 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.go
index 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.Con
max: 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.go
index 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.go
index 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.go
index 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 ad
tablesNewColumns: 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.go
index 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.C
finalMetadata: 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.go
index 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.Cont
allowList: 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.go
index 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.Context
tablesNewColumns: 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.go
index 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.go
index 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.go
index 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.go
index 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 advis
maxLength: 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.go
index 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.go
index 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.Cont
templateList: 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.go
index 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.go
index 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.C
originalMetadata: 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.go
index 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.C
maxLength: 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.go
index 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.Cont
originalMetadata: 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.go
index 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.Conte
changedResources: 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.go
index 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.go
index 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 advis
rule := &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.go
index 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.go
index 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 adviso
tableMap: 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.go
index 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, chec
rule.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.go
index 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.go
index 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.go
index 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.go
index 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.go
index 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.go
index 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.go
index 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 ad
errorCode: 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.go
index 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.go
index 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.go
index 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.go
index 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.Contex
disallowList: 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.go
index 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.Contex
disallowList: 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.go
index 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.go
index 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.go
index 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.go
index 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 advis
format: 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.go
index 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.Contex
dbMetadata: 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.go
index 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.go
index 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.go
index 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.go
index 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.go
index 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.go
index 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.go
index 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.go
index 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.go
deleted file mode 100644
index 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.go
index 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_Status
title 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.go
deleted file mode 100644
index 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.go
index 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 adv
rule := NewStatementPriorBackupCheckRule(ctx, level, checkCtx.Rule.Type.String(), checkCtx)
- return RunOmniRules(checkCtx.ParsedStatements, []OmniRule{rule})
+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule})
}
type StatementType int
diff --git a/backend/plugin/advisor/oracle/rule_column_add_not_null_column_require_default.go b/backend/plugin/advisor/oracle/rule_column_add_not_null_column_require_default.go
index 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, che
rule := 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.go
index 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 advisor
rule := 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.go
index 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 ad
rule := 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.go
index 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 advi
rule := 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.go
index 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.go
index 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]bool
diff --git a/backend/plugin/advisor/oracle/rule_column_require_default.go b/backend/plugin/advisor/oracle/rule_column_require_default.go
index 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.Co
rule := 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.go
index 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.go
index 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.Con
rule := 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.go
index 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 advisor
rule := 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.go
index 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.Co
rule := 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.go
index 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 advis
rule := 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.go
index 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.go
index 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.Co
rule := 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.go
index 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.Conte
rule := 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.go
index 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 advis
return 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.go
index 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.Co
rule := 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.go
index 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.Co
checkCtx.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.go
index 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.go
index 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.Conte
rule := 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.go
index 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.go
index 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 advi
rule := 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.go
index 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.C
rule := 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.go
index 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 adv
rule := 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.go
similarity index 100%
rename from backend/plugin/advisor/oracle/utils_omni.go
rename to backend/plugin/advisor/oracle/utils.go
diff --git a/backend/plugin/advisor/pg/advisor_collation_allowlist.go b/backend/plugin/advisor/pg/advisor_collation_allowlist.go
index 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.Cont
allowlist: 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.go
index 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.go
index 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.go
index 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 ad
maximum: 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.go
index 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.go
index 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.go
index 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.Conte
requiredColumnsMap: 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.go
index 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.go
index 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.Conte
maxLength: 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.go
index 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.Conte
allowlist: 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.go
index 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.Conte
newlyCreatedTables: 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.go
index 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.Con
max: 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.go
index 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.go
index 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 ad
allowlist: 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.go
index 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.go
index 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.go
index 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.Contex
TenantMode: 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.go
index 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.go
index 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.go
index 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.Cont
templateList: 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.go
index 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 adviso
dbMetadata: 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.go
index 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.C
originalMetadata: 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.go
index 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.Cont
originalMetadata: 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.go
index 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.C
maxLength: 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.go
index 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.Cont
originalMetadata: 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.go
index 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.go
index 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.go
index 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 adv
tenantMode: 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.go
index 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.go
index 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.go
index 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.go
index 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.go
index 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.go
index 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.go
index 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.go
index 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 advis
rule := &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.go
index 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.Co
tenantMode: 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.go
index 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 adviso
tableMap: 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.go
index 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.go
index 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.go
index 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.go
index 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 adv
currentRole: 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.go
index 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.go
index 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.go
index 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.go
index 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.go
index 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 advis
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/pg/advisor_table_no_fk.go b/backend/plugin/advisor/pg/advisor_table_no_fk.go
index 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.go
index 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.go
similarity index 96%
rename from backend/plugin/advisor/pg/generic_checker_omni.go
rename to backend/plugin/advisor/pg/generic_checker.go
index 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 {
continue
diff --git a/backend/plugin/advisor/pg/utils.go b/backend/plugin/advisor/pg/utils.go
index 00715f47da..76d0a0c1fd 100644
--- a/backend/plugin/advisor/pg/utils.go
+++ b/backend/plugin/advisor/pg/utils.go
@@ -1,15 +1,15 @@
package pg
import (
+ "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.go
deleted file mode 100644
index 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.go
index 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.go
index 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.go
index 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) (string
return "", 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, nil
diff --git a/backend/plugin/db/mysql/stats.go b/backend/plugin/db/mysql/stats.go
index 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.go
index 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.go
index 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.go
index 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.go
index 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.go
index 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.Dat
continue
}
- 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.go
index 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.go
index 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.go
index 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.go
index 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.go
index 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.go
index 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 mysql
import (
"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.Context
defaultDatabase 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.go
deleted file mode 100644
index 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.go
similarity index 100%
rename from backend/plugin/parser/mysql/query_span_extractor_omni_test.go
rename to backend/plugin/parser/mysql/query_span_extractor_test.go
diff --git a/backend/plugin/parser/mysql/query_span_omni_parity_test.go b/backend/plugin/parser/mysql/query_span_parity_test.go
similarity index 100%
rename from backend/plugin/parser/mysql/query_span_omni_parity_test.go
rename to backend/plugin/parser/mysql/query_span_parity_test.go
diff --git a/backend/plugin/parser/mysql/query_span_omni_probe_test.go b/backend/plugin/parser/mysql/query_span_probe_test.go
similarity index 98%
rename from backend/plugin/parser/mysql/query_span_omni_probe_test.go
rename to backend/plugin/parser/mysql/query_span_probe_test.go
index 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.go
index 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.go
index 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_It
var result []string
for 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.go
index d5a34a5eb9..9dfc978677 100644
--- a/backend/plugin/parser/pg/query_span.go
+++ b/backend/plugin/parser/pg/query_span.go
@@ -2,11 +2,17 @@ package pg
import (
"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.go
index 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 are
diff --git a/backend/plugin/parser/pg/query_span_omni.go b/backend/plugin/parser/pg/query_span_omni.go
deleted file mode 100644
index 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.go
similarity index 100%
rename from backend/plugin/parser/pg/query_span_omni_plpgsql.go
rename to backend/plugin/parser/pg/query_span_plpgsql.go
diff --git a/backend/plugin/parser/plsql/backup.go b/backend/plugin/parser/plsql/backup.go
index 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, err
if 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.go
index 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.SyntaxError
if errors.As(convertOmniError(err, base.Statement{Text: statement}), &syntaxErr) {
return syntaxErr
diff --git a/backend/plugin/parser/plsql/omni.go b/backend/plugin/parser/plsql/omni.go
index 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, err
diff --git a/backend/plugin/parser/plsql/omni_test.go b/backend/plugin/parser/plsql/omni_test.go
index 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 OFF
PROMPT setup
@@ -86,8 +86,8 @@ SPOOL OFF
require.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 NULL
CONSTRAINT 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_ID
ORDER 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 setup
SELECT 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.go
index 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.go
index 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.go
index 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.go
index 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 plsql
import (
"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: &copyExtractor,
+ 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.go
deleted file mode 100644
index 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: &copyExtractor,
- 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.go
similarity index 100%
rename from backend/plugin/parser/plsql/query_span_omni_parity_test.go
rename to backend/plugin/parser/plsql/query_span_parity_test.go
diff --git a/backend/plugin/parser/plsql/query_span_omni_probe_test.go b/backend/plugin/parser/plsql/query_span_probe_test.go
similarity index 98%
rename from backend/plugin/parser/plsql/query_span_omni_probe_test.go
rename to backend/plugin/parser/plsql/query_span_probe_test.go
index 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.go
index 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.go
similarity index 96%
rename from backend/plugin/parser/plsql/query_type_omni_test.go
rename to backend/plugin/parser/plsql/query_type_test.go
index 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.go
index 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.go
index 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.go
index 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.go
index 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 invalid
func 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.go
similarity index 99%
rename from backend/plugin/parser/redshift/query_span_extractor_omni.go
rename to backend/plugin/parser/redshift/query_span_extractor.go
index 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.go
similarity index 99%
rename from backend/plugin/parser/redshift/query_span_omni_test.go
rename to backend/plugin/parser/redshift/query_span_test.go
index 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.go
index 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.go
index 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.go
index 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.go
index 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.go
index 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.go
index 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.go
index 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 tsql
import (
"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, viewDat
return 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.go
deleted file mode 100644
index 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.go
similarity index 100%
rename from backend/plugin/parser/tsql/query_span_extractor_omni_test.go
rename to backend/plugin/parser/tsql/query_span_extractor_test.go
diff --git a/backend/plugin/parser/tsql/query_span_parser_invariant_test.go b/backend/plugin/parser/tsql/query_span_parser_invariant_test.go
index 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.go
similarity index 97%
rename from backend/plugin/parser/tsql/query_span_predicate_omni.go
rename to backend/plugin/parser/tsql/query_span_predicate.go
index 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 expression
diff --git a/backend/plugin/parser/tsql/query_span_predicate_omni_test.go b/backend/plugin/parser/tsql/query_span_predicate_test.go
similarity index 98%
rename from backend/plugin/parser/tsql/query_span_predicate_omni_test.go
rename to backend/plugin/parser/tsql/query_span_predicate_test.go
index 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.go
similarity index 100%
rename from backend/plugin/parser/tsql/query_span_pseudo_column_omni.go
rename to backend/plugin/parser/tsql/query_span_pseudo_column.go
diff --git a/backend/plugin/parser/tsql/query_span_pseudo_column_omni_test.go b/backend/plugin/parser/tsql/query_span_pseudo_column_test.go
similarity index 100%
rename from backend/plugin/parser/tsql/query_span_pseudo_column_omni_test.go
rename to backend/plugin/parser/tsql/query_span_pseudo_column_test.go
diff --git a/backend/plugin/parser/tsql/tsql.go b/backend/plugin/parser/tsql/tsql.go
index 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.go
index 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, comment
func 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.go
similarity index 99%
rename from backend/plugin/schema/mssql/get_database_metadata_omni.go
rename to backend/plugin/schema/mssql/get_database_metadata.go
index 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.go
similarity index 89%
rename from backend/plugin/schema/mssql/get_database_metadata_omni_test.go
rename to backend/plugin/schema/mssql/get_database_metadata_test.go
index 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 KEY
diff --git a/backend/plugin/schema/mysql/format_view_body_test.go b/backend/plugin/schema/mysql/format_view_body_test.go
index 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.go
similarity index 79%
rename from backend/plugin/schema/mysql/get_database_metadata_omni.go
rename to backend/plugin/schema/mysql/get_database_metadata.go
index 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.go
similarity index 99%
rename from backend/plugin/schema/mysql/get_database_metadata_omni_test.go
rename to backend/plugin/schema/mysql/get_database_metadata_test.go
index 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 metadata
diff --git a/backend/plugin/schema/mysql/get_multi_file_definition_test.go b/backend/plugin/schema/mysql/get_multi_file_definition_test.go
index 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 single
diff --git a/backend/plugin/schema/mysql/sdl_migration_omni.go b/backend/plugin/schema/mysql/sdl_migration.go
similarity index 99%
rename from backend/plugin/schema/mysql/sdl_migration_omni.go
rename to backend/plugin/schema/mysql/sdl_migration.go
index 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.go
similarity index 99%
rename from backend/plugin/schema/mysql/sdl_migration_omni_test.go
rename to backend/plugin/schema/mysql/sdl_migration_test.go
index 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 the
diff --git a/backend/plugin/schema/mysql/walk_through_omni.go b/backend/plugin/schema/mysql/walk_through.go
similarity index 99%
rename from backend/plugin/schema/mysql/walk_through_omni.go
rename to backend/plugin/schema/mysql/walk_through.go
index 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.go
index 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.go
similarity index 90%
rename from backend/plugin/schema/mysql/walk_through_omni_test.go
rename to backend/plugin/schema/mysql/walk_through_test.go
index 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 fields
require.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.go
index 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 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"
"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.go
deleted file mode 100644
index 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.go
deleted file mode 100644
index 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.go
index 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.go
similarity index 100%
rename from backend/plugin/schema/pg/sdl_migration_omni.go
rename to backend/plugin/schema/pg/sdl_migration.go
diff --git a/backend/plugin/schema/pg/sdl_migration_omni_test.go b/backend/plugin/schema/pg/sdl_migration_test.go
similarity index 100%
rename from backend/plugin/schema/pg/sdl_migration_omni_test.go
rename to backend/plugin/schema/pg/sdl_migration_test.go
diff --git a/backend/plugin/schema/pg/walk_through.go b/backend/plugin/schema/pg/walk_through.go
index 512c4d2b14..20008eced5 100644
--- a/backend/plugin/schema/pg/walk_through.go
+++ b/backend/plugin/schema/pg/walk_through.go
@@ -1,7 +1,12 @@
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"
@@ -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.go
index 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 table
diff --git a/backend/plugin/schema/pg/walk_through_omni.go b/backend/plugin/schema/pg/walk_through_omni.go
deleted file mode 100644
index 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.md
index 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.md
index 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.md
index 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