Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
feat(parser): migrate Oracle query span to omni (#20428)
rebelicec516b94eba86
diff --git a/backend/plugin/parser/plsql/query_span.go b/backend/plugin/parser/plsql/query_span.goindex 7889e70d11..900b281ac1 100644--- a/backend/plugin/parser/plsql/query_span.go+++ b/backend/plugin/parser/plsql/query_span.go@@ -14,9 +14,9 @@ func init() {}func GetQuerySpan(ctx context.Context, gCtx base.GetQuerySpanContext, stmt base.Statement, database, _ string, _ bool) (*base.QuerySpan, error) {- extractor := newQuerySpanExtractor(database, gCtx)+ extractor := newOmniQuerySpanExtractor(database, gCtx)- querySpan, err := extractor.getQuerySpan(ctx, stmt.Text)+ querySpan, err := extractor.getOmniQuerySpan(ctx, stmt.Text)if err != nil {return nil, errors.Wrapf(err, "failed to get query span from statement: %s", stmt.Text)}diff --git a/backend/plugin/parser/plsql/query_span_extractor.go b/backend/plugin/parser/plsql/query_span_extractor.goindex be868518bd..1753e23003 100644--- a/backend/plugin/parser/plsql/query_span_extractor.go+++ b/backend/plugin/parser/plsql/query_span_extractor.go@@ -1,3 +1,4 @@+//nolint:unusedpackage plsqlimport (@@ -1390,8 +1391,8 @@ func (q *querySpanExtractor) getColumnsForView(instanceID, defaultDatabase, defiListDatabaseNamesFunc: q.gCtx.ListDatabaseNamesFunc,GetLinkedDatabaseMetadataFunc: q.gCtx.GetLinkedDatabaseMetadataFunc,}- newQ := newQuerySpanExtractor(defaultDatabase, newContext)- span, err := newQ.getQuerySpan(q.ctx, definition)+ newQ := newOmniQuerySpanExtractor(defaultDatabase, newContext)+ span, err := newQ.getOmniQuerySpan(q.ctx, definition)if err != nil {return nil, errors.Wrapf(err, "failed to get query span for view definition: %s", definition)}@@ -1408,8 +1409,8 @@ func (q *querySpanExtractor) getColumnsForMaterializedView(instanceID, defaultDaListDatabaseNamesFunc: q.gCtx.ListDatabaseNamesFunc,GetLinkedDatabaseMetadataFunc: q.gCtx.GetLinkedDatabaseMetadataFunc,}- newQ := newQuerySpanExtractor(defaultDatabase, newContext)- span, err := newQ.getQuerySpan(q.ctx, definition)+ newQ := newOmniQuerySpanExtractor(defaultDatabase, newContext)+ span, err := newQ.getOmniQuerySpan(q.ctx, definition)if err != nil {return nil, errors.Wrapf(err, "failed to get query span for materialized view definition: %s", definition)}diff --git a/backend/plugin/parser/plsql/query_span_extractor_omni.go b/backend/plugin/parser/plsql/query_span_extractor_omni.gonew file mode 100644index 0000000000..e1bbdbed8d--- /dev/null+++ b/backend/plugin/parser/plsql/query_span_extractor_omni.go@@ -0,0 +1,1123 @@+package plsql++import (+ "context"+ "reflect"+ "strings"+ "unicode"++ "github.com/pkg/errors"++ oracleast "github.com/bytebase/omni/oracle/ast"++ "github.com/bytebase/bytebase/backend/plugin/parser/base"+)++type omniQuerySpanExtractor struct {+ *querySpanExtractor++ source string+ topLevelTableSourcesFrom []base.TableSource+}++func newOmniQuerySpanExtractor(connectionDatabase string, gCtx base.GetQuerySpanContext) *omniQuerySpanExtractor {+ return &omniQuerySpanExtractor{+ querySpanExtractor: newQuerySpanExtractor(connectionDatabase, gCtx),+ }+}++func (q *omniQuerySpanExtractor) getOmniQuerySpan(ctx context.Context, statement string) (*base.QuerySpan, error) {+ q.ctx = ctx+ q.source = statement++ list, err := ParsePLSQLOmni(statement)+ if err != nil {+ return nil, errors.Wrapf(err, "failed to parse statement: %s", statement)+ }+ if list == nil || len(list.Items) == 0 {+ return nil, nil+ }+ if len(list.Items) > 1 {+ return nil, errors.Errorf("query span extraction only supports single statement, got %d statements", len(list.Items))+ }+ raw, ok := list.Items[0].(*oracleast.RawStmt)+ if !ok || raw.Stmt == nil {+ return nil, nil+ }++ accessTables := collectOmniAccessTables(q.defaultDatabase, raw.Stmt)+ allSystem, mixed := isMixedQuery(accessTables)+ if mixed {+ return nil, base.MixUserSystemTablesError+ }++ queryType := omniQueryType(raw.Stmt, allSystem)+ if queryType != base.Select {+ return &base.QuerySpan{+ Type: queryType,+ SourceColumns: base.SourceColumnSet{},+ Results: []base.QuerySpanResult{},+ }, nil+ }++ columnSet := make(base.SourceColumnSet)+ for _, resource := range accessTables {+ if !q.existsTableMetadata(resource) {+ continue+ }+ columnSet[base.ColumnResource{+ Server: resource.LinkedServer,+ Database: resource.Database,+ Table: resource.Table,+ }] = true+ }++ selectStmt, ok := raw.Stmt.(*oracleast.SelectStmt)+ if !ok {+ return nil, errors.Errorf("expected SELECT statement, got %T", raw.Stmt)+ }+ tableSource, err := q.extractOmniSelect(selectStmt)+ if err != nil {+ var resourceNotFound *base.ResourceNotFoundError+ if errors.As(err, &resourceNotFound) {+ if len(columnSet) == 0 {+ columnSet[base.ColumnResource{+ Database: q.defaultDatabase,+ }] = true+ }+ return &base.QuerySpan{+ Type: base.Select,+ SourceColumns: columnSet,+ Results: []base.QuerySpanResult{},+ NotFoundError: resourceNotFound,+ }, nil+ }+ return nil, err+ }+ var results []base.QuerySpanResult+ if tableSource != nil {+ results = tableSource.GetQuerySpanResult()+ }+ if resourceNotFound := q.findMissingOmniAccessTable(raw.Stmt, accessTables); resourceNotFound != nil {+ if len(columnSet) == 0 {+ columnSet[base.ColumnResource{+ Database: q.defaultDatabase,+ }] = true+ }+ return &base.QuerySpan{+ Type: base.Select,+ SourceColumns: columnSet,+ Results: []base.QuerySpanResult{},+ NotFoundError: resourceNotFound,+ }, nil+ }+ return &base.QuerySpan{+ Type: base.Select,+ SourceColumns: columnSet,+ Results: results,+ }, nil+}++func omniQueryType(stmt oracleast.StmtNode, allSystem bool) base.QueryType {+ if stmt == nil {+ return base.QueryTypeUnknown+ }+ switch stmt.(type) {+ case *oracleast.ExplainPlanStmt:+ return base.Explain+ case *oracleast.SelectStmt:+ if allSystem {+ return base.SelectInfoSchema+ }+ return base.Select+ case *oracleast.InsertStmt, *oracleast.UpdateStmt, *oracleast.DeleteStmt, *oracleast.MergeStmt,+ *oracleast.CallStmt, *oracleast.LockTableStmt:+ return base.DML+ case *oracleast.CreateTableStmt, *oracleast.AlterTableStmt, *oracleast.DropStmt,+ *oracleast.CreateIndexStmt, *oracleast.CreateViewStmt,+ *oracleast.CreateSequenceStmt, *oracleast.CreateSynonymStmt,+ *oracleast.CreateDatabaseLinkStmt, *oracleast.CreateTypeStmt,+ *oracleast.CreatePackageStmt, *oracleast.CreateProcedureStmt,+ *oracleast.CreateFunctionStmt, *oracleast.CreateTriggerStmt,+ *oracleast.TruncateStmt, *oracleast.AlterSessionStmt,+ *oracleast.AlterSystemStmt, *oracleast.CreateUserStmt,+ *oracleast.AlterUserStmt, *oracleast.CreateRoleStmt,+ *oracleast.AlterRoleStmt, *oracleast.CreateProfileStmt,+ *oracleast.AlterProfileStmt, *oracleast.AlterResourceCostStmt,+ *oracleast.AdminDDLStmt, *oracleast.CreateSchemaStmt,+ *oracleast.AlterDatabaseLinkStmt, *oracleast.AlterSynonymStmt,+ *oracleast.AlterMaterializedViewStmt,+ *oracleast.CreateAuditPolicyStmt, *oracleast.AlterAuditPolicyStmt,+ *oracleast.DropAuditPolicyStmt, *oracleast.CreateTablespaceStmt,+ *oracleast.AlterTablespaceStmt, *oracleast.CreateTablespaceSetStmt,+ *oracleast.DropTablespaceStmt, *oracleast.CreateClusterStmt,+ *oracleast.CreateDimensionStmt, *oracleast.AlterClusterStmt,+ *oracleast.AlterDimensionStmt, *oracleast.CreateMaterializedZonemapStmt,+ *oracleast.AlterMaterializedZonemapStmt, *oracleast.CreateInmemoryJoinGroupStmt,+ *oracleast.AlterInmemoryJoinGroupStmt, *oracleast.AlterIndexStmt,+ *oracleast.AlterViewStmt, *oracleast.AlterSequenceStmt,+ *oracleast.AlterProcedureStmt, *oracleast.AlterFunctionStmt,+ *oracleast.AlterPackageStmt, *oracleast.AlterTriggerStmt,+ *oracleast.AlterTypeStmt, *oracleast.CreateIndextypeStmt,+ *oracleast.AlterIndextypeStmt, *oracleast.CreateOperatorStmt,+ *oracleast.AlterOperatorStmt, *oracleast.CreateMviewLogStmt,+ *oracleast.AlterMviewLogStmt, *oracleast.CreateAnalyticViewStmt,+ *oracleast.AlterAnalyticViewStmt, *oracleast.CreateJsonDualityViewStmt,+ *oracleast.AlterJsonDualityViewStmt, *oracleast.CreateAttributeDimensionStmt,+ *oracleast.AlterAttributeDimensionStmt, *oracleast.CreateHierarchyStmt,+ *oracleast.AlterHierarchyStmt, *oracleast.CreateDomainStmt,+ *oracleast.AlterDomainStmt, *oracleast.CreatePropertyGraphStmt,+ *oracleast.CreateVectorIndexStmt, *oracleast.CreateLockdownProfileStmt,+ *oracleast.AlterLockdownProfileStmt, *oracleast.CreateOutlineStmt,+ *oracleast.AlterOutlineStmt:+ return base.DDL+ }+ return base.QueryTypeUnknown+}++func (q *omniQuerySpanExtractor) findMissingOmniAccessTable(stmt oracleast.StmtNode, accessTables []base.SchemaResource) *base.ResourceNotFoundError {+ cteNames := collectOmniCTENames(stmt)+ for _, resource := range accessTables {+ if cteNames[resource.Table] || q.existsTableMetadata(resource) {+ continue+ }+ database := resource.Database+ if database == "" {+ database = q.defaultDatabase+ }+ table := resource.Table+ return &base.ResourceNotFoundError{+ Database: &database,+ Table: &table,+ }+ }+ return nil+}++func collectOmniCTENames(stmt oracleast.StmtNode) map[string]bool {+ result := make(map[string]bool)+ oracleast.Inspect(stmt, func(node oracleast.Node) bool {+ cte, ok := node.(*oracleast.CTE)+ if ok {+ result[cte.Name] = true+ }+ return true+ })+ return result+}++func collectOmniAccessTables(defaultDatabase string, stmt oracleast.StmtNode) []base.SchemaResource {+ seen := make(map[base.SchemaResource]bool)+ var result []base.SchemaResource+ addResource := func(name *oracleast.ObjectName) {+ if name == nil || name.Name == "DUAL" || name.DBLink != "" {+ return+ }+ database := name.Schema+ if database == "" {+ database = defaultDatabase+ }+ resource := base.SchemaResource{+ Database: database,+ Table: name.Name,+ }+ if !seen[resource] {+ seen[resource] = true+ result = append(result, resource)+ }+ }+ oracleast.Inspect(stmt, func(node oracleast.Node) bool {+ switch node := node.(type) {+ case *oracleast.TableRef:+ if node.Dblink == "" {+ addResource(node.Name)+ }+ case *oracleast.ContainersExpr:+ addResource(node.Name)+ default:+ }+ return true+ })+ return result+}++func (q *omniQuerySpanExtractor) clone() *omniQuerySpanExtractor {+ copyExtractor := *q.querySpanExtractor+ return &omniQuerySpanExtractor{+ querySpanExtractor: ©Extractor,+ source: q.source,+ topLevelTableSourcesFrom: cloneTableSourceSlice(q.topLevelTableSourcesFrom),+ }+}++func (q *omniQuerySpanExtractor) extractOmniSelect(stmt *oracleast.SelectStmt) (base.TableSource, error) {+ if stmt == nil {+ return nil, nil+ }+ if stmt.Pivot != nil {+ return nil, errors.Errorf("unsupported oracle table source: %T", stmt.Pivot)+ }+ if stmt.Unpivot != nil {+ return nil, errors.Errorf("unsupported oracle table source: %T", stmt.Unpivot)+ }+ if stmt.ModelClause != nil {+ return nil, errors.Errorf("unsupported oracle table source: %T", stmt.ModelClause)+ }++ 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)+ }++ 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) 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, *oracleast.PivotClause, *oracleast.UnpivotClause, *oracleast.MatchRecognizeClause:+ return nil, errors.Errorf("unsupported oracle table source: %T", expr)+ default:+ return nil, errors.Errorf("unsupported oracle table source: %T", expr)+ }+}++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) {+ 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, q.getOmniFieldColumnSource(node.Schema, node.Table, node.Column))+ }+ 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 cloneQuerySpanResults(results []base.QuerySpanResult) []base.QuerySpanResult {+ cloned := make([]base.QuerySpanResult, 0, len(results))+ for _, result := range results {+ cloned = append(cloned, base.QuerySpanResult{+ Name: result.Name,+ SourceColumns: cloneSourceColumnSet(result.SourceColumns),+ IsPlainField: result.IsPlainField,+ })+ }+ 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 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 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 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_omni_parity_test.gonew file mode 100644index 0000000000..cca3b59cef--- /dev/null+++ b/backend/plugin/parser/plsql/query_span_omni_parity_test.go@@ -0,0 +1,532 @@+package plsql++import (+ "context"+ "fmt"+ "io"+ "os"+ "reflect"+ "strings"+ "testing"++ "github.com/stretchr/testify/require"+ "gopkg.in/yaml.v3"++ "github.com/bytebase/bytebase/backend/common"+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ "github.com/bytebase/bytebase/backend/plugin/parser/base"+)++// TestOracleOmniQuerySpanGoldenHarness is the strict cutover guard. It compares+// the package-internal omni path against the existing YAML corpus instead of+// comparing GetQuerySpan to itself after the production cutover.+func TestOracleOmniQuerySpanGoldenHarness(t *testing.T) {+ type testCase struct {+ Description string `yaml:"description,omitempty"`+ Statement string `yaml:"statement,omitempty"`+ DefaultDatabase string `yaml:"defaultDatabase,omitempty"`+ Metadata string `yaml:"metadata,omitempty"`+ CrossDatabaseMetadata string `yaml:"crossDatabaseMetadata,omitempty"`+ QuerySpan *base.YamlQuerySpan `yaml:"querySpan,omitempty"`+ }++ type diff struct {+ index int+ description string+ statement string+ details string+ }++ const testDataPath = "test-data/query_span.yaml"+ yamlFile, err := os.Open(testDataPath)+ require.NoError(t, err)+ byteValue, err := io.ReadAll(yamlFile)+ require.NoError(t, err)+ require.NoError(t, yamlFile.Close())++ var testCases []testCase+ require.NoError(t, yaml.Unmarshal(byteValue, &testCases))++ var diffs []diff+ for i, tc := range testCases {+ if strings.TrimSpace(tc.Statement) == "" {+ continue+ }++ omni, err := runOracleOmniGoldenCase(context.Background(), tc.Statement, tc.Metadata, tc.CrossDatabaseMetadata, tc.DefaultDatabase)+ if err != nil {+ diffs = append(diffs, diff{+ index: i,+ description: tc.Description,+ statement: tc.Statement,+ details: err.Error(),+ })+ continue+ }+ if !reflect.DeepEqual(tc.QuerySpan, omni) {+ diffs = append(diffs, diff{+ index: i,+ description: tc.Description,+ statement: tc.Statement,+ details: fmt.Sprintf("want=%+v omni=%+v", tc.QuerySpan, omni),+ })+ }+ }++ t.Logf("Oracle omni query-span golden: %d/%d matched, %d diffs", len(testCases)-len(diffs), len(testCases), len(diffs))+ for i, d := range diffs {+ if i >= 10 {+ t.Logf("... %d more diffs omitted", len(diffs)-i)+ break+ }+ t.Logf("[case %d %q] %s\n SQL: %s", d.index, d.description, d.details, firstOracleOmniProbeLine(d.statement))+ }+ require.Empty(t, diffs)+}++func runOracleOmniGoldenCase(+ ctx context.Context,+ statement string,+ metadataText string,+ crossDatabaseMetadataText string,+ defaultDatabase string,+) (*base.YamlQuerySpan, error) {+ metadata := &storepb.DatabaseSchemaMetadata{}+ if err := common.ProtojsonUnmarshaler.Unmarshal([]byte(metadataText), metadata); err != nil {+ return nil, err+ }+ list := []*storepb.DatabaseSchemaMetadata{metadata}+ if crossDatabaseMetadataText != "" {+ crossDatabase := &storepb.DatabaseSchemaMetadata{}+ if err := common.ProtojsonUnmarshaler.Unmarshal([]byte(crossDatabaseMetadataText), crossDatabase); err != nil {+ return nil, err+ }+ list = append(list, crossDatabase)+ }++ databaseMetadataGetter, databaseNamesLister, linkedDatabaseMetadataGetter := buildMockDatabaseMetadataGetter(list)+ gCtx := base.GetQuerySpanContext{+ InstanceID: instanceIDA,+ GetDatabaseMetadataFunc: databaseMetadataGetter,+ ListDatabaseNamesFunc: databaseNamesLister,+ GetLinkedDatabaseMetadataFunc: linkedDatabaseMetadataGetter,+ }++ omni, err := newOmniQuerySpanExtractor(defaultDatabase, gCtx).getOmniQuerySpan(ctx, statement)+ if err != nil {+ return nil, err+ }+ return omni.ToYaml(), nil+}++func TestOracleOmniLongTailTableSources(t *testing.T) {+ tests := []struct {+ name string+ statement string+ wantResult string+ wantSourceColumns []base.ColumnResource+ wantQuerySources []base.ColumnResource+ }{+ {+ name: "json table",+ statement: "SELECT JT.ID FROM T, JSON_TABLE(T.J, '$' COLUMNS (ID NUMBER PATH '$.id')) JT",+ wantResult: "ID",+ wantSourceColumns: []base.ColumnResource{{Database: "PUBLIC", Table: "T", Column: "J"}},+ wantQuerySources: []base.ColumnResource{{Database: "PUBLIC", Table: "T"}},+ },+ {+ name: "xml table",+ statement: "SELECT XT.ID FROM T, XMLTABLE('/root' PASSING T.X COLUMNS ID NUMBER PATH 'id') XT",+ wantResult: "ID",+ wantSourceColumns: []base.ColumnResource{{Database: "PUBLIC", Table: "T", Column: "X"}},+ wantQuerySources: []base.ColumnResource{{Database: "PUBLIC", Table: "T"}},+ },+ {+ name: "containers",+ statement: "SELECT A FROM CONTAINERS(T)",+ wantResult: "A",+ wantSourceColumns: []base.ColumnResource{{Database: "PUBLIC", Table: "T", Column: "A"}},+ wantQuerySources: []base.ColumnResource{{Database: "PUBLIC", Table: "T"}},+ },+ {+ name: "inline external table",+ statement: "SELECT EXT.A FROM EXTERNAL ((A NUMBER, B VARCHAR2(20)) TYPE ORACLE_LOADER DEFAULT DIRECTORY D ACCESS PARAMETERS (FIELDS TERMINATED BY ',') LOCATION ('x.csv')) EXT",+ wantResult: "A",+ wantSourceColumns: []base.ColumnResource{},+ wantQuerySources: []base.ColumnResource{},+ },+ }++ for _, test := range tests {+ t.Run(test.name, func(t *testing.T) {+ span, err := newOmniQuerySpanExtractor("PUBLIC", oracleOmniLongTailTestContext(t)).getOmniQuerySpan(context.Background(), test.statement)+ require.NoError(t, err)+ require.NotNil(t, span)+ require.Len(t, span.Results, 1)+ require.Equal(t, test.wantResult, span.Results[0].Name)+ require.Equal(t, sourceColumnSetFromList(test.wantSourceColumns), span.Results[0].SourceColumns)+ require.Equal(t, sourceColumnSetFromList(test.wantQuerySources), span.SourceColumns)+ })+ }+}++func TestOracleOmniAnalyticCountStarSources(t *testing.T) {+ span, err := newOmniQuerySpanExtractor("PUBLIC", oracleOmniLongTailTestContext(t)).getOmniQuerySpan(+ context.Background(),+ "SELECT COUNT(*) OVER (PARTITION BY B ORDER BY A) AS C FROM T",+ )+ require.NoError(t, err)+ require.NotNil(t, span)+ require.Len(t, span.Results, 1)+ require.Equal(t, "C", span.Results[0].Name)+ require.Equal(t, sourceColumnSetFromList([]base.ColumnResource{+ {Database: "PUBLIC", Table: "T", Column: "A"},+ {Database: "PUBLIC", Table: "T", Column: "B"},+ }), span.Results[0].SourceColumns)+}++func TestOracleOmniUnqualifiedStarExpandsAllCommaSources(t *testing.T) {+ tests := []struct {+ name string+ statement string+ want []base.QuerySpanResult+ }{+ {+ name: "base tables",+ statement: "SELECT * FROM T, T2",+ want: []base.QuerySpanResult{+ {Name: "A", SourceColumns: sourceColumnSetFromList([]base.ColumnResource{{Database: "PUBLIC", Table: "T", Column: "A"}})},+ {Name: "B", SourceColumns: sourceColumnSetFromList([]base.ColumnResource{{Database: "PUBLIC", Table: "T", Column: "B"}})},+ {Name: "C", SourceColumns: sourceColumnSetFromList([]base.ColumnResource{{Database: "PUBLIC", Table: "T", Column: "C"}})},+ {Name: "J", SourceColumns: sourceColumnSetFromList([]base.ColumnResource{{Database: "PUBLIC", Table: "T", Column: "J"}})},+ {Name: "X", SourceColumns: sourceColumnSetFromList([]base.ColumnResource{{Database: "PUBLIC", Table: "T", Column: "X"}})},+ {Name: "C", SourceColumns: sourceColumnSetFromList([]base.ColumnResource{{Database: "PUBLIC", Table: "T2", Column: "C"}})},+ {Name: "D", SourceColumns: sourceColumnSetFromList([]base.ColumnResource{{Database: "PUBLIC", Table: "T2", Column: "D"}})},+ },+ },+ {+ name: "json table",+ statement: "SELECT * FROM T, JSON_TABLE(T.J, '$' COLUMNS (ID NUMBER PATH '$.id')) JT",+ want: []base.QuerySpanResult{+ {Name: "A", SourceColumns: sourceColumnSetFromList([]base.ColumnResource{{Database: "PUBLIC", Table: "T", Column: "A"}})},+ {Name: "B", SourceColumns: sourceColumnSetFromList([]base.ColumnResource{{Database: "PUBLIC", Table: "T", Column: "B"}})},+ {Name: "C", SourceColumns: sourceColumnSetFromList([]base.ColumnResource{{Database: "PUBLIC", Table: "T", Column: "C"}})},+ {Name: "J", SourceColumns: sourceColumnSetFromList([]base.ColumnResource{{Database: "PUBLIC", Table: "T", Column: "J"}})},+ {Name: "X", SourceColumns: sourceColumnSetFromList([]base.ColumnResource{{Database: "PUBLIC", Table: "T", Column: "X"}})},+ {Name: "ID", SourceColumns: sourceColumnSetFromList([]base.ColumnResource{{Database: "PUBLIC", Table: "T", Column: "J"}})},+ },+ },+ {+ name: "join",+ statement: "SELECT * FROM T JOIN T2 ON T.A = T2.C",+ want: []base.QuerySpanResult{+ {Name: "A", SourceColumns: sourceColumnSetFromList([]base.ColumnResource{{Database: "PUBLIC", Table: "T", Column: "A"}})},+ {Name: "B", SourceColumns: sourceColumnSetFromList([]base.ColumnResource{{Database: "PUBLIC", Table: "T", Column: "B"}})},+ {Name: "C", SourceColumns: sourceColumnSetFromList([]base.ColumnResource{{Database: "PUBLIC", Table: "T", Column: "C"}})},+ {Name: "J", SourceColumns: sourceColumnSetFromList([]base.ColumnResource{{Database: "PUBLIC", Table: "T", Column: "J"}})},+ {Name: "X", SourceColumns: sourceColumnSetFromList([]base.ColumnResource{{Database: "PUBLIC", Table: "T", Column: "X"}})},+ {Name: "C", SourceColumns: sourceColumnSetFromList([]base.ColumnResource{{Database: "PUBLIC", Table: "T2", Column: "C"}})},+ {Name: "D", SourceColumns: sourceColumnSetFromList([]base.ColumnResource{{Database: "PUBLIC", Table: "T2", Column: "D"}})},+ },+ },+ {+ name: "natural join",+ statement: "SELECT * FROM T NATURAL JOIN T2",+ want: []base.QuerySpanResult{+ {Name: "A", SourceColumns: sourceColumnSetFromList([]base.ColumnResource{{Database: "PUBLIC", Table: "T", Column: "A"}})},+ {Name: "B", SourceColumns: sourceColumnSetFromList([]base.ColumnResource{{Database: "PUBLIC", Table: "T", Column: "B"}})},+ {Name: "C", SourceColumns: sourceColumnSetFromList([]base.ColumnResource{+ {Database: "PUBLIC", Table: "T", Column: "C"},+ {Database: "PUBLIC", Table: "T2", Column: "C"},+ })},+ {Name: "J", SourceColumns: sourceColumnSetFromList([]base.ColumnResource{{Database: "PUBLIC", Table: "T", Column: "J"}})},+ {Name: "X", SourceColumns: sourceColumnSetFromList([]base.ColumnResource{{Database: "PUBLIC", Table: "T", Column: "X"}})},+ {Name: "D", SourceColumns: sourceColumnSetFromList([]base.ColumnResource{{Database: "PUBLIC", Table: "T2", Column: "D"}})},+ },+ },+ }++ for _, test := range tests {+ t.Run(test.name, func(t *testing.T) {+ span, err := newOmniQuerySpanExtractor("PUBLIC", oracleOmniLongTailTestContext(t)).getOmniQuerySpan(context.Background(), test.statement)+ require.NoError(t, err)+ require.NotNil(t, span)+ require.Len(t, span.Results, len(test.want))+ for i, want := range test.want {+ require.Equal(t, want.Name, span.Results[i].Name)+ require.Equal(t, want.SourceColumns, span.Results[i].SourceColumns)+ }+ })+ }+}++func TestOracleOmniCTEScopeAndSetOperations(t *testing.T) {+ tests := []struct {+ name string+ statement string+ want []base.QuerySpanResult+ }{+ {+ name: "sibling cte references previous cte",+ statement: "WITH C1 AS (SELECT A FROM T), C2 AS (SELECT A FROM C1 UNION SELECT C FROM T2) SELECT * FROM C2",+ want: []base.QuerySpanResult{+ {Name: "A", SourceColumns: sourceColumnSetFromList([]base.ColumnResource{+ {Database: "PUBLIC", Table: "T", Column: "A"},+ {Database: "PUBLIC", Table: "T2", Column: "C"},+ })},+ },+ },+ {+ name: "cte name shadows physical table",+ statement: "WITH T AS (SELECT C FROM T2) SELECT * FROM T",+ want: []base.QuerySpanResult{+ {Name: "C", SourceColumns: sourceColumnSetFromList([]base.ColumnResource{{Database: "PUBLIC", Table: "T2", Column: "C"}})},+ },+ },+ {+ name: "nested cte name shadows outer cte",+ statement: "WITH C AS (WITH C AS (SELECT C FROM T2) SELECT C FROM C) SELECT * FROM C",+ want: []base.QuerySpanResult{+ {Name: "C", SourceColumns: sourceColumnSetFromList([]base.ColumnResource{{Database: "PUBLIC", Table: "T2", Column: "C"}})},+ },+ },+ {+ name: "multiple ctes join",+ statement: "WITH C1 AS (SELECT A FROM T), C2 AS (SELECT C FROM T2) SELECT C1.A, C2.C FROM C1 JOIN C2 ON C1.A = C2.C",+ want: []base.QuerySpanResult{+ {Name: "A", SourceColumns: sourceColumnSetFromList([]base.ColumnResource{{Database: "PUBLIC", Table: "T", Column: "A"}})},+ {Name: "C", SourceColumns: sourceColumnSetFromList([]base.ColumnResource{{Database: "PUBLIC", Table: "T2", Column: "C"}})},+ },+ },+ {+ name: "intersect merges source columns positionally",+ statement: "SELECT A FROM T INTERSECT SELECT C FROM T2",+ want: []base.QuerySpanResult{+ {Name: "A", SourceColumns: sourceColumnSetFromList([]base.ColumnResource{+ {Database: "PUBLIC", Table: "T", Column: "A"},+ {Database: "PUBLIC", Table: "T2", Column: "C"},+ })},+ },+ },+ {+ name: "minus merges source columns positionally",+ statement: "SELECT A FROM T MINUS SELECT C FROM T2",+ want: []base.QuerySpanResult{+ {Name: "A", SourceColumns: sourceColumnSetFromList([]base.ColumnResource{+ {Database: "PUBLIC", Table: "T", Column: "A"},+ {Database: "PUBLIC", Table: "T2", Column: "C"},+ })},+ },+ },+ {+ name: "recursive cte reaches stable source closure",+ statement: "WITH C(X) AS (SELECT A FROM T UNION ALL SELECT T2.C FROM T2 JOIN C ON C.X = T2.C) SELECT * FROM C",+ want: []base.QuerySpanResult{+ {Name: "X", SourceColumns: sourceColumnSetFromList([]base.ColumnResource{+ {Database: "PUBLIC", Table: "T", Column: "A"},+ {Database: "PUBLIC", Table: "T2", Column: "C"},+ })},+ },+ },+ }++ for _, test := range tests {+ t.Run(test.name, func(t *testing.T) {+ span, err := newOmniQuerySpanExtractor("PUBLIC", oracleOmniLongTailTestContext(t)).getOmniQuerySpan(context.Background(), test.statement)+ require.NoError(t, err)+ require.NotNil(t, span)+ require.Equal(t, test.want, span.Results)+ })+ }+}++func TestOracleOmniExpressionAndAccessTableCoverage(t *testing.T) {+ t.Run("expression nodes keep source columns", func(t *testing.T) {+ span, err := newOmniQuerySpanExtractor("PUBLIC", oracleOmniLongTailTestContext(t)).getOmniQuerySpan(+ context.Background(),+ `SELECT+ CASE WHEN A > 0 THEN B ELSE C END AS CASE_VALUE,+ DECODE(A, 1, B, C) AS DECODE_VALUE,+ CAST(A AS NUMBER) AS CAST_VALUE,+ B BETWEEN A AND C AS BETWEEN_VALUE,+ X LIKE J AS LIKE_VALUE+FROM T`,+ )+ require.NoError(t, err)+ require.NotNil(t, span)+ want := []base.QuerySpanResult{+ {Name: "CASE_VALUE", SourceColumns: sourceColumnSetFromList([]base.ColumnResource{+ {Database: "PUBLIC", Table: "T", Column: "A"},+ {Database: "PUBLIC", Table: "T", Column: "B"},+ {Database: "PUBLIC", Table: "T", Column: "C"},+ })},+ {Name: "DECODE_VALUE", SourceColumns: sourceColumnSetFromList([]base.ColumnResource{+ {Database: "PUBLIC", Table: "T", Column: "A"},+ {Database: "PUBLIC", Table: "T", Column: "B"},+ {Database: "PUBLIC", Table: "T", Column: "C"},+ })},+ {Name: "CAST_VALUE", SourceColumns: sourceColumnSetFromList([]base.ColumnResource{{Database: "PUBLIC", Table: "T", Column: "A"}})},+ {Name: "BETWEEN_VALUE", SourceColumns: sourceColumnSetFromList([]base.ColumnResource{+ {Database: "PUBLIC", Table: "T", Column: "A"},+ {Database: "PUBLIC", Table: "T", Column: "B"},+ {Database: "PUBLIC", Table: "T", Column: "C"},+ })},+ {Name: "LIKE_VALUE", SourceColumns: sourceColumnSetFromList([]base.ColumnResource{+ {Database: "PUBLIC", Table: "T", Column: "J"},+ {Database: "PUBLIC", Table: "T", Column: "X"},+ })},+ }+ require.Equal(t, want, span.Results)+ })++ t.Run("subqueries in non result clauses contribute access tables", func(t *testing.T) {+ tests := []string{+ "SELECT A FROM T WHERE EXISTS (SELECT C FROM T2 WHERE T2.C = T.A)",+ "SELECT A FROM T ORDER BY (SELECT C FROM T2)",+ "SELECT COALESCE((SELECT C FROM T2), A) FROM T",+ }+ for _, statement := range tests {+ span, err := newOmniQuerySpanExtractor("PUBLIC", oracleOmniLongTailTestContext(t)).getOmniQuerySpan(context.Background(), statement)+ require.NoError(t, err, statement)+ require.NotNil(t, span, statement)+ require.Equal(t, sourceColumnSetFromList([]base.ColumnResource{+ {Database: "PUBLIC", Table: "T"},+ {Database: "PUBLIC", Table: "T2"},+ }), span.SourceColumns, statement)+ }+ })++ t.Run("cursor expression uses subquery scope", func(t *testing.T) {+ span, err := newOmniQuerySpanExtractor("PUBLIC", oracleOmniLongTailTestContext(t)).getOmniQuerySpan(+ context.Background(),+ "SELECT CURSOR(SELECT C FROM T2) AS CUR FROM T",+ )+ require.NoError(t, err)+ require.NotNil(t, span)+ require.Equal(t, []base.QuerySpanResult{+ {Name: "CUR", SourceColumns: sourceColumnSetFromList([]base.ColumnResource{{Database: "PUBLIC", Table: "T2", Column: "C"}})},+ }, span.Results)+ })+}++func TestOracleOmniResourceNotFoundPropagation(t *testing.T) {+ tests := []struct {+ name string+ statement string+ }{+ {+ name: "top level table",+ statement: "SELECT A FROM MISSING_TABLE",+ },+ {+ name: "predicate subquery",+ statement: "SELECT A FROM T WHERE EXISTS (SELECT 1 FROM MISSING_TABLE)",+ },+ {+ name: "target subquery",+ statement: "SELECT (SELECT A FROM MISSING_TABLE) AS A FROM T",+ },+ {+ name: "recursive cte arm",+ statement: "WITH C(X) AS (SELECT A FROM T UNION ALL SELECT MISSING_TABLE.A FROM MISSING_TABLE JOIN C ON C.X = MISSING_TABLE.A) SELECT * FROM C",+ },+ }++ for _, test := range tests {+ t.Run(test.name, func(t *testing.T) {+ span, err := newOmniQuerySpanExtractor("PUBLIC", oracleOmniLongTailTestContext(t)).getOmniQuerySpan(context.Background(), test.statement)+ require.NoError(t, err)+ require.NotNil(t, span)+ require.Empty(t, span.Results)+ require.ErrorAs(t, span.NotFoundError, new(*base.ResourceNotFoundError))+ })+ }+}++func TestOracleOmniUnsupportedLongTailTableSources(t *testing.T) {+ // UNPIVOT and MODEL used to return approximate ANTLR spans that ignored+ // their transformation semantics. Keep them explicit unsupported until the+ // omni extractor models their output columns accurately.+ tests := []struct {+ name string+ statement string+ }{+ {+ name: "table collection",+ statement: "SELECT * FROM TABLE(pkg.values()) X",+ },+ {+ name: "pivot",+ statement: "SELECT * FROM (SELECT A, B FROM T) PIVOT (COUNT(*) FOR B IN (1 AS ONE))",+ },+ {+ name: "unpivot",+ statement: "SELECT * FROM (SELECT A, B FROM T) UNPIVOT (VAL FOR COL IN (A AS 'A', B AS 'B'))",+ },+ {+ name: "model",+ statement: "SELECT * FROM T MODEL DIMENSION BY (A) MEASURES (B) RULES (B[1] = 1)",+ },+ }++ for _, test := range tests {+ t.Run(test.name, func(t *testing.T) {+ _, err := newOmniQuerySpanExtractor("PUBLIC", oracleOmniLongTailTestContext(t)).getOmniQuerySpan(context.Background(), test.statement)+ require.ErrorContains(t, err, "unsupported oracle table source")+ })+ }+}++func oracleOmniLongTailTestContext(t *testing.T) base.GetQuerySpanContext {+ t.Helper()++ const metadataText = `{+ "name": "PUBLIC",+ "schemas": [{+ "name": "",+ "tables": [{+ "name": "T",+ "columns": [+ {"name": "A"},+ {"name": "B"},+ {"name": "C"},+ {"name": "J"},+ {"name": "X"}+ ]+ }, {+ "name": "T2",+ "columns": [+ {"name": "C"},+ {"name": "D"}+ ]+ }]+ }]+}`++ metadata := &storepb.DatabaseSchemaMetadata{}+ require.NoError(t, common.ProtojsonUnmarshaler.Unmarshal([]byte(metadataText), metadata))+ databaseMetadataGetter, databaseNamesLister, linkedDatabaseMetadataGetter := buildMockDatabaseMetadataGetter([]*storepb.DatabaseSchemaMetadata{metadata})+ return base.GetQuerySpanContext{+ InstanceID: instanceIDA,+ GetDatabaseMetadataFunc: databaseMetadataGetter,+ ListDatabaseNamesFunc: databaseNamesLister,+ GetLinkedDatabaseMetadataFunc: linkedDatabaseMetadataGetter,+ }+}++func firstOracleOmniProbeLine(statement string) string {+ for _, line := range strings.Split(statement, "\n") {+ if strings.TrimSpace(line) != "" {+ return strings.TrimSpace(line)+ }+ }+ return ""+}++func sourceColumnSetFromList(columns []base.ColumnResource) base.SourceColumnSet {+ result := make(base.SourceColumnSet, len(columns))+ for _, column := range columns {+ result[column] = true+ }+ return result+}diff --git a/backend/plugin/parser/plsql/query_span_omni_probe_test.go b/backend/plugin/parser/plsql/query_span_omni_probe_test.gonew file mode 100644index 0000000000..fc45472a48--- /dev/null+++ b/backend/plugin/parser/plsql/query_span_omni_probe_test.go@@ -0,0 +1,198 @@+package plsql++import (+ "io"+ "os"+ "reflect"+ "testing"++ "github.com/bytebase/omni/oracle/ast"+ "github.com/stretchr/testify/require"+ "gopkg.in/yaml.v3"+)++func TestOracleOmniParsesQuerySpanFixtureCorpus(t *testing.T) {+ type testCase struct {+ Description string `yaml:"description,omitempty"`+ Statement string `yaml:"statement,omitempty"`+ }++ yamlFile, err := os.Open("test-data/query_span.yaml")+ require.NoError(t, err)+ defer yamlFile.Close()++ byteValue, err := io.ReadAll(yamlFile)+ require.NoError(t, err)++ var testCases []testCase+ require.NoError(t, yaml.Unmarshal(byteValue, &testCases))++ for _, tc := range testCases {+ t.Run(tc.Description, func(t *testing.T) {+ list, err := ParsePLSQLOmni(tc.Statement)+ require.NoError(t, err)+ require.NotNil(t, list)+ require.Len(t, list.Items, 1)+ require.IsType(t, &ast.RawStmt{}, list.Items[0])+ })+ }+}++func TestOracleOmniQuerySpanMigrationProbe(t *testing.T) {+ tests := []struct {+ name string+ statement string+ expectedNodes []string+ check func(*testing.T, *ast.RawStmt)+ }{+ {+ name: "select columns and table ref",+ statement: "SELECT A, T.B, PUBLIC.T.C FROM T",+ expectedNodes: []string{"SelectStmt", "ResTarget", "ColumnRef", "TableRef"},+ },+ {+ name: "join using",+ statement: "SELECT * FROM T T1 JOIN T T2 USING(A)",+ expectedNodes: []string{"SelectStmt", "JoinClause", "TableRef"},+ },+ {+ name: "derived table",+ statement: "SELECT * FROM (SELECT A FROM T) DT",+ expectedNodes: []string{"SelectStmt", "SubqueryRef", "TableRef"},+ },+ {+ name: "scalar and in subqueries",+ statement: "SELECT (SELECT MAX(A) FROM T) AS M FROM T WHERE B IN (SELECT C FROM T)",+ expectedNodes: []string{"SelectStmt", "SubqueryExpr", "FuncCallExpr", "InExpr"},+ },+ {+ name: "cte and set operation",+ statement: "WITH T1(D, C) AS (SELECT A, B FROM T UNION ALL SELECT C, D FROM T) SELECT * FROM T1",+ expectedNodes: []string{"WithClause", "CTE", "SelectStmt", "TableRef"},+ check: func(t *testing.T, raw *ast.RawStmt) {+ var foundSetOp bool+ ast.Inspect(raw, func(node ast.Node) bool {+ if sel, ok := node.(*ast.SelectStmt); ok && sel.Op != ast.SETOP_NONE {+ foundSetOp = true+ }+ return true+ })+ require.True(t, foundSetOp)+ },+ },+ {+ name: "database link",+ statement: "SELECT * FROM SCHEMA1.LT1@REMOTE",+ expectedNodes: []string{"SelectStmt", "TableRef", "ObjectName"},+ check: func(t *testing.T, raw *ast.RawStmt) {+ var foundDBLink bool+ ast.Inspect(raw, func(node ast.Node) bool {+ if name, ok := node.(*ast.ObjectName); ok && name.Schema == "SCHEMA1" && name.Name == "LT1" && name.DBLink == "REMOTE" {+ foundDBLink = true+ }+ return true+ })+ require.True(t, foundDBLink)+ },+ },+ {+ name: "json table",+ statement: "SELECT JT.ID FROM T, JSON_TABLE(T.J, '$' COLUMNS (ID NUMBER PATH '$.id')) JT",+ expectedNodes: []string{"SelectStmt", "JsonTableRef", "JsonTableColumn", "TableRef"},+ },+ {+ name: "xml table",+ statement: "SELECT XT.ID FROM T, XMLTABLE('/root' PASSING T.X COLUMNS ID NUMBER PATH 'id') XT",+ expectedNodes: []string{"SelectStmt", "XmlTableRef", "XmlTableColumn", "TableRef"},+ },+ {+ name: "containers",+ statement: "SELECT A FROM CONTAINERS(T)",+ expectedNodes: []string{"SelectStmt", "ContainersExpr", "ObjectName"},+ },+ {+ name: "inline external table",+ statement: "SELECT EXT.A FROM EXTERNAL ((A NUMBER, B VARCHAR2(20)) TYPE ORACLE_LOADER DEFAULT DIRECTORY D ACCESS PARAMETERS (FIELDS TERMINATED BY ',') LOCATION ('x.csv')) EXT",+ expectedNodes: []string{"SelectStmt", "InlineExternalTable", "ColumnDef"},+ },+ {+ name: "pivot",+ statement: "SELECT * FROM (SELECT A, B FROM T) PIVOT (COUNT(*) FOR B IN (1 AS ONE))",+ expectedNodes: []string{"SelectStmt", "PivotClause", "SubqueryRef"},+ },+ {+ name: "unpivot",+ statement: "SELECT * FROM (SELECT A, B FROM T) UNPIVOT (VAL FOR COL IN (A AS 'A', B AS 'B'))",+ expectedNodes: []string{"SelectStmt", "UnpivotClause", "SubqueryRef"},+ },+ {+ name: "model",+ statement: "SELECT * FROM T MODEL DIMENSION BY (A) MEASURES (B) RULES (B[1] = 1)",+ expectedNodes: []string{"SelectStmt", "ModelClause", "ModelRule"},+ },+ {+ name: "lateral inline view",+ statement: "SELECT * FROM T, LATERAL (SELECT A FROM DUAL) L",+ expectedNodes: []string{"SelectStmt", "LateralRef", "TableRef"},+ },+ {+ name: "hierarchical query",+ statement: "SELECT A FROM T START WITH A = 1 CONNECT BY PRIOR A = B",+ expectedNodes: []string{"SelectStmt", "HierarchicalClause", "UnaryExpr", "BinaryExpr"},+ },+ {+ name: "analytic function",+ statement: "SELECT SUM(A) OVER (PARTITION BY B ORDER BY C) FROM T",+ expectedNodes: []string{"SelectStmt", "FuncCallExpr", "WindowSpec", "SortBy"},+ },+ {+ name: "explain root",+ statement: "EXPLAIN PLAN FOR SELECT * FROM T",+ expectedNodes: []string{"ExplainPlanStmt", "SelectStmt"},+ },+ {+ name: "dml roots",+ statement: "INSERT INTO T(A) SELECT A FROM T2",+ expectedNodes: []string{"InsertStmt", "SelectStmt", "TableRef"},+ },+ {+ name: "ddl root",+ statement: "CREATE TABLE T(A NUMBER)",+ expectedNodes: []string{"CreateTableStmt", "ColumnDef"},+ },+ }++ for _, test := range tests {+ t.Run(test.name, func(t *testing.T) {+ list, err := ParsePLSQLOmni(test.statement)+ require.NoError(t, err)+ require.Len(t, list.Items, 1)+ raw, ok := list.Items[0].(*ast.RawStmt)+ require.True(t, ok)++ nodeTypes := collectOracleOmniNodeTypes(raw)+ for _, expectedNode := range test.expectedNodes {+ require.Contains(t, nodeTypes, expectedNode)+ }+ if test.check != nil {+ test.check(t, raw)+ }+ })+ }+}++func collectOracleOmniNodeTypes(node ast.Node) map[string]bool {+ result := make(map[string]bool)+ ast.Inspect(node, func(node ast.Node) bool {+ if node == nil {+ return false+ }+ typ := reflect.TypeOf(node)+ if typ.Kind() == reflect.Pointer {+ typ = typ.Elem()+ }+ result[typ.Name()] = true+ return true+ })+ return result+}diff --git a/backend/plugin/parser/plsql/query_type.go b/backend/plugin/parser/plsql/query_type.goindex e800864997..cd1cd1b1d9 100644--- a/backend/plugin/parser/plsql/query_type.go+++ b/backend/plugin/parser/plsql/query_type.go@@ -1,3 +1,4 @@+//nolint:unusedpackage plsqlimport (diff --git a/backend/plugin/parser/plsql/query_type_omni_test.go b/backend/plugin/parser/plsql/query_type_omni_test.gonew file mode 100644index 0000000000..065d95c590--- /dev/null+++ b/backend/plugin/parser/plsql/query_type_omni_test.go@@ -0,0 +1,62 @@+package plsql++import (+ "testing"++ oracleast "github.com/bytebase/omni/oracle/ast"+ "github.com/stretchr/testify/require"++ "github.com/bytebase/bytebase/backend/plugin/parser/base"+)++func TestOracleOmniQueryTypeDDLClassification(t *testing.T) {+ tests := []struct {+ name string+ statement string+ want base.QueryType+ }{+ {+ name: "create table",+ statement: "CREATE TABLE T(A NUMBER)",+ want: base.DDL,+ },+ {+ name: "create database admin ddl",+ statement: "CREATE DATABASE",+ want: base.DDL,+ },+ {+ name: "alter database admin ddl",+ statement: "ALTER DATABASE OPEN",+ want: base.DDL,+ },+ {+ name: "drop database admin ddl",+ statement: "DROP DATABASE",+ want: base.DDL,+ },+ {+ name: "lock table is dml",+ statement: "LOCK TABLE T IN EXCLUSIVE MODE",+ want: base.DML,+ },+ {+ name: "transaction remains unknown",+ statement: "COMMIT",+ want: base.QueryTypeUnknown,+ },+ }++ for _, test := range tests {+ t.Run(test.name, func(t *testing.T) {+ list, err := ParsePLSQLOmni(test.statement)+ require.NoError(t, err)+ require.Len(t, list.Items, 1)+ raw, ok := list.Items[0].(*oracleast.RawStmt)+ require.True(t, ok)+ require.NotNil(t, raw.Stmt)++ require.Equal(t, test.want, omniQueryType(raw.Stmt, false))+ })+ }+}diff --git a/docs/plans/2026-05-28-oracle-query-span-omni-migration.md b/docs/plans/2026-05-28-oracle-query-span-omni-migration.mdnew file mode 100644index 0000000000..104e78ab94--- /dev/null+++ b/docs/plans/2026-05-28-oracle-query-span-omni-migration.md@@ -0,0 +1,108 @@+# Oracle Query Span Omni Migration Implementation Plan++> **For Claude:** REQUIRED SUB-SKILL: Use superpowers:executing-plans to implement this plan task-by-task.++**Goal:** Migrate Oracle query span extraction from the ANTLR parser path to the omni Oracle AST path while preserving the existing query span fixture behavior.++**Architecture:** Add a package-internal omni golden harness that compares the new extractor against `backend/plugin/parser/plsql/test-data/query_span.yaml`. Implement an Oracle omni query span extractor that reuses the existing metadata lookup and column-source semantics where practical, then switch the public `GetQuerySpan` registration to the omni path. Keep the legacy ANTLR extractor available during the migration for existing access-table tests and as a reference until follow-up cleanup.++**Tech Stack:** Go, `github.com/bytebase/omni/oracle/ast`, `github.com/bytebase/omni/oracle/parser`, existing Bytebase parser base query span model.++### Task 1: Oracle Omni Golden Harness++**Files:**+- Create: `backend/plugin/parser/plsql/query_span_omni_parity_test.go`++**Step 1: Write the failing test**++Add a test that loads `backend/plugin/parser/plsql/test-data/query_span.yaml`, builds the same mock metadata context as `TestGetQuerySpan`, and calls `newOmniQuerySpanExtractor(...).getOmniQuerySpan(...)`.++**Step 2: Run test to verify it fails**++Run: `go test -v -count=1 github.com/bytebase/bytebase/backend/plugin/parser/plsql -run '^TestOracleOmniQuerySpanGoldenHarness$'`++Expected: FAIL because `newOmniQuerySpanExtractor` is undefined.++### Task 2: Upgrade Omni++**Files:**+- Modify: `go.mod`+- Modify: `go.sum`++**Step 1: Update dependency**++Run: `go get github.com/bytebase/[email protected]`++**Step 2: Verify parser coverage**++Run: `go test -v -count=1 github.com/bytebase/bytebase/backend/plugin/parser/plsql -run '^TestOracleOmniQuerySpanMigrationProbe$'`++Expected: PASS, including inline external table support through the upgraded omni parser.++### Task 3: Implement Oracle Omni Extractor++**Files:**+- Create: `backend/plugin/parser/plsql/query_span_extractor_omni.go`++**Step 1: Add minimal extractor scaffold**++Implement `newOmniQuerySpanExtractor` and `getOmniQuerySpan` with parsing, statement classification, access-table collection, and select result extraction.++**Step 2: Run golden harness**++Run: `go test -v -count=1 github.com/bytebase/bytebase/backend/plugin/parser/plsql -run '^TestOracleOmniQuerySpanGoldenHarness$'`++Expected: PASS.++### Intentional Behavior Changes++- `JSON_TABLE`, `XMLTABLE`, `CONTAINERS`, and inline external table are supported by the omni query span extractor.+- `PIVOT`, `UNPIVOT`, `MODEL`, and `TABLE(collection)` are intentionally typed unsupported for this migration. In particular, ANTLR could return a successful approximate span for some `UNPIVOT` and `MODEL` queries, but it did not model their transformation semantics accurately. The omni path should fail explicitly until those output columns can be represented correctly.++### Task 4: Switch Public Oracle Query Span Entry++**Files:**+- Modify: `backend/plugin/parser/plsql/query_span.go`++**Step 1: Change registration**++Replace the public Oracle `GetQuerySpan` implementation with the omni extractor path.++**Step 2: Run public fixture test**++Run: `go test -v -count=1 github.com/bytebase/bytebase/backend/plugin/parser/plsql -run '^TestGetQuerySpan$'`++Expected: PASS.++### Task 5: Final Verification++**Files:**+- All modified Go files++**Step 1: Format**++Run: `gofmt -w backend/plugin/parser/plsql/query_span_omni_parity_test.go backend/plugin/parser/plsql/query_span_extractor_omni.go backend/plugin/parser/plsql/query_span.go`++**Step 2: Package tests**++Run: `go test -v -count=1 github.com/bytebase/bytebase/backend/plugin/parser/plsql`++Expected: PASS.++**Step 3: Lint**++Run: `golangci-lint run --allow-parallel-runners`++Expected: `0 issues.`++**Step 4: Auto-fix lint**++Run: `golangci-lint run --fix --allow-parallel-runners`++Expected: `0 issues.`++**Step 5: Build**++Run: `go build -ldflags "-w -s" -p=16 -o ./bytebase-build/bytebase ./backend/bin/server/main.go`++Expected: PASS.diff --git a/go.mod b/go.modindex 99164c8f45..951bf1c659 100644--- a/go.mod+++ b/go.mod@@ -34,7 +34,7 @@ require (github.com/bmatcuk/doublestar/v4 v4.10.0github.com/bytebase/gomongo v0.0.0-20260510192859-8526a440b352github.com/bytebase/lsp-protocol v0.0.0-20250324071136-1586d0c10ff0- github.com/bytebase/omni v0.0.0-20260527100738-02b1a9f3a954+ github.com/bytebase/omni v0.0.0-20260528064644-6ef6c2c2b826github.com/caarlos0/env/v11 v11.4.1github.com/cenkalti/backoff/v5 v5.0.3github.com/cockroachdb/cockroachdb-parser v0.25.2diff --git a/go.sum b/go.sumindex 322442fd56..f7fb22acf6 100644--- a/go.sum+++ b/go.sum@@ -250,8 +250,8 @@ github.com/bytebase/gomongo v0.0.0-20260510192859-8526a440b352 h1:3sC5pdvJ7bNAhRgithub.com/bytebase/gomongo v0.0.0-20260510192859-8526a440b352/go.mod h1:eyWrxE51HCbjGIChvty/mYaNcAroXshnIiR6SIqlxfY=github.com/bytebase/lsp-protocol v0.0.0-20250324071136-1586d0c10ff0 h1:bJ8NSf2K+pccl5m/wuu97fiYjDwpJH6IzURAq/3XA2U=github.com/bytebase/lsp-protocol v0.0.0-20250324071136-1586d0c10ff0/go.mod h1:BEWMfiZtqshdmulKJcIsWb45MUaEvDO4CROcgi8dfFg=-github.com/bytebase/omni v0.0.0-20260527100738-02b1a9f3a954 h1:ADmVnC+pOrjcqzI7m8UAafCUYQwGsXgawz/nsuJYQDY=-github.com/bytebase/omni v0.0.0-20260527100738-02b1a9f3a954/go.mod h1:EVG8nQbNPUnUBGKn6J0niSGOs3jgfKo3TciY22R4bfo=+github.com/bytebase/omni v0.0.0-20260528064644-6ef6c2c2b826 h1:Ow343I2DTKscD+MG65qItnE60jM3dQTJovVz0UPCelM=+github.com/bytebase/omni v0.0.0-20260528064644-6ef6c2c2b826/go.mod h1:EVG8nQbNPUnUBGKn6J0niSGOs3jgfKo3TciY22R4bfo=github.com/bytebase/parser v0.0.0-20260417075056-57b6ef7a2640 h1:g4Jed1/Jv/DHBiQmEgN5ILOQDDBjFlG4N4Lp+3B4aYE=github.com/bytebase/parser v0.0.0-20260417075056-57b6ef7a2640/go.mod h1:jeak/EfutSOAuWKvrFIT2IZunhWprM7oTFBRgZ9RCxo=github.com/bytebase/pgx/v5 v5.0.0-20250212161523-96ff8aed8767 h1:YuR5G3LcxpO5ScSTA+Kdirxg9RW4TRc/v1t7N2Hfmbw=