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(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.goindex 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.DatabaseSchemaMeif 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.DatabaseSchemaMeSequences: 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.SCHEMATAdiff --git a/backend/plugin/db/mssql/sync_test.go b/backend/plugin/db/mssql/sync_test.goindex 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.goindex 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.PBackupDatabaseExists: 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.goindex 80a8004cf2..7f1f9ec530 100644--- a/backend/runner/reviewrun/rule_executor_test.go+++ b/backend/runner/reviewrun/rule_executor_test.go@@ -3,7 +3,9 @@ package reviewrunimport ("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,+ },+ },+ }},+ },+ }, "[email protected]")+ 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", ""))+}