Skip to content

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

fix(tsql)!: resolve UPDATE/DELETE targets through the FROM clause (#21653)

Vincent Huangfec9a2a82043
diff --git a/backend/api/v1/sql_service.go b/backend/api/v1/sql_service.go
index dd78e642a4..ff72907b8b 100644
--- a/backend/api/v1/sql_service.go
+++ b/backend/api/v1/sql_service.go
@@ -2001,17 +2001,7 @@ func (s *SQLService) authorizeWriteTargets(
envByDatabase[t.database] = env
}
- attributes := map[string]any{
- common.CELAttributeRequestTime: requestTime,
- common.CELAttributeResourceDatabase: databaseFullName,
- common.CELAttributeResourceEnvironmentID: env,
- }
- if !useDatabaseLevel {
- attributes[common.CELAttributeResourceTableName] = t.table
- if t.schema != "" {
- attributes[common.CELAttributeResourceSchemaName] = t.schema
- }
- }
+ attributes := writeTargetAttributes(requestTime, databaseFullName, env, t, useDatabaseLevel)
allowed, err := s.hasDatabaseAccessRights(ctx, user, perm, attributes, iamPolicies...)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to check access control for target %q: %v", deniedResource, err))
@@ -2023,6 +2013,23 @@ func (s *SQLService) authorizeWriteTargets(
return deniedResources, nil
}
+// writeTargetAttributes returns the attributes a grant condition is evaluated against
+// for write target t; a database-level check carries no table or schema.
+func writeTargetAttributes(requestTime time.Time, databaseFullName, env string, t writeTargetResource, databaseLevel bool) map[string]any {
+ attributes := map[string]any{
+ common.CELAttributeRequestTime: requestTime,
+ common.CELAttributeResourceDatabase: databaseFullName,
+ common.CELAttributeResourceEnvironmentID: env,
+ }
+ if !databaseLevel {
+ attributes[common.CELAttributeResourceTableName] = t.table
+ if t.schema != "" {
+ attributes[common.CELAttributeResourceSchemaName] = t.schema
+ }
+ }
+ return attributes
+}
+
// formatWriteTargetResource renders a denied write target as
// instances/i/databases/d[/schemas/s]/tables/t; the schema segment is omitted when unknown.
func formatWriteTargetResource(databaseFullName, schema, table string) string {
@@ -2048,7 +2055,9 @@ type writeTargetResource struct {
// Some engines' extractors report auxiliary tables referenced by the change (e.g.
// the joined/using tables of an UPDATE … JOIN … / DELETE … USING …) alongside the
// mutated table, others only the primary target; either way this can only ever
-// over-restrict (fail-closed), never under-restrict.
+// over-restrict (fail-closed), never under-restrict. The exception is a SQL Server target
+// left as written (BOT-158, BOT-160): it is checked as a table of that name in the request
+// database.
//
// DDL on a non-table object (view/procedure/function/trigger/…) has no table to scope. When
// such DDL names an EXPLICIT target database (e.g. CREATE VIEW other_db.v), the extractor
diff --git a/backend/api/v1/sql_service_schema_resolution_test.go b/backend/api/v1/sql_service_schema_resolution_test.go
index 6dc0e877d7..9b0173c645 100644
--- a/backend/api/v1/sql_service_schema_resolution_test.go
+++ b/backend/api/v1/sql_service_schema_resolution_test.go
@@ -2,12 +2,14 @@ package v1
import (
"testing"
+ "time"
metadatapb "github.com/bytebase/omni/metadata"
"github.com/stretchr/testify/require"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
parserbase "github.com/bytebase/bytebase/backend/plugin/parser/base"
+ "github.com/bytebase/bytebase/backend/store"
"github.com/bytebase/bytebase/backend/store/model"
)
@@ -94,3 +96,71 @@ func TestWriteTargetsFromChangeSummaryRefusesSkippedStatements(t *testing.T) {
)
require.Nil(t, writeTargetsFromChangeSummary(extract("CREATE OR REPLACE TABLE other_db.t (a INT);")))
}
+
+func TestMSSQLDMLWriteTargetGrantConditions(t *testing.T) {
+ t.Parallel()
+ dbMeta := model.NewDatabaseMetadata(&metadatapb.DatabaseSchemaMetadata{
+ Name: "db",
+ Schemas: []*metadatapb.SchemaMetadata{{
+ Name: "dbo",
+ Tables: []*metadatapb.TableMetadata{{Name: "Orders"}, {Name: "Customers"}},
+ }},
+ }, nil, nil, storepb.Engine_MSSQL, false /* isObjectCaseSensitive, as store.IsObjectCaseSensitive reports SQL Server */)
+ instance := &store.InstanceMessage{ResourceID: "i"}
+
+ targets := func(statement string) []writeTargetResource {
+ stmts, err := parserbase.ParseStatements(storepb.Engine_MSSQL, statement)
+ require.NoError(t, err, statement)
+ changeSummary, err := parserbase.ExtractChangedResources(storepb.Engine_MSSQL, "db",
+ schemaForWriteTargetResolution(storepb.Engine_MSSQL, "db", ""), dbMeta, parserbase.ExtractASTs(stmts), statement)
+ require.NoError(t, err, statement)
+ return writeTargetsFromChangeSummary(changeSummary)
+ }
+ authorized := func(grant string, target writeTargetResource) bool {
+ databaseFullName := formatDatabaseResourceName(instance, &store.DatabaseMessage{InstanceID: "i", DatabaseName: target.database})
+ ok, err := evaluateQueryExportPolicyCondition(grant, writeTargetAttributes(time.Now(), databaseFullName, "prod", target, false))
+ return err == nil && ok
+ }
+ const (
+ ordersGrant = `resource.database == "instances/i/databases/db" && resource.table_name in ["Orders"]`
+ uiOrdersGrant = `resource.database == "instances/i/databases/db" && resource.schema_name == "dbo" && resource.table_name in ["Orders"]`
+ aliasGrant = `resource.database == "instances/i/databases/db" && resource.table_name in ["o"]`
+ customersGrant = `resource.database == "instances/i/databases/db" && resource.table_name in ["Customers"]`
+ )
+
+ aliased := targets(`UPDATE o SET o.status = 'x' FROM dbo.Orders AS o WHERE o.id = 1;`)
+ require.Equal(t, []writeTargetResource{{database: "db", schema: "dbo", table: "Orders"}}, aliased)
+ require.True(t, authorized(ordersGrant, aliased[0]))
+ require.True(t, authorized(uiOrdersGrant, aliased[0]), "the aliased table's schema is known, so a schema-scoped grant matches")
+ require.False(t, authorized(aliasGrant, aliased[0]))
+ require.False(t, authorized(customersGrant, aliased[0]))
+
+ require.Equal(t, []writeTargetResource{{database: "db", table: "Orders"}},
+ targets(`DELETE o FROM Orders AS o WHERE o.id = 1;`))
+
+ // The alias shadows the real table of the same name, so the write goes to Orders.
+ shadowing := targets(`UPDATE Customers SET status = 'x' FROM dbo.Orders AS Customers WHERE Customers.id = 1;`)
+ require.Equal(t, []writeTargetResource{{database: "db", schema: "dbo", table: "Orders"}}, shadowing)
+ require.False(t, authorized(customersGrant, shadowing[0]))
+
+ // A FROM table in another database, aliased or not, is gated by that database, not the request one.
+ crossDatabase := targets(`UPDATE o SET o.status = 'x' FROM otherdb.dbo.Orders AS o WHERE o.id = 1;`)
+ require.Equal(t, []writeTargetResource{{database: "otherdb", schema: "dbo", table: "Orders"}}, crossDatabase)
+ require.False(t, authorized(ordersGrant, crossDatabase[0]))
+ unaliasedCrossDatabase := targets(`UPDATE Orders SET status = 'x' FROM otherdb.dbo.Orders WHERE Orders.id = 1;`)
+ require.Equal(t, []writeTargetResource{{database: "otherdb", schema: "dbo", table: "Orders"}}, unaliasedCrossDatabase)
+ require.False(t, authorized(ordersGrant, unaliasedCrossDatabase[0]))
+
+ otherSchema := targets(`UPDATE Orders SET status = 'x' FROM sales.Orders WHERE Orders.id = 1;`)
+ require.Equal(t, []writeTargetResource{{database: "db", schema: "sales", table: "Orders"}}, otherSchema)
+ require.False(t, authorized(uiOrdersGrant, otherSchema[0]))
+
+ qualified := targets(`UPDATE dbo.Orders SET status = 'x' FROM dbo.Orders AS o JOIN dbo.Customers AS Orders ON Orders.id = o.id WHERE o.id = 1;`)
+ require.Equal(t, []writeTargetResource{{database: "db", schema: "dbo", table: "Orders"}}, qualified)
+ require.False(t, authorized(customersGrant, qualified[0]))
+
+ // Exact match: a case-insensitive database writes Orders here (BOT-158); a case-sensitive one writes table O.
+ caseVariant := targets(`UPDATE O SET status = 'x' FROM dbo.Orders AS o WHERE o.id = 1;`)
+ require.Equal(t, []writeTargetResource{{database: "db", table: "O"}}, caseVariant)
+ require.False(t, authorized(ordersGrant, caseVariant[0]))
+}
diff --git a/backend/component/review/evaluator.go b/backend/component/review/evaluator.go
index 5f92a0e3e1..7d1d0fc43c 100644
--- a/backend/component/review/evaluator.go
+++ b/backend/component/review/evaluator.go
@@ -763,18 +763,7 @@ func buildCELVariablesForDatabaseChange(ctx context.Context, stores *store.Store
}
report := result.GetSqlSummaryReport()
-
- // Calculate table rows from changed resources
- var tableRows int64
- var tableNames []string
- for _, db := range report.GetChangedResources().GetDatabases() {
- for _, sc := range db.GetSchemas() {
- for _, tb := range sc.GetTables() {
- tableRows += tb.GetTableRows()
- tableNames = append(tableNames, tb.Name)
- }
- }
- }
+ tableNames, tableRows := changedTables(report)
celVars[common.CELAttributeStatementAffectedRows] = report.AffectedRows
celVars[common.CELAttributeStatementTableRows] = tableRows
@@ -1180,6 +1169,22 @@ func statementTypesFromParser(engine storepb.Engine, statement string) []storepb
return statementTypes
}
+// changedTables returns the names of the tables a summary report changes and their
+// total row count.
+func changedTables(report *storepb.PlanCheckRunResult_Result_SqlSummaryReport) ([]string, int64) {
+ var names []string
+ var rows int64
+ for _, db := range report.GetChangedResources().GetDatabases() {
+ for _, sc := range db.GetSchemas() {
+ for _, tb := range sc.GetTables() {
+ rows += tb.GetTableRows()
+ names = append(names, tb.Name)
+ }
+ }
+ }
+ return names, rows
+}
+
// expandCELVars creates CEL variable maps for each combination of statement types and table names.
func expandCELVars(base map[string]any, statementTypes []storepb.StatementType, tableNames []string) []map[string]any {
if len(statementTypes) == 0 {
diff --git a/backend/component/review/evaluator_test.go b/backend/component/review/evaluator_test.go
index edde5f1d84..7cff25c9ef 100644
--- a/backend/component/review/evaluator_test.go
+++ b/backend/component/review/evaluator_test.go
@@ -1157,3 +1157,56 @@ func TestApprovalRuleMatchesOceanBaseSummaryReport(t *testing.T) {
})
}
}
+
+func TestApprovalRuleMatchesMSSQLAliasTarget(t *testing.T) {
+ strict := &storepb.WorkspaceApprovalSetting_Rule{
+ Source: storepb.WorkspaceApprovalSetting_Rule_CHANGE_DATABASE,
+ Condition: &expr.Expr{Expression: `statement.sql_type == "UPDATE" && resource.table_name.matches("(?i)^(orders)$")`},
+ Template: &storepb.ApprovalTemplate{Title: "Trigger tables"},
+ }
+ general := &storepb.WorkspaceApprovalSetting_Rule{
+ Source: storepb.WorkspaceApprovalSetting_Rule_CHANGE_DATABASE,
+ Condition: &expr.Expr{Expression: "true"},
+ Template: &storepb.ApprovalTemplate{Title: "General"},
+ }
+ tests := []struct {
+ name string
+ statement string
+ wantTitle string
+ }{
+ {"aliased UPDATE of a listed table", `UPDATE o SET o.status = 'x' FROM dbo.Orders AS o WHERE o.id = 1;`, "Trigger tables"},
+ {"alias named like a listed table writes another table", `UPDATE Orders SET name = 'x' FROM dbo.Customers AS Orders WHERE Orders.id = 1;`, "General"},
+ {"UPDATE of an unlisted table", `UPDATE dbo.Customers SET name = 'x' WHERE id = 1;`, "General"},
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ a := require.New(t)
+ stmts, err := parserbase.ParseStatements(storepb.Engine_MSSQL, tt.statement)
+ a.NoError(err)
+ asts := parserbase.ExtractASTs(stmts)
+ statementTypes, err := plancheck.SummaryStatementTypes(storepb.Engine_MSSQL, asts)
+ a.NoError(err)
+ changeSummary, err := parserbase.ExtractChangedResources(storepb.Engine_MSSQL, "db", "dbo", nil, asts, tt.statement)
+ a.NoError(err)
+
+ report := &storepb.PlanCheckRunResult_Result_SqlSummaryReport{
+ StatementTypes: statementTypes,
+ ChangedResources: changeSummary.ChangedResources.Build(),
+ }
+ tableNames, _ := changedTables(report)
+ celVars := expandCELVars(map[string]any{
+ common.CELAttributeResourceEnvironmentID: "prod",
+ common.CELAttributeResourceProjectID: "project",
+ common.CELAttributeResourceDBEngine: storepb.Engine_MSSQL.String(),
+ common.CELAttributeStatementText: tt.statement,
+ }, report.StatementTypes, tableNames)
+
+ template, err := getApprovalTemplate(&storepb.WorkspaceApprovalSetting{
+ Rules: []*storepb.WorkspaceApprovalSetting_Rule{strict, general},
+ }, storepb.WorkspaceApprovalSetting_Rule_CHANGE_DATABASE, celVars)
+ a.NoError(err)
+ a.NotNil(template)
+ a.Equal(tt.wantTitle, template.Title)
+ })
+ }
+}
diff --git a/backend/plugin/parser/tsql/resource_change.go b/backend/plugin/parser/tsql/resource_change.go
index b39ed043f0..c874801f39 100644
--- a/backend/plugin/parser/tsql/resource_change.go
+++ b/backend/plugin/parser/tsql/resource_change.go
@@ -123,13 +123,13 @@ func extractChangedResources(currentDatabase string, currentSchema string, dbMet
case *ast.UpdateStmt:
if ref, ok := n.Relation.(*ast.TableRef); ok {
- addTable(ref, false)
+ addTable(resolveDMLWriteTarget(ref, n.FromClause, n.WithClause), false)
}
addDML(omniAST.Text)
case *ast.DeleteStmt:
if ref, ok := n.Relation.(*ast.TableRef); ok {
- addTable(ref, false)
+ addTable(resolveDMLWriteTarget(ref, n.FromClause, n.WithClause), false)
}
addDML(omniAST.Text)
@@ -179,6 +179,54 @@ func extractChangedResources(currentDatabase string, currentSchema string, dbMet
}, nil
}
+// resolveDMLWriteTarget returns the table an UPDATE/DELETE target writes. SQL Server binds an
+// unqualified target to the FROM table with that exposed name: its alias, or its own name when
+// it has none. A qualified target names its own table, even when a FROM entry is aliased to its
+// bare name. Synced metadata reports every SQL Server database as case-insensitive, even under a
+// case-sensitive collation, so a target binds only when both collations agree: the FROM match is
+// exact and the CTE check folds case. Other targets stay as written, such as a differently cased
+// name (BOT-158) and a CTE or derived-table target (BOT-160).
+func resolveDMLWriteTarget(target *ast.TableRef, fromClause *ast.List, withClause *ast.WithClause) *ast.TableRef {
+ if target.Server != "" || target.Database != "" || target.Schema != "" || fromClause == nil {
+ return target
+ }
+ source := tableByExposedName(fromClause, target.Object)
+ if source == nil || isCTETarget(source, withClause, false /* caseSensitive */) {
+ return target
+ }
+ return source
+}
+
+func tableByExposedName(node ast.Node, name string) *ast.TableRef {
+ switch n := node.(type) {
+ case *ast.List:
+ for _, item := range n.Items {
+ if ref := tableByExposedName(item, name); ref != nil {
+ return ref
+ }
+ }
+ case *ast.TableRef:
+ if n.Alias == name || (n.Alias == "" && n.Object == name) {
+ return n
+ }
+ case *ast.AliasedTableRef:
+ // omni wraps an unaliased table that has TABLESAMPLE in an AliasedTableRef.
+ if n.Alias == "" {
+ return tableByExposedName(n.Table, name)
+ }
+ if ref, ok := n.Table.(*ast.TableRef); ok && n.Alias == name {
+ return ref
+ }
+ case *ast.JoinClause:
+ if ref := tableByExposedName(n.Left, name); ref != nil {
+ return ref
+ }
+ return tableByExposedName(n.Right, name)
+ default:
+ }
+ return nil
+}
+
func omniTableRefTriple(ref *ast.TableRef, defaultDatabase, defaultSchema string) (string, string, string) {
if ref == nil {
return defaultDatabase, defaultSchema, ""
diff --git a/backend/plugin/parser/tsql/resource_change_test.go b/backend/plugin/parser/tsql/resource_change_test.go
index 502c78bba8..ecc427e174 100644
--- a/backend/plugin/parser/tsql/resource_change_test.go
+++ b/backend/plugin/parser/tsql/resource_change_test.go
@@ -10,6 +10,60 @@ import (
"github.com/bytebase/bytebase/backend/store/model"
)
+// extractMSSQL returns the built projection: what approval and write authorization read,
+// without the embedded metadata pointer.
+func extractMSSQL(t *testing.T, statement string) *storepb.ChangedResources {
+ t.Helper()
+ stmts, err := base.ParseStatements(storepb.Engine_MSSQL, statement)
+ require.NoError(t, err, statement)
+ got, err := extractChangedResources("DB", "dbo", nil /* dbMetadata */, base.ExtractASTs(stmts), statement)
+ require.NoError(t, err, statement)
+ return got.ChangedResources.Build()
+}
+
+func TestExtractChangedResources_DMLWriteTarget(t *testing.T) {
+ tests := []struct {
+ name string
+ statement string
+ database string
+ schema string
+ table string
+ }{
+ {"alias", `UPDATE o SET o.status = 'x' FROM dbo.Orders AS o WHERE o.id = 1;`, "DB", "dbo", "Orders"},
+ {"alias without AS", `UPDATE o SET status = 'x' FROM dbo.Orders o WHERE o.id = 1;`, "DB", "dbo", "Orders"},
+ {"alias in DELETE", `DELETE o FROM dbo.Orders AS o WHERE o.id = 1;`, "DB", "dbo", "Orders"},
+ {"alias on the right of a JOIN", `UPDATE o SET o.status = 'x' FROM dbo.Customers AS c JOIN dbo.Orders AS o ON o.id = c.id WHERE c.id = 1;`, "DB", "dbo", "Orders"},
+ {"alias beside an APPLY", `UPDATE o SET o.status = 'x' FROM dbo.Orders AS o CROSS APPLY (SELECT TOP 1 c.id FROM dbo.Customers AS c WHERE c.id = o.id) AS a WHERE o.id = 1;`, "DB", "dbo", "Orders"},
+ {"alias shadows a table of its name", `UPDATE Customers SET status = 'x' FROM dbo.Orders AS Customers WHERE Customers.id = 1;`, "DB", "dbo", "Orders"},
+ {"alias of a table in another database", `UPDATE o SET o.status = 'x' FROM otherdb.dbo.Orders AS o WHERE o.id = 1;`, "otherdb", "dbo", "Orders"},
+ {"unaliased table in another database", `UPDATE Orders SET status = 'x' FROM otherdb.dbo.Orders WHERE Orders.id = 1;`, "otherdb", "dbo", "Orders"},
+ {"unaliased table in another schema", `UPDATE Orders SET status = 'x' FROM sales.Orders WHERE Orders.id = 1;`, "DB", "sales", "Orders"},
+ {"unaliased table in DELETE FROM", `DELETE FROM Orders FROM otherdb.dbo.Orders WHERE Orders.id = 1;`, "otherdb", "dbo", "Orders"},
+ {"unaliased join operand", `UPDATE Orders SET status = 'x' FROM dbo.Customers AS c LEFT JOIN otherdb.dbo.Orders ON c.id = Orders.id WHERE c.id = 1;`, "otherdb", "dbo", "Orders"},
+ {"unaliased sampled table", `UPDATE Orders SET status = 'x' FROM otherdb.dbo.Orders TABLESAMPLE (100 PERCENT) WHERE Orders.id = 1;`, "otherdb", "dbo", "Orders"},
+ {"aliased table hides its own name", `UPDATE Orders SET status = 'x' FROM otherdb.dbo.Orders AS x WHERE x.id = 1;`, "DB", "dbo", "Orders"},
+ {"qualified target ignores an alias of its bare name", `UPDATE dbo.Orders SET status = 'x' FROM dbo.Orders AS o JOIN dbo.Customers AS Orders ON Orders.id = o.id WHERE o.id = 1;`, "DB", "dbo", "Orders"},
+ {"qualified DELETE target ignores an alias of its bare name", `DELETE dbo.Orders FROM dbo.Orders AS o JOIN dbo.Customers AS Orders ON Orders.id = o.id WHERE o.id = 1;`, "DB", "dbo", "Orders"},
+ {"qualified target in another database ignores an alias of its bare name", `UPDATE otherdb.dbo.Orders SET status = 'x' FROM otherdb.dbo.Orders AS o JOIN dbo.Customers AS Orders ON Orders.id = o.id WHERE o.id = 1;`, "otherdb", "dbo", "Orders"},
+ // The server part is dropped, as for any linked-server name (BYT-10235).
+ {"server-qualified target ignores an alias of its bare name", `UPDATE srv...Orders SET status = 'x' FROM srv...Orders AS t JOIN dbo.Customers AS Orders ON Orders.id = t.id WHERE t.id = 1;`, "DB", "dbo", "Orders"},
+ // A case-insensitive database binds the next two to the FROM table (BOT-158); a
+ // case-sensitive one does not.
+ {"differently cased alias stays as written", `UPDATE O SET status = 'x' FROM dbo.Orders AS o WHERE o.id = 1;`, "DB", "dbo", "O"},
+ {"differently cased table name stays as written", `UPDATE ORDERS SET status = 'x' FROM otherdb.dbo.Orders WHERE Orders.id = 1;`, "DB", "dbo", "ORDERS"},
+ {"alias of a CTE stays as written", `WITH c AS (SELECT id, status FROM dbo.Orders) UPDATE x SET status = 'v' FROM c AS x WHERE x.id = 1;`, "DB", "dbo", "x"},
+ {"alias of a differently cased CTE name stays as written", `WITH c AS (SELECT id, status FROM dbo.Orders) UPDATE x SET status = 'v' FROM C AS x WHERE x.id = 1;`, "DB", "dbo", "x"},
+ {"alias of a derived table stays as written", `UPDATE d SET status = 'x' FROM (SELECT * FROM dbo.Orders) AS d WHERE d.id = 1;`, "DB", "dbo", "d"},
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ want := model.NewChangedResources(nil)
+ want.AddTable(tt.database, tt.schema, &storepb.ChangedResourceTable{Name: tt.table}, false)
+ require.Equal(t, want.Build(), extractMSSQL(t, tt.statement))
+ })
+ }
+}
+
func TestExtractChangedResources(t *testing.T) {
statement := `CREATE TABLE t1 (c1 INT);
DROP TABLE t1;