Skip to content

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

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.go
index 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) (*ba
if 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.Ps
if 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.FuncCallExpr
if 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.go
index 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.go
deleted file mode 100644
index 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.go
index 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 tsql
import (
+ "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.yaml
index 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: db
ignoreCaseSensitive: true
metadata:
@@ -70,9 +70,19 @@
schema: dbo
table: MyTable2
column: ""
- 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: db
ignoreCaseSensitive: true
metadata:
@@ -143,4 +153,14 @@
schema: dbo
table: MyTable2
column: ""
- predicatecolumns: []
+ predicatecolumns:
+ - server: ""
+ database: db
+ schema: dbo
+ table: MyTable1
+ column: a
+ - server: ""
+ database: db
+ schema: dbo
+ table: MyTable2
+ column: c
diff --git a/backend/plugin/parser/tsql/test-data/query-span/standard.yaml b/backend/plugin/parser/tsql/test-data/query-span/standard.yaml
index 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: dbo
table: MyTable2
column: ""
- predicatecolumns: []
+ predicatecolumns:
+ - server: ""
+ database: db
+ schema: dbo
+ table: MyTable1
+ column: a
+ - server: ""
+ database: db
+ schema: dbo
+ table: MyTable2
+ column: d
- description: Table Source List
statement: SELECT a, b, c, d FROM MyTable1, MyTable2;
defaultDatabase: db
@@ -775,7 +785,17 @@
schema: dbo
table: tt2
column: ""
- predicatecolumns: []
+ predicatecolumns:
+ - server: ""
+ database: db
+ schema: dbo
+ table: MyTable1
+ column: a
+ - server: ""
+ database: db
+ schema: dbo
+ table: MyTable2
+ column: c
- description: Test for recursive CTE
statement: |-
WITH cte_01 AS (
diff --git a/go.mod b/go.mod
index 2c7f52aaa3..f60dc23188 100644
--- a/go.mod
+++ b/go.mod
@@ -36,7 +36,7 @@ require (
github.com/bmatcuk/doublestar/v4 v4.10.0
github.com/bytebase/gomongo v0.0.0-20260730033313-67ba6e249735
github.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-25cc3c3b45bd
github.com/caarlos0/env/v11 v11.4.1
github.com/cenkalti/backoff/v7 v7.0.0
github.com/cockroachdb/cockroach-go/v2 v2.4.3
diff --git a/go.sum b/go.sum
index 01e9438af9..063df968f8 100644
--- a/go.sum
+++ b/go.sum
@@ -252,8 +252,8 @@ github.com/bytebase/gomongo v0.0.0-20260730033313-67ba6e249735 h1:v8y6mXeHmYVsdM
github.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=