Skip to content

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

feat(mssql): sync the default schema and synonyms, and pass the default schema to review (#21718)

rebeliced9e998f216bd
diff --git a/backend/plugin/db/mssql/sync.go b/backend/plugin/db/mssql/sync.go
index 6eed03e54b..4f03280547 100644
--- a/backend/plugin/db/mssql/sync.go
+++ b/backend/plugin/db/mssql/sync.go
@@ -96,6 +96,16 @@ func (d *Driver) SyncDBSchema(ctx context.Context) (*metadatapb.DatabaseSchemaMe
if err != nil {
return nil, errors.Wrapf(err, "failed to get triggers from database %q", d.databaseName)
}
+ synonymMap, err := getSynonyms(txn)
+ if err != nil {
+ return nil, errors.Wrapf(err, "failed to get synonyms from database %q", d.databaseName)
+ }
+ // Changes run as the user that syncs, so this is where their unqualified
+ // names land.
+ var defaultSchema string
+ if err := txn.QueryRow("SELECT SCHEMA_NAME()").Scan(&defaultSchema); err != nil {
+ return nil, errors.Wrapf(err, "failed to get the default schema of database %q", d.databaseName)
+ }
for schemaName, tables := range tableMap {
for i := range tables {
table := tables[i]
@@ -118,7 +128,8 @@ func (d *Driver) SyncDBSchema(ctx context.Context) (*metadatapb.DatabaseSchemaMe
}
databaseMetadata := &metadatapb.DatabaseSchemaMetadata{
- Name: d.databaseName,
+ Name: d.databaseName,
+ DefaultSchema: defaultSchema,
}
for _, schemaName := range schemaNames {
databaseMetadata.Schemas = append(databaseMetadata.Schemas, &metadatapb.SchemaMetadata{
@@ -128,11 +139,52 @@ func (d *Driver) SyncDBSchema(ctx context.Context) (*metadatapb.DatabaseSchemaMe
Sequences: sequenceMap[schemaName],
Functions: functionMap[schemaName],
Procedures: procedureMap[schemaName],
+ Synonyms: synonymMap[schemaName],
})
}
return databaseMetadata, nil
}
+// getSynonyms gets the synonyms of a database by schema, with the parts of
+// the name each stands for.
+func getSynonyms(txn *sql.Tx) (map[string][]*metadatapb.SynonymMetadata, error) {
+ query := `
+ SELECT
+ SCHEMA_NAME(schema_id),
+ name,
+ PARSENAME(base_object_name, 4),
+ PARSENAME(base_object_name, 3),
+ PARSENAME(base_object_name, 2),
+ PARSENAME(base_object_name, 1)
+ FROM sys.synonyms
+ ORDER BY SCHEMA_NAME(schema_id), name`
+ rows, err := txn.Query(query)
+ if err != nil {
+ return nil, util.FormatErrorWithQuery(err, query)
+ }
+ defer rows.Close()
+
+ synonymMap := make(map[string][]*metadatapb.SynonymMetadata)
+ for rows.Next() {
+ var schemaName, name string
+ var server, database, targetSchema, targetName sql.NullString
+ if err := rows.Scan(&schemaName, &name, &server, &database, &targetSchema, &targetName); err != nil {
+ return nil, err
+ }
+ synonymMap[schemaName] = append(synonymMap[schemaName], &metadatapb.SynonymMetadata{
+ Name: name,
+ TargetServer: server.String,
+ TargetDatabase: database.String,
+ TargetSchema: targetSchema.String,
+ TargetName: targetName.String,
+ })
+ }
+ if err := rows.Err(); err != nil {
+ return nil, util.FormatErrorWithQuery(err, query)
+ }
+ return synonymMap, nil
+}
+
func getSchemas(txn *sql.Tx) ([]string, error) {
query := `
SELECT schema_name FROM INFORMATION_SCHEMA.SCHEMATA
diff --git a/backend/plugin/db/mssql/sync_test.go b/backend/plugin/db/mssql/sync_test.go
index 3e16fc1531..ca5838cb3e 100644
--- a/backend/plugin/db/mssql/sync_test.go
+++ b/backend/plugin/db/mssql/sync_test.go
@@ -7,11 +7,14 @@ import (
metadatapb "github.com/bytebase/omni/metadata"
"github.com/google/go-cmp/cmp"
+ "github.com/google/go-cmp/cmp/cmpopts"
_ "github.com/microsoft/go-mssqldb"
"github.com/stretchr/testify/require"
"google.golang.org/protobuf/testing/protocmp"
"github.com/bytebase/bytebase/backend/common/testcontainer"
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/db"
)
// TestSyncUniqueIndex covers which synced indexes carry Unique. SQL Server
@@ -571,3 +574,58 @@ func requireGridLevels(t *testing.T, index *metadatapb.IndexMetadata, level1, le
}
require.Equal(t, map[int32]string{1: level1, 2: level2, 3: level3, 4: level4}, densities)
}
+
+func TestSyncDefaultSchemaAndSynonyms(t *testing.T) {
+ t.Parallel()
+ ctx := context.Background()
+ container := testcontainer.SharedMSSQLContainer(t)
+
+ driver := newSyncTestDatabase(ctx, t, container)
+ executeBatches(ctx, t, driver, `
+CREATE SCHEMA app;
+GO
+CREATE SYNONYM dbo.s1 FOR obj3;
+CREATE SYNONYM dbo.s4 FOR srv1.db1.sch1.obj1;
+CREATE SYNONYM app.s2 FOR sch2.obj2;
+GO
+`)
+
+ metadata, err := driver.SyncDBSchema(ctx)
+ require.NoError(t, err)
+ require.Equal(t, "dbo", metadata.DefaultSchema)
+ synonyms := make(map[string][]*metadatapb.SynonymMetadata)
+ for _, schema := range metadata.Schemas {
+ synonyms[schema.Name] = schema.Synonyms
+ }
+ require.Empty(t, cmp.Diff(map[string][]*metadatapb.SynonymMetadata{
+ "dbo": {
+ {Name: "s1", TargetName: "obj3"},
+ {Name: "s4", TargetServer: "srv1", TargetDatabase: "db1", TargetSchema: "sch1", TargetName: "obj1"},
+ },
+ "app": {{Name: "s2", TargetSchema: "sch2", TargetName: "obj2"}},
+ }, synonyms, protocmp.Transform(), cmpopts.EquateEmpty()))
+
+ // A user that is not sysadmin syncs its own default schema.
+ login := driver.databaseName + "_login"
+ const password = "Test123!login"
+ _, err = container.GetDB().ExecContext(ctx, "CREATE LOGIN ["+login+"] WITH PASSWORD = '"+password+"', CHECK_POLICY = OFF")
+ require.NoError(t, err)
+ t.Cleanup(func() { _, _ = container.GetDB().ExecContext(context.Background(), "DROP LOGIN ["+login+"]") })
+ executeBatches(ctx, t, driver, "CREATE USER ["+login+"] FOR LOGIN ["+login+"] WITH DEFAULT_SCHEMA = app;\nALTER ROLE db_owner ADD MEMBER ["+login+"];")
+ opened, err := (&Driver{}).Open(ctx, storepb.Engine_MSSQL, db.ConnectionConfig{
+ DataSource: &storepb.DataSource{
+ Type: storepb.DataSourceType_ADMIN,
+ Username: login,
+ Host: container.GetHost(),
+ Port: container.GetPort(),
+ Database: driver.databaseName,
+ },
+ Password: password,
+ ConnectionContext: db.ConnectionContext{DatabaseName: driver.databaseName},
+ })
+ require.NoError(t, err)
+ defer opened.Close(ctx)
+ metadata, err = opened.SyncDBSchema(ctx)
+ require.NoError(t, err)
+ require.Equal(t, "app", metadata.DefaultSchema)
+}
diff --git a/backend/runner/reviewrun/rule_executor.go b/backend/runner/reviewrun/rule_executor.go
index 3dac21d6e0..bf25180608 100644
--- a/backend/runner/reviewrun/rule_executor.go
+++ b/backend/runner/reviewrun/rule_executor.go
@@ -183,6 +183,7 @@ func (e *RuleExecutor) resolveReviewTarget(ctx context.Context, project *store.P
BackupDatabaseExists: backupDatabaseExists,
SessionUser: sessionUser(project, instance, schema.GetOwner()),
LowerCaseTableNames: int(instance.Metadata.GetMysqlLowerCaseTableNames()),
+ DefaultSchema: schema.GetDefaultSchema(),
},
}, nil
}
diff --git a/backend/runner/reviewrun/rule_executor_test.go b/backend/runner/reviewrun/rule_executor_test.go
index 80a8004cf2..7f1f9ec530 100644
--- a/backend/runner/reviewrun/rule_executor_test.go
+++ b/backend/runner/reviewrun/rule_executor_test.go
@@ -3,7 +3,9 @@ package reviewrun
import (
"context"
"testing"
+ "time"
+ metadatapb "github.com/bytebase/omni/metadata"
"github.com/stretchr/testify/require"
"google.golang.org/protobuf/encoding/protojson"
@@ -159,3 +161,96 @@ func TestRuleExecutorSkipsAnEngineWithoutAReviewer(t *testing.T) {
require.NoError(t, runOn("dynamo", storepb.Engine_DYNAMODB))
require.NoError(t, runOn("clickhouse", storepb.Engine_CLICKHOUSE))
}
+
+// TestRuleExecutorPassesTheSyncedDefaultSchema pins that SQL Server's walk
+// judges an unqualified name in the default schema the sync read: with it,
+// CREATE TABLE of a name the schema holds is a finding; without it, the walk
+// cannot place the name.
+func TestRuleExecutorPassesTheSyncedDefaultSchema(t *testing.T) {
+ t.Parallel()
+ ctx := context.Background()
+ db, stores, _ := testcontainer.NewMetadataDB(t)
+ _, err := db.ExecContext(ctx, `
+ INSERT INTO workspace (resource_id) VALUES ('ws');
+ INSERT INTO principal (name, email, password_hash) VALUES ('creator', '[email protected]', 'unused');
+ INSERT INTO project (resource_id, workspace, name) VALUES ('p', 'ws', 'P');
+ `)
+ require.NoError(t, err)
+ payload, err := protojson.Marshal(&storepb.ReviewRulePolicy{Rules: []storepb.ReviewRuleType{storepb.ReviewRuleType_SYNTAX, storepb.ReviewRuleType_WALK_THROUGH}})
+ require.NoError(t, err)
+ _, err = stores.CreatePolicy(ctx, &store.PolicyMessage{
+ Workspace: "ws",
+ ResourceType: storepb.Policy_PROJECT,
+ Resource: common.FormatProject("p"),
+ Type: storepb.Policy_REVIEW_RULE,
+ Payload: string(payload),
+ Enforce: true,
+ })
+ require.NoError(t, err)
+ sheets, err := stores.CreateSheets(ctx, "p", &store.SheetMessage{Statement: "CREATE TABLE t (a int);"})
+ require.NoError(t, err)
+
+ review := func(instanceID, defaultSchema string) []string {
+ t.Helper()
+ _, err := stores.CreateInstance(ctx, &store.InstanceMessage{
+ ResourceID: instanceID,
+ Workspace: "ws",
+ Metadata: &storepb.Instance{
+ Engine: storepb.Engine_MSSQL,
+ DataSources: []*storepb.DataSource{{Id: "admin", Type: storepb.DataSourceType_ADMIN}},
+ },
+ })
+ require.NoError(t, err)
+ _, err = stores.UpsertDatabase(ctx, &store.DatabaseMessage{
+ ProjectID: "p",
+ InstanceID: instanceID,
+ DatabaseName: "app",
+ Metadata: &storepb.DatabaseMetadata{},
+ })
+ require.NoError(t, err)
+ _, err = stores.UpsertDBSchema(ctx, instanceID, "app", &metadatapb.DatabaseSchemaMetadata{
+ Name: "app",
+ DefaultSchema: defaultSchema,
+ Schemas: []*metadatapb.SchemaMetadata{{
+ Name: "dbo",
+ Tables: []*metadatapb.TableMetadata{{Name: "t", Columns: []*metadatapb.ColumnMetadata{{Name: "a"}}}},
+ }},
+ }, nil, time.Now())
+ require.NoError(t, err)
+ plan, err := stores.CreatePlan(ctx, &store.PlanMessage{
+ ProjectID: "p",
+ Name: "plan",
+ Config: &storepb.PlanConfig{
+ Specs: []*storepb.PlanConfig_Spec{{
+ Id: "spec-1",
+ Config: &storepb.PlanConfig_Spec_ChangeDatabaseConfig{
+ ChangeDatabaseConfig: &storepb.PlanConfig_ChangeDatabaseConfig{
+ Targets: []string{"instances/" + instanceID + "/databases/app"},
+ SheetSha256: sheets[0].Sha256,
+ },
+ },
+ }},
+ },
+ require.NoError(t, err)
+ issue, err := stores.CreateIssue(ctx, &store.IssueMessage{
+ ProjectID: "p",
+ CreatorEmail: "[email protected]",
+ Title: "issue",
+ Type: storepb.Issue_DATABASE_CHANGE,
+ Payload: &storepb.Issue{},
+ PlanUID: &plan.UID,
+ })
+ require.NoError(t, err)
+ comments, err := NewRuleExecutor(stores).RunOnce(ctx, "p", issue.UID)
+ require.NoError(t, err)
+ var messages []string
+ for _, comment := range comments {
+ messages = append(messages, comment.Payload.GetComment())
+ }
+ return messages
+ }
+
+ require.Equal(t, []string{"an object named t already exists"}, review("synced", "dbo"))
+ require.Empty(t, review("unsynced", ""))
+}