Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
fix(masking)!: refuse SQL Server queries whose joins and row limits read masked columns (#21667)
rebelice6589af9dcbe3
diff --git a/backend/plugin/parser/tsql/query_span_extractor.go b/backend/plugin/parser/tsql/query_span_extractor.goindex dece095136..5cd8c1f795 100644--- a/backend/plugin/parser/tsql/query_span_extractor.go+++ b/backend/plugin/parser/tsql/query_span_extractor.go@@ -584,6 +584,9 @@ func (q *omniQuerySpanExtractor) extractFromSelectStmt(sel *ast.SelectStmt) (*baif err := q.collectPredicatesInScope(sel.HavingClause); err != nil {return nil, err}+ if err := q.collectRowCountPredicates(sel); err != nil {+ return nil, err+ }// Target list.results, err := q.extractTargetList(sel.TargetList)@@ -772,6 +775,44 @@ func (q *omniQuerySpanExtractor) collectPredicatesInScope(expr ast.Node) error {}}+// collectRowCountPredicates records what TOP, OFFSET, and FETCH read, since+// they decide how many rows come back, and the conditions of subqueries in+// ORDER BY. The ORDER BY keys themselves only order the rows.+func (q *omniQuerySpanExtractor) collectRowCountPredicates(sel *ast.SelectStmt) error {+ if sel.Top != nil {+ if err := q.collectPredicatesInScope(sel.Top.Count); err != nil {+ return err+ }+ }+ if err := q.collectPredicatesInScope(sel.OffsetClause); err != nil {+ return err+ }+ if sel.FetchClause != nil {+ if err := q.collectPredicatesInScope(sel.FetchClause.Count); err != nil {+ return err+ }+ }+ if sel.OrderByClause == nil {+ return nil+ }+ var err error+ ast.Inspect(sel.OrderByClause, func(n ast.Node) bool {+ if err != nil {+ return false+ }+ sub, ok := n.(*ast.SelectStmt)+ if !ok {+ return true+ }+ clone := q.cloneForSubquery()+ if _, err = clone.extractFromSelectStmt(sub); err == nil {+ q.predicateColumns, _ = base.MergeSourceColumnSet(q.predicateColumns, clone.predicateColumns)+ }+ return false+ })+ return err+}+func (q *omniQuerySpanExtractor) mergeSubqueryIntoPredicates(body ast.Node) error {sel, ok := body.(*ast.SelectStmt)if !ok {@@ -814,6 +855,15 @@ func (q *omniQuerySpanExtractor) extractFromSetOp(sel *ast.SelectStmt) (*base.Psif err != nil {return nil, err}+ if sel.Op == ast.SetOpIntersect || sel.Op == ast.SetOpExcept {+ // INTERSECT and EXCEPT keep a row by whether the other arm has it, so+ // both arms' output columns decide which rows come back.+ for _, arm := range []base.TableSource{left, right} {+ for _, c := range arm.GetQuerySpanResult() {+ q.predicateColumns, _ = base.MergeSourceColumnSet(q.predicateColumns, c.SourceColumns)+ }+ }+ }merged, err := unionTableSources(left, right)if err != nil {return nil, err@@ -877,8 +927,8 @@ func (q *omniQuerySpanExtractor) extractCTEBody(cteName string, body *ast.Select}}- // Non-set-op CTE: extract directly.- if body.Op == ast.SetOpNone || (body.Larg == nil && body.Rarg == nil) {+ // Only UNION can be recursive; extract every other CTE directly.+ if body.Op != ast.SetOpUnion || (body.Larg == nil && body.Rarg == nil) {clone := newClone()pseudo, err := clone.extractFromSelectStmt(body)if err != nil {@@ -997,19 +1047,26 @@ func unsupportedNodeError(message string, node ast.Node) error {}func (q *omniQuerySpanExtractor) extractFromJoin(j *ast.JoinClause) ([]base.TableSource, error) {+ tableSourcesSnapshot := len(q.tableSourcesFrom)+ defer func() { q.tableSourcesFrom = q.tableSourcesFrom[:tableSourcesSnapshot] }()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}+ if j.Condition != nil {+ q.tableSourcesFrom = append(q.tableSourcesFrom[:tableSourcesSnapshot], left...)+ q.tableSourcesFrom = append(q.tableSourcesFrom, right...)+ if err := q.collectPredicatesInScope(j.Condition); err != nil {+ return nil, err+ }+ }return append(left, right...), nil}@@ -1102,6 +1159,8 @@ func (q *omniQuerySpanExtractor) resolveTableValuedFunction(fn *ast.FuncCallExprif err != nil {return nil, err}+ // The arguments decide how many rows the function returns.+ q.predicateColumns, _ = base.MergeSourceColumnSet(q.predicateColumns, argSources.SourceColumns)columns := make([]base.QuerySpanResult, 0, len(columnNames))for _, name := range columnNames {columns = append(columns, base.QuerySpanResult{diff --git a/backend/plugin/parser/tsql/query_span_extractor_test.go b/backend/plugin/parser/tsql/query_span_extractor_test.goindex 218c8e9527..1c69a85c8b 100644--- a/backend/plugin/parser/tsql/query_span_extractor_test.go+++ b/backend/plugin/parser/tsql/query_span_extractor_test.go@@ -603,6 +603,7 @@ func TestOmniQuerySpan_UnresolvedColumnErrors(t *testing.T) {{"select_list", "SELECT no_such_col FROM t"},{"qualified_select_list", "SELECT t.no_such_col FROM t"},{"where_predicate", "SELECT a FROM t WHERE no_such_col = 1"},+ {"join_condition", "SELECT t.a FROM t JOIN t1 ON t1.no_such_col = t.a"},{"window_partition", "SELECT SUM(a) OVER (PARTITION BY no_such_col) FROM t"},{"window_order", "SELECT SUM(a) OVER (ORDER BY no_such_col) FROM t"},{"within_group_order", "SELECT PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY no_such_col) FROM t"},diff --git a/backend/plugin/parser/tsql/query_span_predicate.go b/backend/plugin/parser/tsql/query_span_predicate.godeleted file mode 100644index 148c1a2f9e..0000000000--- a/backend/plugin/parser/tsql/query_span_predicate.go+++ /dev/null@@ -1,170 +0,0 @@-package tsql--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.-//-// Scope it covers:-// - direct column references in the expression-// - FULLTEXT predicate column lists (CONTAINS / FREETEXT)-// - nested subqueries: their WHERE / HAVING / ON / CTE bodies are descended-//-// Scope it does NOT cover (left to the extractor):-// - a subquery's SELECT-list output columns that flow back into the outer-// predicate via IN / scalar subquery / ANY|ALL — those require the-// extractor's table-source resolution.-// - table sources in a FROM clause other than their JOIN ON / derived-table-// WHERE.-func collectOmniPredicateColumnRefs(expr ast.ExprNode) []*ast.ColumnRef {- var out []*ast.ColumnRef- walkOmniPredicateExpr(expr, &out)- return out-}--// collectOmniSelectPredicateColumnRefs returns predicate column refs reachable-// from a SelectStmt's WHERE, HAVING, JOIN ON conditions, set-op arms, and CTE-// bodies.-func collectOmniSelectPredicateColumnRefs(sel *ast.SelectStmt) []*ast.ColumnRef {- var out []*ast.ColumnRef- walkOmniSelectPredicates(sel, &out)- return out-}--func walkOmniPredicateExpr(n ast.Node, out *[]*ast.ColumnRef) {- if n == nil {- return- }- switch v := n.(type) {- case *ast.ColumnRef:- *out = append(*out, v)- case *ast.FullTextPredicate:- if v.Columns != nil {- for _, item := range v.Columns.Items {- if cr, ok := item.(*ast.ColumnRef); ok {- *out = append(*out, cr)- }- }- }- walkOmniPredicateExpr(v.Value, out)- walkOmniPredicateExpr(v.LanguageTerm, out)- case *ast.BinaryExpr:- walkOmniPredicateExpr(v.Left, out)- walkOmniPredicateExpr(v.Right, out)- case *ast.UnaryExpr:- walkOmniPredicateExpr(v.Operand, out)- case *ast.BetweenExpr:- walkOmniPredicateExpr(v.Expr, out)- walkOmniPredicateExpr(v.Low, out)- walkOmniPredicateExpr(v.High, out)- case *ast.LikeExpr:- walkOmniPredicateExpr(v.Expr, out)- walkOmniPredicateExpr(v.Pattern, out)- walkOmniPredicateExpr(v.Escape, out)- case *ast.IsExpr:- walkOmniPredicateExpr(v.Expr, out)- case *ast.InExpr:- walkOmniPredicateExpr(v.Expr, out)- if v.List != nil {- for _, item := range v.List.Items {- if e, ok := item.(ast.ExprNode); ok {- walkOmniPredicateExpr(e, out)- }- }- }- walkOmniPredicateExpr(v.Subquery, out)- case *ast.ExistsExpr:- if sel, ok := v.Subquery.(*ast.SelectStmt); ok {- walkOmniSelectPredicates(sel, out)- }- case *ast.SubqueryExpr:- if sel, ok := v.Query.(*ast.SelectStmt); ok {- walkOmniSelectPredicates(sel, out)- }- case *ast.SubqueryComparisonExpr:- walkOmniPredicateExpr(v.Left, out)- if sel, ok := v.Subquery.(*ast.SelectStmt); ok {- walkOmniSelectPredicates(sel, out)- }- case *ast.CaseExpr:- walkOmniPredicateExpr(v.Arg, out)- if v.WhenList != nil {- for _, item := range v.WhenList.Items {- if cw, ok := item.(*ast.CaseWhen); ok {- walkOmniPredicateExpr(cw.Condition, out)- walkOmniPredicateExpr(cw.Result, out)- }- }- }- walkOmniPredicateExpr(v.ElseExpr, out)- case *ast.IifExpr:- walkOmniPredicateExpr(v.Condition, out)- walkOmniPredicateExpr(v.TrueVal, out)- walkOmniPredicateExpr(v.FalseVal, out)- case *ast.CoalesceExpr:- walkOmniArgList(v.Args, out)- case *ast.NullifExpr:- walkOmniPredicateExpr(v.Left, out)- walkOmniPredicateExpr(v.Right, out)- case *ast.FuncCallExpr:- walkOmniArgList(v.Args, out)- case *ast.MethodCallExpr:- walkOmniArgList(v.Args, out)- case *ast.CastExpr:- walkOmniPredicateExpr(v.Expr, out)- case *ast.ConvertExpr:- walkOmniPredicateExpr(v.Expr, out)- walkOmniPredicateExpr(v.Style, out)- case *ast.TryCastExpr:- walkOmniPredicateExpr(v.Expr, out)- case *ast.TryConvertExpr:- walkOmniPredicateExpr(v.Expr, out)- walkOmniPredicateExpr(v.Style, out)- case *ast.ParenExpr:- walkOmniPredicateExpr(v.Expr, out)- case *ast.CollateExpr:- walkOmniPredicateExpr(v.Expr, out)- case *ast.AtTimeZoneExpr:- walkOmniPredicateExpr(v.Expr, out)- walkOmniPredicateExpr(v.TimeZone, out)- default:- }-}--func walkOmniArgList(list *ast.List, out *[]*ast.ColumnRef) {- if list == nil {- return- }- for _, item := range list.Items {- if e, ok := item.(ast.ExprNode); ok {- walkOmniPredicateExpr(e, out)- }- }-}--func walkOmniSelectPredicates(sel *ast.SelectStmt, out *[]*ast.ColumnRef) {- if sel == nil {- return- }- if sel.Larg != nil {- walkOmniSelectPredicates(sel.Larg, out)- }- if sel.Rarg != nil {- walkOmniSelectPredicates(sel.Rarg, out)- }- if sel.WithClause != nil && sel.WithClause.CTEs != nil {- for _, item := range sel.WithClause.CTEs.Items {- if c, ok := item.(*ast.CommonTableExpr); ok {- if q, ok := c.Query.(*ast.SelectStmt); ok {- walkOmniSelectPredicates(q, out)- }- }- }- }- walkOmniPredicateExpr(sel.WhereClause, out)- walkOmniPredicateExpr(sel.HavingClause, out)- // JOIN ON conditions are intentionally NOT walked — the legacy ANTLR extractor- // doesn't treat them as predicate columns, and downstream fixtures assume- // that behavior. Re-enabling them is a separate decision.-}diff --git a/backend/plugin/parser/tsql/query_span_predicate_test.go b/backend/plugin/parser/tsql/query_span_predicate_test.goindex 0e391c17f4..f27c12fefa 100644--- a/backend/plugin/parser/tsql/query_span_predicate_test.go+++ b/backend/plugin/parser/tsql/query_span_predicate_test.go@@ -1,116 +1,101 @@package tsqlimport (+ "context""slices""testing"- "github.com/bytebase/omni/mssql/ast""github.com/stretchr/testify/require"++ "github.com/bytebase/bytebase/backend/plugin/parser/base")-func TestCollectOmniSelectPredicateColumnRefs(t *testing.T) {- type testCase struct {- name string- sql string- // want lists the expected column names (ColumnRef.Column) reachable- // from the SelectStmt's predicate contexts, order-insensitive.- want []string- }- cases := []testCase{- {"simple_eq", "SELECT * FROM t WHERE a = 1", []string{"a"}},- {"col_vs_col", "SELECT * FROM t WHERE a > b", []string{"a", "b"}},- {"and_or", "SELECT * FROM t WHERE a = 1 AND (b = 2 OR c = 3)", []string{"a", "b", "c"}},- {"not", "SELECT * FROM t WHERE NOT (a > 0)", []string{"a"}},- {"between", "SELECT * FROM t WHERE a BETWEEN b AND c", []string{"a", "b", "c"}},- {"like", "SELECT * FROM t WHERE a LIKE b", []string{"a", "b"}},- {"is_null", "SELECT * FROM t WHERE a IS NULL", []string{"a"}},- {"in_literal_list", "SELECT * FROM t WHERE a IN (1, 2, 3)", []string{"a"}},- {"in_subquery", "SELECT * FROM t WHERE a IN (SELECT c FROM t1 WHERE d = 1)", []string{"a", "d"}},- {"exists", "SELECT * FROM t WHERE EXISTS (SELECT 1 FROM t1 WHERE d = e)", []string{"d", "e"}},- {"contains_predicate", "SELECT * FROM t WHERE CONTAINS(a, 'foo')", []string{"a"}},- {"freetext_predicate", "SELECT * FROM t WHERE FREETEXT(a, 'foo')", []string{"a"}},- {"fulltext_star", "SELECT * FROM t WHERE CONTAINS(*, 'foo')", []string{}},- {"case_expr", "SELECT * FROM t WHERE CASE WHEN a = 1 THEN b ELSE c END = 1", []string{"a", "b", "c"}},- {"iif", "SELECT * FROM t WHERE IIF(a = 1, b, c) > 0", []string{"a", "b", "c"}},- {"coalesce", "SELECT * FROM t WHERE COALESCE(a, b, c) = 0", []string{"a", "b", "c"}},- {"nullif", "SELECT * FROM t WHERE NULLIF(a, b) IS NOT NULL", []string{"a", "b"}},- {"cast_expr", "SELECT * FROM t WHERE CAST(a AS INT) > 5", []string{"a"}},- {"convert_expr", "SELECT * FROM t WHERE CONVERT(INT, a) > 5", []string{"a"}},- {"try_cast_expr", "SELECT * FROM t WHERE TRY_CAST(a AS INT) > 5", []string{"a"}},- {"func_args", "SELECT * FROM t WHERE LEN(a) > LEN(b)", []string{"a", "b"}},- {"paren_expr", "SELECT * FROM t WHERE ((a + b) > (c - d))", []string{"a", "b", "c", "d"}},- {"collate_expr", "SELECT * FROM t WHERE a COLLATE Latin1_General_CS_AS = 'x'", []string{"a"}},- // Note: JOIN ON is intentionally NOT collected by this helper (parity- // with the legacy ANTLR extractor). Only WHERE/HAVING contribute.- {"join_on", "SELECT * FROM t1 JOIN t2 ON t1.a = t2.b", []string{}},- {"multi_join_on", "SELECT * FROM t1 JOIN t2 ON t1.a = t2.b JOIN t3 ON t2.c = t3.d", []string{}},- {"having", "SELECT a, SUM(b) FROM t GROUP BY a HAVING SUM(b) > 10", []string{"b"}},- {"correlated_subquery", "SELECT * FROM t1 WHERE EXISTS (SELECT 1 FROM t2 WHERE t2.a = t1.b)", []string{"a", "b"}},- {"subquery_comparison_any", "SELECT * FROM t WHERE a > ANY (SELECT b FROM t1 WHERE c = 1)", []string{"a", "c"}},- {"subquery_comparison_all", "SELECT * FROM t WHERE a <= ALL (SELECT b FROM t1 WHERE c = 1)", []string{"a", "c"}},- {"nested_subquery", "SELECT * FROM t WHERE EXISTS (SELECT 1 FROM t1 WHERE EXISTS (SELECT 1 FROM t2 WHERE x = y))", []string{"x", "y"}},- // The `c` inside MAX(c) lives in the subquery's SELECT list, not its WHERE,- // so it is intentionally excluded by this helper's contract. Subquery OUTPUT- // columns become outer predicate columns only after the extractor's- // table-source resolution.- {"scalar_subquery_in_where", "SELECT * FROM t WHERE (SELECT MAX(c) FROM t1 WHERE d = 1) > 5", []string{"d"}},- {"no_predicate", "SELECT * FROM t", []string{}},- {"set_op_union_both_have_where", "SELECT * FROM t WHERE a = 1 UNION SELECT * FROM t2 WHERE b = 2", []string{"a", "b"}},- {"cte_body_where", "WITH c AS (SELECT * FROM t WHERE a = 1) SELECT * FROM c WHERE x = 2", []string{"a", "x"}},- {"where_and_join_on", "SELECT * FROM t1 JOIN t2 ON t1.a = t2.b WHERE t1.c > 0", []string{"c"}},- {"cross_apply_condition_none", "SELECT * FROM t1 CROSS APPLY fn(t1.a) AS x", []string{}},+func predicateColumnNames(columns base.SourceColumnSet) []string {+ names := []string{}+ for column := range columns {+ names = append(names, column.Table+"."+column.Column)}- for _, tc := range cases {- t.Run(tc.name, func(t *testing.T) {- 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)- require.Truef(t, ok, "want *SelectStmt, got %T", stmts[0].AST)+ slices.Sort(names)+ return names+}- refs := collectOmniSelectPredicateColumnRefs(sel)- got := make([]string, 0, len(refs))- for _, r := range refs {- got = append(got, r.Column)- }- slices.Sort(got)- want := append([]string{}, tc.want...)- slices.Sort(want)- require.ElementsMatch(t, want, got, "sql: %s", tc.sql)+func TestOmniQuerySpanPredicateColumns(t *testing.T) {+ testCases := []struct {+ statement string+ want []string+ }{+ {"SELECT a FROM t WHERE b = 1", []string{"t.b"}},+ {"SELECT t.a FROM t JOIN t1 ON t.b = t1.b", []string{"t.b", "t1.b"}},+ {"SELECT t.a FROM t LEFT JOIN t1 ON t1.a = t.a AND t1.c = 'x'", []string{"t.a", "t1.a", "t1.c"}},+ {"SELECT t.a FROM t FULL JOIN t1 ON t1.c = 'x'", []string{"t1.c"}},+ {"SELECT t.a FROM t JOIN t1 ON t.a = t1.a JOIN t2 ON t2.b = t1.b", []string{"t.a", "t1.a", "t1.b", "t2.b"}},+ {"SELECT t.a FROM t JOIN (t1 JOIN t2 ON t1.b = t2.b) ON t.a = t1.a", []string{"t.a", "t1.a", "t1.b", "t2.b"}},+ {"SELECT t.a FROM t JOIN t1 JOIN t2 ON t1.b = t2.b ON t.a = t1.a", []string{"t.a", "t1.a", "t1.b", "t2.b"}},+ {"SELECT t.a FROM t LEFT HASH JOIN t1 ON t.c = t1.c", []string{"t.c", "t1.c"}},+ {"SELECT x.a FROM t AS x JOIN t1 AS y ON x.c = y.c", []string{"t.c", "t1.c"}},+ {"SELECT t.a FROM t JOIN t1 ON t1.a = (SELECT MAX(t2.a) FROM t2 WHERE t2.b = 1)", []string{"t1.a", "t2.a", "t2.b"}},+ {"SELECT t.a FROM t JOIN t1 ON EXISTS (SELECT 1 FROM t2 WHERE t2.b = t1.b)", []string{"t1.b", "t2.b"}},+ {"SELECT d.a FROM (SELECT t.a FROM t JOIN t1 ON t.c = t1.c) AS d", []string{"t.c", "t1.c"}},+ {"WITH c AS (SELECT t.a FROM t JOIN t1 ON t.c = t1.c) SELECT a FROM c", []string{"t.c", "t1.c"}},+ {"SELECT a FROM t WHERE EXISTS (SELECT 1 FROM t1 JOIN t2 ON t1.b = t2.b WHERE t1.a = t.a)", []string{"t.a", "t1.a", "t1.b", "t2.b"}},+ {"SELECT a FROM t WHERE EXISTS (SELECT 1 FROM t1 JOIN t2 ON t2.a = t.c)", []string{"t.c", "t2.a"}},+ {"SELECT (SELECT MAX(t1.a) FROM t1 JOIN t2 ON t1.b = t2.b) AS m FROM t", []string{"t1.b", "t2.b"}},+ {"SELECT t.a FROM t CROSS JOIN t1", []string{}},+ {"SELECT x.a FROM t CROSS APPLY (SELECT t1.a FROM t1 WHERE t1.b = t.b) AS x", []string{"t.b", "t1.b"}},+ {"SELECT s.value FROM t CROSS APPLY STRING_SPLIT(t.c, ',') AS s", []string{"t.c"}},+ {"SELECT j.[key] FROM t OUTER APPLY OPENJSON(t.c) AS j", []string{"t.c"}},+ {"SELECT value FROM STRING_SPLIT((SELECT MAX(t1.c) FROM t1), ',')", []string{"t1.c"}},+ {"SELECT TOP ((SELECT MAX(t1.a) FROM t1)) a FROM t", []string{"t1.a"}},+ {"SELECT TOP ((SELECT COUNT(*) FROM t1 WHERE t1.c = 'x')) a FROM t", []string{"t1.c"}},+ {"SELECT a FROM t ORDER BY a OFFSET (SELECT MAX(t1.a) FROM t1) ROWS FETCH NEXT (SELECT MAX(t1.b) FROM t1) ROWS ONLY", []string{"t1.a", "t1.b"}},+ {"SELECT a FROM t UNION SELECT a FROM t1 ORDER BY a OFFSET (SELECT MAX(t2.a) FROM t2) ROWS", []string{"t2.a"}},+ {"SELECT a FROM t ORDER BY CASE WHEN EXISTS (SELECT 1 FROM t1 WHERE t1.c = 'x') THEN 0 ELSE 1 END", []string{"t1.c"}},+ {"SELECT a FROM t INTERSECT SELECT a FROM t1", []string{"t.a", "t1.a"}},+ {"SELECT a FROM t EXCEPT SELECT b FROM t1", []string{"t.a", "t1.b"}},+ {"SELECT d.a FROM (SELECT a FROM t INTERSECT SELECT a FROM t1) AS d", []string{"t.a", "t1.a"}},+ {"WITH c AS (SELECT a FROM t EXCEPT SELECT b FROM t1) SELECT a FROM c", []string{"t.a", "t1.b"}},+ {"SELECT a FROM t UNION SELECT a FROM t1", []string{}},+ {"SELECT a FROM t UNION ALL SELECT a FROM t1", []string{}},+ {"SELECT a FROM t ORDER BY b", []string{}},+ {"SELECT a AS x FROM t ORDER BY x", []string{}},+ {"SELECT b, COUNT(*) AS n FROM t GROUP BY b", []string{}},+ }+ for _, tc := range testCases {+ t.Run(tc.statement, func(t *testing.T) {+ q := newOmniTestExtractor(t, "db")+ span, err := q.getOmniQuerySpan(context.Background(), tc.statement)+ require.NoError(t, err)+ require.Nil(t, span.NotFoundError)+ require.Equal(t, tc.want, predicateColumnNames(span.PredicateColumns))})}}-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 := ParseTSQL(sql)+func TestOmniQuerySpanJoinConditionKeepsLineage(t *testing.T) {+ q := newOmniTestExtractor(t, "db")+ span, err := q.getOmniQuerySpan(context.Background(), "SELECT t.a, t1.b FROM t JOIN t1 ON t.c = t1.c")require.NoError(t, err)- sel, ok := stmts[0].AST.(*ast.SelectStmt)- require.True(t, ok)- refs := collectOmniSelectPredicateColumnRefs(sel)- require.Len(t, refs, 1)- r := refs[0]- require.Equal(t, "db1", r.Database)- require.Equal(t, "dbo", r.Schema)- require.Equal(t, "t", r.Table)- require.Equal(t, "a", r.Column)+ require.Len(t, span.Results, 2)+ require.Equal(t, []string{"t.a"}, predicateColumnNames(span.Results[0].SourceColumns))+ require.Equal(t, []string{"t1.b"}, predicateColumnNames(span.Results[1].SourceColumns))}-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 := ParseTSQL(sql)- require.NoError(t, err)- sel, ok := stmts[0].AST.(*ast.SelectStmt)- require.True(t, ok)-- refs := collectOmniPredicateColumnRefs(sel.WhereClause)- got := make([]string, 0, len(refs))- for _, r := range refs {- got = append(got, r.Column)+func TestOmniQuerySpanRefusesUnsupportedTableSources(t *testing.T) {+ for _, statement := range []string{+ "SELECT * FROM t JOIN db2.dbo.t2 AS u ON t.a = u.x PIVOT (MAX(y) FOR b IN ([1])) AS p",+ "SELECT j.v FROM t CROSS APPLY OPENJSON(t.c) WITH (v NVARCHAR(100) '$.v') AS j",+ } {+ t.Run(statement, func(t *testing.T) {+ q := newOmniTestExtractor(t, "db")+ _, err := q.getOmniQuerySpan(context.Background(), statement)+ require.Error(t, err)+ })}- slices.Sort(got)- require.ElementsMatch(t, []string{"a", "b", "c"}, got)+}++func TestOmniQuerySpanJoinConditionNotFoundPropagates(t *testing.T) {+ q := newOmniTestExtractor(t, "db")+ span, err := q.getOmniQuerySpan(context.Background(), "SELECT t.a FROM t JOIN t1 ON t1.a IN (SELECT x FROM no_such_table)")+ require.NoError(t, err)+ require.NotNil(t, span.NotFoundError)}diff --git a/backend/plugin/parser/tsql/test-data/query-span/join.yaml b/backend/plugin/parser/tsql/test-data/query-span/join.yamlindex a236409161..f4358528d2 100644--- a/backend/plugin/parser/tsql/test-data/query-span/join.yaml+++ b/backend/plugin/parser/tsql/test-data/query-span/join.yaml@@ -1,5 +1,5 @@- description: Join Alias and Asterisk- statement: SELECT t.* FROM MyTable1 t JOIN MyTable2 u ON t.a = u.id;+ statement: SELECT t.* FROM MyTable1 t JOIN MyTable2 u ON t.a = u.c;defaultDatabase: dbignoreCaseSensitive: truemetadata:@@ -70,9 +70,19 @@schema: dbotable: MyTable2column: ""- predicatecolumns: []+ predicatecolumns:+ - server: ""+ database: db+ schema: dbo+ table: MyTable1+ column: a+ - server: ""+ database: db+ schema: dbo+ table: MyTable2+ column: c- description: Join Alias- statement: SELECT t.a, t.b FROM MyTable1 t JOIN MyTable2 u ON t.a = u.id;+ statement: SELECT t.a, t.b FROM MyTable1 t JOIN MyTable2 u ON t.a = u.c;defaultDatabase: dbignoreCaseSensitive: truemetadata:@@ -143,4 +153,14 @@schema: dbotable: MyTable2column: ""- predicatecolumns: []+ predicatecolumns:+ - server: ""+ database: db+ schema: dbo+ table: MyTable1+ column: a+ - server: ""+ database: db+ schema: dbo+ table: MyTable2+ column: cdiff --git a/backend/plugin/parser/tsql/test-data/query-span/standard.yaml b/backend/plugin/parser/tsql/test-data/query-span/standard.yamlindex 81cde54f61..87b4c7c2a1 100644--- a/backend/plugin/parser/tsql/test-data/query-span/standard.yaml+++ b/backend/plugin/parser/tsql/test-data/query-span/standard.yaml@@ -441,7 +441,17 @@schema: dbotable: MyTable2column: ""- predicatecolumns: []+ predicatecolumns:+ - server: ""+ database: db+ schema: dbo+ table: MyTable1+ column: a+ - server: ""+ database: db+ schema: dbo+ table: MyTable2+ column: d- description: Table Source Liststatement: SELECT a, b, c, d FROM MyTable1, MyTable2;defaultDatabase: db@@ -775,7 +785,17 @@schema: dbotable: tt2column: ""- predicatecolumns: []+ predicatecolumns:+ - server: ""+ database: db+ schema: dbo+ table: MyTable1+ column: a+ - server: ""+ database: db+ schema: dbo+ table: MyTable2+ column: c- description: Test for recursive CTEstatement: |-WITH cte_01 AS (diff --git a/go.mod b/go.modindex 2c7f52aaa3..f60dc23188 100644--- a/go.mod+++ b/go.mod@@ -36,7 +36,7 @@ require (github.com/bmatcuk/doublestar/v4 v4.10.0github.com/bytebase/gomongo v0.0.0-20260730033313-67ba6e249735github.com/bytebase/lsp-protocol v0.0.0-20250324071136-1586d0c10ff0- github.com/bytebase/omni v0.0.0-20261023061317-0234ea55a861+ github.com/bytebase/omni v0.0.0-20261026083107-25cc3c3b45bdgithub.com/caarlos0/env/v11 v11.4.1github.com/cenkalti/backoff/v7 v7.0.0github.com/cockroachdb/cockroach-go/v2 v2.4.3diff --git a/go.sum b/go.sumindex 01e9438af9..063df968f8 100644--- a/go.sum+++ b/go.sum@@ -252,8 +252,8 @@ github.com/bytebase/gomongo v0.0.0-20260730033313-67ba6e249735 h1:v8y6mXeHmYVsdMgithub.com/bytebase/gomongo v0.0.0-20260730033313-67ba6e249735/go.mod h1:vTHjcvfn8Pmf65WjnV1ytTCYyC7xNhFjrniv4YWvtA8=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-20261023061317-0234ea55a861 h1:IV5+STWCkVNLz6E82uqSeFIZg56uUiVaGpg4ET2kYLk=-github.com/bytebase/omni v0.0.0-20261023061317-0234ea55a861/go.mod h1:9XZE1hqtvr09Oc+DdLu1/yCb8MDcoy/EPdA4AONDHlE=+github.com/bytebase/omni v0.0.0-20261026083107-25cc3c3b45bd h1:Mp5RLIccvrgW/jkK2MgYx3+Kh+wr/03yYFntb/F3Um0=+github.com/bytebase/omni v0.0.0-20261026083107-25cc3c3b45bd/go.mod h1:9XZE1hqtvr09Oc+DdLu1/yCb8MDcoy/EPdA4AONDHlE=github.com/bytebase/pgx/v5 v5.0.0-20250212161523-96ff8aed8767 h1:YuR5G3LcxpO5ScSTA+Kdirxg9RW4TRc/v1t7N2Hfmbw=github.com/bytebase/pgx/v5 v5.0.0-20250212161523-96ff8aed8767/go.mod h1:ncY89UGWxg82EykZUwSpUKEfccBGGYq1xjrOpsbsfGQ=github.com/bytebase/pkcs8 v0.0.0-20240612095628-fcd0a7484c94 h1:6PNsuNmSqCuR8Z616uQLzDIvujWCFsKzeVc3ECmVubk=