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(oracle): parallelize testcontainer tests with isolated Oracle users (#18899)
Danny Xu82cd210947d0
diff --git a/backend/plugin/db/oracle/sync.go b/backend/plugin/db/oracle/sync.goindex 5b652b31e5..12caa42fc2 100644--- a/backend/plugin/db/oracle/sync.go+++ b/backend/plugin/db/oracle/sync.go@@ -727,15 +727,17 @@ func getConstraints(txn *sql.Tx, schemaName string) (case "R":if rOwner.Valid && rConstraintName.Valid {foreignKey := &storepb.ForeignKeyMetadata{- Name: constraintName,- Columns: constraintColumnMap[constraintKey],- ReferencedSchema: rOwner.String,+ Name: constraintName,+ Columns: constraintColumnMap[constraintKey],}if rOwner.String == schemaName {+ // Same-schema reference - don't set ReferencedSchema for portabilityrConstraintKey := db.ConstraintKey{Schema: rOwner.String, Constraint: rConstraintName.String}foreignKey.ReferencedTable = constraintTableMap[rConstraintKey]foreignKey.ReferencedColumns = constraintColumnMap[rConstraintKey]} else {+ // Cross-schema reference - set ReferencedSchema+ foreignKey.ReferencedSchema = rOwner.StringforeignKey.ReferencedTable, foreignKey.ReferencedColumns, err = getOuterSchemaRColumns(txn, outerRTableMap, outerRColumnMap, rOwner.String, rConstraintName.String)if err != nil {return nil, nil, nil, nil, errors.Wrapf(err, "failed to get outer schema reference columns")diff --git a/backend/plugin/schema/oracle/generate_migration_testcontainer_test.go b/backend/plugin/schema/oracle/generate_migration_testcontainer_test.goindex 22bd58ec99..14db89e01a 100644--- a/backend/plugin/schema/oracle/generate_migration_testcontainer_test.go+++ b/backend/plugin/schema/oracle/generate_migration_testcontainer_test.go@@ -5,19 +5,16 @@ import ("database/sql""fmt""slices"- "strconv""strings""testing"- "time"- "github.com/docker/docker/api/types/container""github.com/google/go-cmp/cmp"+ "github.com/google/uuid""github.com/pkg/errors""github.com/stretchr/testify/require"- "github.com/testcontainers/testcontainers-go"- "github.com/testcontainers/testcontainers-go/wait""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"oracledb "github.com/bytebase/bytebase/backend/plugin/db/oracle"@@ -28,6 +25,8 @@ import (// TestGenerateMigrationWithTestcontainer tests the generate migration function// by applying migrations and rollback to verify the schema can be restored.+//+//nolint:tparallelfunc TestGenerateMigrationWithTestcontainer(t *testing.T) {if testing.Short() {t.Skip("Skipping Oracle testcontainer test in short mode")@@ -35,52 +34,14 @@ func TestGenerateMigrationWithTestcontainer(t *testing.T) {ctx := context.Background()- // Use Oracle Free image (Oracle 23c Free) slim version- imageName := "gvenzl/oracle-free:slim"+ // Get Oracle container from testcontainer utility+ container := testcontainer.GetTestOracleContainer(ctx, t)+ t.Cleanup(func() { container.Close(ctx) })- // Start Oracle container- req := testcontainers.ContainerRequest{- Image: imageName,- Env: map[string]string{- "ORACLE_PASSWORD": "test123",- "APP_USER": "testuser",- "APP_USER_PASSWORD": "testpass",- },- ExposedPorts: []string{"1521/tcp"},- WaitingFor: wait.ForLog("DATABASE IS READY TO USE!").- WithStartupTimeout(10 * time.Minute),- HostConfigModifier: func(hc *container.HostConfig) {- hc.ShmSize = 1 * 1024 * 1024 * 1024 // 1GB shared memory- },- }-- container, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{- ContainerRequest: req,- Started: true,- })- if err != nil {- // Get detailed logs for debugging- if container != nil {- logs, logErr := container.Logs(ctx)- if logErr == nil {- buf := make([]byte, 10000)- n, _ := logs.Read(buf)- t.Logf("Container logs on failure: %s", string(buf[:n]))- }- }- require.NoError(t, err, "Failed to start Oracle container")- }- defer func() {- if err := container.Terminate(ctx); err != nil {- t.Logf("failed to terminate container: %s", err)- }- }()-- // Get connection details- host, err := container.Host(ctx)- require.NoError(t, err)- port, err := container.MappedPort(ctx, "1521")+ // Create shared SYSTEM database connection for user management+ systemDB, err := openSystemDatabase(container.GetHost(), container.GetPort())require.NoError(t, err)+ t.Cleanup(func() { systemDB.Close() })// Test cases with various schema changestestCases := []struct {@@ -1758,50 +1719,38 @@ COMMENT ON TABLE SPECIAL_DATA IS '';}for _, tc := range testCases {+ tc := tc // Capture range variablet.Run(tc.name, func(t *testing.T) {- // Step 1: Initialize the database schema and get schema result A- portInt, err := strconv.Atoi(port.Port())- require.NoError(t, err)- testDB, err := openTestDatabase(host, portInt, "testuser", "testpass")- require.NoError(t, err)- defer testDB.Close()+ t.Parallel()- // Set current schema to TESTUSER- _, err = testDB.Exec("ALTER SESSION SET CURRENT_SCHEMA = TESTUSER")- require.NoError(t, err)+ // Create unique Oracle user for this test (Oracle users are schemas)+ // Use UUID to ensure uniqueness and avoid name collisions+ testUser := fmt.Sprintf("U_%s", strings.ReplaceAll(uuid.New().String(), "-", "_"))- // Clean up any existing objects- // Drop procedures- _, _ = testDB.Exec("BEGIN FOR c IN (SELECT object_name FROM user_objects WHERE object_type = 'PROCEDURE') LOOP EXECUTE IMMEDIATE 'DROP PROCEDURE ' || c.object_name; END LOOP; END;")- // Drop packages (must be before functions/procedures that might be in packages)- _, _ = testDB.Exec("BEGIN FOR c IN (SELECT object_name FROM user_objects WHERE object_type = 'PACKAGE') LOOP EXECUTE IMMEDIATE 'DROP PACKAGE ' || c.object_name; END LOOP; END;")- // Drop functions- _, _ = testDB.Exec("BEGIN FOR c IN (SELECT object_name FROM user_objects WHERE object_type = 'FUNCTION') LOOP EXECUTE IMMEDIATE 'DROP FUNCTION ' || c.object_name; END LOOP; END;")- // Drop types- _, _ = testDB.Exec("BEGIN FOR c IN (SELECT type_name FROM user_types) LOOP EXECUTE IMMEDIATE 'DROP TYPE ' || c.type_name || ' FORCE'; END LOOP; END;")- // Drop materialized views- _, _ = testDB.Exec("BEGIN FOR c IN (SELECT mview_name FROM user_mviews) LOOP EXECUTE IMMEDIATE 'DROP MATERIALIZED VIEW ' || c.mview_name; END LOOP; END;")- // Drop views- _, _ = testDB.Exec("BEGIN FOR c IN (SELECT view_name FROM user_views) LOOP EXECUTE IMMEDIATE 'DROP VIEW ' || c.view_name; END LOOP; END;")- // Drop tables (with CASCADE CONSTRAINTS to handle foreign keys)- _, _ = testDB.Exec("BEGIN FOR c IN (SELECT table_name FROM user_tables) LOOP EXECUTE IMMEDIATE 'DROP TABLE ' || c.table_name || ' CASCADE CONSTRAINTS'; END LOOP; END;")- // Drop sequences (excluding system-generated ones)- _, _ = testDB.Exec("BEGIN FOR c IN (SELECT sequence_name FROM user_sequences WHERE sequence_name NOT LIKE 'ISEQ$$_%') LOOP EXECUTE IMMEDIATE 'DROP SEQUENCE ' || c.sequence_name; END LOOP; END;")+ // Create user using shared SYSTEM connection+ require.NoError(t, createOracleUser(systemDB, testUser))++ // Connect as the test user+ driver, err := createOracleDriver(ctx, container.GetHost(), container.GetPort(), testUser)+ require.NoError(t, err)+ defer driver.Close(ctx)// Execute initial schema- if err := executeStatements(testDB, tc.initialSchema); err != nil {+ if err := executeStatements(ctx, driver, tc.initialSchema); err != nil {t.Fatalf("Failed to execute initial schema: %v", err)}- schemaA, err := getSyncMetadataForGenerateMigration(ctx, host, portInt)+ // Get schema metadata A+ schemaA, err := driver.SyncDBSchema(ctx)require.NoError(t, err)// Step 2: Do some migration and get schema result B- if err := executeStatements(testDB, tc.migrationDDL); err != nil {+ if err := executeStatements(ctx, driver, tc.migrationDDL); err != nil {t.Fatalf("Failed to execute migration DDL: %v", err)}- schemaB, err := getSyncMetadataForGenerateMigration(ctx, host, portInt)+ // Get schema metadata B+ schemaB, err := driver.SyncDBSchema(ctx)require.NoError(t, err)// Step 3: Call generate migration to get the rollback DDL@@ -1818,11 +1767,12 @@ COMMENT ON TABLE SPECIAL_DATA IS '';require.NoError(t, err)// Step 4: Run rollback DDL and get schema result C- if err := executeStatements(testDB, rollbackDDL); err != nil {+ if err := executeStatements(ctx, driver, rollbackDDL); err != nil {t.Fatalf("Failed to execute rollback DDL: %v", err)}- schemaC, err := getSyncMetadataForGenerateMigration(ctx, host, portInt)+ // Get schema metadata C+ schemaC, err := driver.SyncDBSchema(ctx)require.NoError(t, err)// Step 5: Compare schema result A and C to ensure they are the same@@ -1841,9 +1791,46 @@ COMMENT ON TABLE SPECIAL_DATA IS '';}}-// openTestDatabase opens a connection to the test Oracle database-func openTestDatabase(host string, port int, username, password string) (*sql.DB, error) {- dsn := fmt.Sprintf("oracle://%s:%s@%s:%d/FREEPDB1", username, password, host, port)+// createOracleUser creates an Oracle user (schema) with necessary privileges+func createOracleUser(systemDB *sql.DB, username string) error {+ // Use same password as container for test simplicity+ for _, stmt := range []string{+ fmt.Sprintf("CREATE USER %s IDENTIFIED BY test123", username),+ fmt.Sprintf("GRANT CONNECT, RESOURCE, CREATE VIEW, CREATE MATERIALIZED VIEW, CREATE PROCEDURE, CREATE SEQUENCE, CREATE TRIGGER TO %s", username),+ fmt.Sprintf("GRANT UNLIMITED TABLESPACE TO %s", username),+ } {+ if _, err := systemDB.Exec(stmt); err != nil {+ return err+ }+ }+ return nil+}++// createOracleDriver creates and opens an Oracle driver connection+func createOracleDriver(ctx context.Context, host, port, username string) (db.Driver, error) {+ driver := &oracledb.Driver{}+ config := db.ConnectionConfig{+ DataSource: &storepb.DataSource{+ Type: storepb.DataSourceType_ADMIN,+ Username: username,+ Host: host,+ Port: port,+ Database: "",+ ServiceName: "FREEPDB1",+ },+ Password: "test123", // Use same password as container for test simplicity+ ConnectionContext: db.ConnectionContext{+ EngineVersion: "23.0",+ DatabaseName: strings.ToUpper(username),+ },+ }+ return driver.Open(ctx, storepb.Engine_ORACLE, config)+}++// openSystemDatabase opens a connection to Oracle using the SYSTEM account+func openSystemDatabase(host string, port string) (*sql.DB, error) {+ // Use SYSTEM account with the password from container env+ dsn := fmt.Sprintf("oracle://system:test123@%s:%s/FREEPDB1", host, port)db, err := sql.Open("oracle", dsn)if err != nil {return nil, err@@ -1855,12 +1842,7 @@ func openTestDatabase(host string, port int, username, password string) (*sql.DB}// executeStatements executes multiple SQL statements, handling both regular DDL and PL/SQL blocks-func executeStatements(db *sql.DB, statements string) error {- // Set current schema to TESTUSER before executing any statements- if _, err := db.Exec("ALTER SESSION SET CURRENT_SCHEMA = TESTUSER"); err != nil {- return errors.Wrapf(err, "failed to set current schema")- }-+func executeStatements(ctx context.Context, driver db.Driver, statements string) error {// Use plsql.SplitSQL to properly split Oracle SQL statementsstmts, err := plsqlparser.SplitSQL(statements)if err != nil {@@ -1890,13 +1872,13 @@ func executeStatements(db *sql.DB, statements string) error {}// Execute the statement- if _, err := db.Exec(stmt); err != nil {+ if _, err := driver.Execute(ctx, stmt, db.ExecuteOptions{}); err != nil {// Handle Oracle-specific issues where materialized views are misclassified as tablesif strings.Contains(err.Error(), "must use DROP MATERIALIZED VIEW") {// Try to fix the statement by replacing DROP TABLE with DROP MATERIALIZED VIEWif strings.HasPrefix(strings.ToUpper(stmt), "DROP TABLE") {fixedStmt := strings.Replace(stmt, "DROP TABLE", "DROP MATERIALIZED VIEW", 1)- if _, retryErr := db.Exec(fixedStmt); retryErr == nil {+ if _, retryErr := driver.Execute(ctx, fixedStmt, db.ExecuteOptions{}); retryErr == nil {continue // Successfully executed with corrected statement}}@@ -1913,49 +1895,6 @@ func executeStatements(db *sql.DB, statements string) error {return nil}-// getSyncMetadataForGenerateMigration retrieves metadata from the live database using Driver.SyncDBSchema-func getSyncMetadataForGenerateMigration(ctx context.Context, host string, port int) (*storepb.DatabaseSchemaMetadata, error) {- // Create a driver instance using the oracle package- driver := &oracledb.Driver{}-- // Create connection config- config := db.ConnectionConfig{- DataSource: &storepb.DataSource{- Type: storepb.DataSourceType_ADMIN,- Username: "testuser",- Host: host,- Port: fmt.Sprintf("%d", port),- Database: "",- ServiceName: "FREEPDB1",- },- Password: "testpass",- ConnectionContext: db.ConnectionContext{- EngineVersion: "23.0", // Oracle 23c Free- DatabaseName: "TESTUSER", // Oracle schema names are uppercase- },- }-- // Open connection using the driver- openedDriver, err := driver.Open(ctx, storepb.Engine_ORACLE, config)- if err != nil {- return nil, err- }- defer openedDriver.Close(ctx)-- // Use SyncDBSchema to get the metadata- oracleDriver, ok := openedDriver.(*oracledb.Driver)- if !ok {- return nil, errors.New("failed to cast to oracle.Driver")- }-- metadata, err := oracleDriver.SyncDBSchema(ctx)- if err != nil {- return nil, err- }-- return metadata, nil-}-// normalizeMetadataForComparison normalizes metadata to ignore differences that don't affect schema equalityfunc normalizeMetadataForComparison(metadata *storepb.DatabaseSchemaMetadata) {// Clear database name as it might differdiff --git a/backend/plugin/schema/oracle/get_database_definition.go b/backend/plugin/schema/oracle/get_database_definition.goindex 624a81fc59..2629830ad2 100644--- a/backend/plugin/schema/oracle/get_database_definition.go+++ b/backend/plugin/schema/oracle/get_database_definition.go@@ -20,6 +20,8 @@ func GetDatabaseDefinition(_ schema.GetDefinitionContext, to *storepb.DatabaseScvar buf strings.Builderschema := to.Schemas[0]+ // For Oracle, the database name (user/schema name) is stored in to.Name+ databaseName := to.Name// First generate sequences (they need to exist before tables that reference them)for _, sequence := range schema.Sequences {@@ -41,14 +43,14 @@ func GetDatabaseDefinition(_ schema.GetDefinitionContext, to *storepb.DatabaseSc// Add tables to graphfor _, table := range schema.Tables {- tableID := getObjectID(schema.Name, table.Name)+ tableID := getObjectID(databaseName, table.Name)tableMap[tableID] = tablegraph.AddNode(tableID)}// Add views to graphfor _, view := range schema.Views {- viewID := getObjectID(schema.Name, view.Name)+ viewID := getObjectID(databaseName, view.Name)viewMap[viewID] = viewgraph.AddNode(viewID)// Add dependencies from view to tables/views it references@@ -60,7 +62,7 @@ func GetDatabaseDefinition(_ schema.GetDefinitionContext, to *storepb.DatabaseSc// Add materialized views to graphfor _, view := range schema.MaterializedViews {- viewID := getObjectID(schema.Name, view.Name)+ viewID := getObjectID(databaseName, view.Name)materializedViewMap[viewID] = viewgraph.AddNode(viewID)// Add dependencies from materialized view to tables/views it references@@ -72,7 +74,7 @@ func GetDatabaseDefinition(_ schema.GetDefinitionContext, to *storepb.DatabaseSc// Add functions to graphfor _, function := range schema.Functions {- functionID := getObjectID(schema.Name, function.Name)+ functionID := getObjectID(databaseName, function.Name)functionMap[functionID] = functiongraph.AddNode(functionID)// Add dependencies from function to tables it references@@ -84,7 +86,7 @@ func GetDatabaseDefinition(_ schema.GetDefinitionContext, to *storepb.DatabaseSc// Add procedures to graphfor _, procedure := range schema.Procedures {- procedureID := getObjectID(schema.Name, procedure.Name)+ procedureID := getObjectID(databaseName, procedure.Name)procedureMap[procedureID] = proceduregraph.AddNode(procedureID)// Note: ProcedureMetadata doesn't have DependencyTables field@@ -93,10 +95,10 @@ func GetDatabaseDefinition(_ schema.GetDefinitionContext, to *storepb.DatabaseSc// Add foreign key dependencies between tablesfor _, table := range schema.Tables {- tableID := getObjectID(schema.Name, table.Name)+ tableID := getObjectID(databaseName, table.Name)for _, fk := range table.ForeignKeys {if fk.ReferencedTable != table.Name { // Avoid self-references- referencedTableID := getObjectID(schema.Name, fk.ReferencedTable)+ referencedTableID := getObjectID(databaseName, fk.ReferencedTable)graph.AddEdge(referencedTableID, tableID)}}@@ -107,27 +109,27 @@ func GetDatabaseDefinition(_ schema.GetDefinitionContext, to *storepb.DatabaseScif err != nil {// If there are cycles, fall back to original orderfor _, table := range schema.Tables {- if err := writeTable(&buf, schema.Name, table); err != nil {+ if err := writeTable(&buf, table); err != nil {return "", err}}for _, view := range schema.Views {- if err := writeView(&buf, schema.Name, view); err != nil {+ if err := writeView(&buf, view); err != nil {return "", err}}for _, view := range schema.MaterializedViews {- if err := writeMaterializedView(&buf, schema.Name, view); err != nil {+ if err := writeMaterializedView(&buf, view); err != nil {return "", err}}for _, function := range schema.Functions {- if err := writeFunction(&buf, schema.Name, function); err != nil {+ if err := writeFunction(&buf, function); err != nil {return "", err}}for _, procedure := range schema.Procedures {- if err := writeProcedure(&buf, schema.Name, procedure); err != nil {+ if err := writeProcedure(&buf, procedure); err != nil {return "", err}}@@ -137,27 +139,27 @@ func GetDatabaseDefinition(_ schema.GetDefinitionContext, to *storepb.DatabaseSc// Generate objects in dependency orderfor _, objectID := range orderedList {if table, ok := tableMap[objectID]; ok {- if err := writeTable(&buf, schema.Name, table); err != nil {+ if err := writeTable(&buf, table); err != nil {return "", err}}if view, ok := viewMap[objectID]; ok {- if err := writeView(&buf, schema.Name, view); err != nil {+ if err := writeView(&buf, view); err != nil {return "", err}}if view, ok := materializedViewMap[objectID]; ok {- if err := writeMaterializedView(&buf, schema.Name, view); err != nil {+ if err := writeMaterializedView(&buf, view); err != nil {return "", err}}if function, ok := functionMap[objectID]; ok {- if err := writeFunction(&buf, schema.Name, function); err != nil {+ if err := writeFunction(&buf, function); err != nil {return "", err}}if procedure, ok := procedureMap[objectID]; ok {- if err := writeProcedure(&buf, schema.Name, procedure); err != nil {+ if err := writeProcedure(&buf, procedure); err != nil {return "", err}}@@ -166,16 +168,16 @@ func GetDatabaseDefinition(_ schema.GetDefinitionContext, to *storepb.DatabaseScreturn buf.String(), nil}-func GetTableDefinition(schemaName string, table *storepb.TableMetadata, _ []*storepb.SequenceMetadata) (string, error) {+func GetTableDefinition(_ string, table *storepb.TableMetadata, _ []*storepb.SequenceMetadata) (string, error) {var buf strings.Builder- if err := writeTable(&buf, schemaName, table); err != nil {+ if err := writeTable(&buf, table); err != nil {return "", err}return buf.String(), nil}-func writeTable(buf *strings.Builder, schema string, table *storepb.TableMetadata) error {+func writeTable(buf *strings.Builder, table *storepb.TableMetadata) error {if _, err := buf.WriteString(`CREATE TABLE "`); err != nil {return err}@@ -243,7 +245,7 @@ func writeTable(buf *strings.Builder, schema string, table *storepb.TableMetadatif _, err := buf.WriteString(` `); err != nil {return err}- if err := writeForeignKey(buf, schema, fk); err != nil {+ if err := writeForeignKey(buf, fk); err != nil {return err}}@@ -262,7 +264,7 @@ func writeTable(buf *strings.Builder, schema string, table *storepb.TableMetadat// Write triggers for this tablefor _, trigger := range table.Triggers {- if err := writeTrigger(buf, schema, trigger); err != nil {+ if err := writeTrigger(buf, trigger); err != nil {return err}}@@ -379,7 +381,7 @@ func writeIndex(buf *strings.Builder, table string, index *storepb.IndexMetadatareturn nil}-func writeForeignKey(buf *strings.Builder, schema string, fk *storepb.ForeignKeyMetadata) error {+func writeForeignKey(buf *strings.Builder, fk *storepb.ForeignKeyMetadata) error {if _, err := buf.WriteString(`CONSTRAINT "`); err != nil {return err}@@ -411,7 +413,9 @@ func writeForeignKey(buf *strings.Builder, schema string, fk *storepb.ForeignKeyif _, err := buf.WriteString(`) REFERENCES "`); err != nil {return err}- if fk.ReferencedSchema != schema {+ // Only include schema prefix for cross-schema foreign key references+ // Same-schema references don't need prefix for portability+ if fk.ReferencedSchema != "" {if _, err := buf.WriteString(fk.ReferencedSchema); err != nil {return err}@@ -642,7 +646,7 @@ func getObjectID(schema, objectName string) string {}// writeView writes a CREATE VIEW statement-func writeView(buf *strings.Builder, _ string, view *storepb.ViewMetadata) error {+func writeView(buf *strings.Builder, view *storepb.ViewMetadata) error {if _, err := buf.WriteString(`CREATE VIEW "`); err != nil {return err}@@ -667,7 +671,7 @@ func writeView(buf *strings.Builder, _ string, view *storepb.ViewMetadata) error}// writeMaterializedView writes a CREATE MATERIALIZED VIEW statement-func writeMaterializedView(buf *strings.Builder, _ string, view *storepb.MaterializedViewMetadata) error {+func writeMaterializedView(buf *strings.Builder, view *storepb.MaterializedViewMetadata) error {if _, err := buf.WriteString(`CREATE MATERIALIZED VIEW "`); err != nil {return err}@@ -692,7 +696,7 @@ func writeMaterializedView(buf *strings.Builder, _ string, view *storepb.Materia}// writeFunction writes a CREATE FUNCTION statement-func writeFunction(buf *strings.Builder, _ string, function *storepb.FunctionMetadata) error {+func writeFunction(buf *strings.Builder, function *storepb.FunctionMetadata) error {definition := function.Definition// If the definition doesn't start with CREATE, add the CREATE OR REPLACE prefixif !strings.HasPrefix(strings.ToUpper(strings.TrimSpace(definition)), "CREATE") {@@ -715,7 +719,7 @@ func writeFunction(buf *strings.Builder, _ string, function *storepb.FunctionMet}// writeProcedure writes a CREATE PROCEDURE statement-func writeProcedure(buf *strings.Builder, _ string, procedure *storepb.ProcedureMetadata) error {+func writeProcedure(buf *strings.Builder, procedure *storepb.ProcedureMetadata) error {definition := procedure.Definition// If the definition doesn't start with CREATE, add the CREATE OR REPLACE prefixif !strings.HasPrefix(strings.ToUpper(strings.TrimSpace(definition)), "CREATE") {@@ -738,7 +742,7 @@ func writeProcedure(buf *strings.Builder, _ string, procedure *storepb.Procedure}// writeTrigger writes a CREATE TRIGGER statement-func writeTrigger(buf *strings.Builder, _ string, trigger *storepb.TriggerMetadata) error {+func writeTrigger(buf *strings.Builder, trigger *storepb.TriggerMetadata) error {// The trigger body should already contain the full CREATE TRIGGER statementif _, err := buf.WriteString(trigger.Body); err != nil {return errdiff --git a/backend/plugin/schema/oracle/get_database_definition_testcontainer_test.go b/backend/plugin/schema/oracle/get_database_definition_testcontainer_test.goindex 9fcfc7cdbc..4f8e57e382 100644--- a/backend/plugin/schema/oracle/get_database_definition_testcontainer_test.go+++ b/backend/plugin/schema/oracle/get_database_definition_testcontainer_test.go@@ -2,12 +2,12 @@ package oracleimport ("context"- "database/sql"- "strconv"+ "fmt""strings""testing""github.com/google/go-cmp/cmp"+ "github.com/google/uuid""github.com/stretchr/testify/require""google.golang.org/protobuf/testing/protocmp"@@ -19,6 +19,8 @@ import (// TestGetDatabaseDefinitionWithTestcontainer tests the GetDatabaseDefinition function// by creating a schema, getting its definition, recreating it in a new database,// and comparing the results.+//+//nolint:tparallelfunc TestGetDatabaseDefinitionWithTestcontainer(t *testing.T) {if testing.Short() {t.Skip("Skipping Oracle testcontainer test in short mode")@@ -28,7 +30,12 @@ func TestGetDatabaseDefinitionWithTestcontainer(t *testing.T) {// Get Oracle container from testcontainer utilitycontainer := testcontainer.GetTestOracleContainer(ctx, t)- defer container.Close(ctx)+ t.Cleanup(func() { container.Close(ctx) })++ // Create shared SYSTEM database connection for user management+ systemDB, err := openSystemDatabase(container.GetHost(), container.GetPort())+ require.NoError(t, err)+ t.Cleanup(func() { systemDB.Close() })// Test cases with various schema configurationstestCases := []struct {@@ -64,24 +71,28 @@ CREATE INDEX IDX_EMP_NAME ON EMPLOYEES(NAME);}for _, tc := range testCases {+ tc := tc // Capture range variablet.Run(tc.name, func(t *testing.T) {- // Get the database connection from the container- testDB := container.GetDB()+ t.Parallel()- // Set current schema to TESTUSER- _, err := testDB.Exec("ALTER SESSION SET CURRENT_SCHEMA = TESTUSER")- require.NoError(t, err)+ // Create unique Oracle user for this test (Oracle users are schemas)+ // Use UUID to ensure uniqueness and avoid name collisions+ testUser := fmt.Sprintf("U_%s", strings.ReplaceAll(uuid.New().String(), "-", "_"))- // Clean up any existing objects- cleanupSchema(t, testDB)+ // Create user using shared SYSTEM connection+ require.NoError(t, createOracleUser(systemDB, testUser))++ // Connect as the test user+ driver, err := createOracleDriver(ctx, container.GetHost(), container.GetPort(), testUser)+ require.NoError(t, err)+ defer driver.Close(ctx)// Step 1: Initialize the database schema and use SyncDBSchema to get metadata A- err = executeStatements(testDB, tc.initialSchema)+ err = executeStatements(ctx, driver, tc.initialSchema)require.NoError(t, err, "Failed to execute initial schema")- portInt, err := strconv.Atoi(container.GetPort())- require.NoError(t, err)- metadataA, err := getSyncMetadataForGenerateMigration(ctx, container.GetHost(), portInt)+ // Get schema metadata A+ metadataA, err := driver.SyncDBSchema(ctx)require.NoError(t, err, "Failed to get initial metadata")// Step 2: Call GetDatabaseDefinition to generate the database definition X@@ -92,16 +103,24 @@ CREATE INDEX IDX_EMP_NAME ON EMPLOYEES(NAME);// Log the generated definition for debuggingt.Logf("Generated definition:\n%s", definition)- // Step 3: Create a new database schema and run the database definition X- // First, clean up the schema- cleanupSchema(t, testDB)+ // Step 3: Create a new user and run the database definition X+ // Create a second unique user for recreation test+ testUser2 := fmt.Sprintf("U_%s", strings.ReplaceAll(uuid.New().String(), "-", "_"))++ // Create the second user+ require.NoError(t, createOracleUser(systemDB, testUser2))++ // Connect as the second test user+ driver2, err := createOracleDriver(ctx, container.GetHost(), container.GetPort(), testUser2)+ require.NoError(t, err)+ defer driver2.Close(ctx)- // Execute the generated definition- err = executeStatements(testDB, definition)+ // Execute the generated definition in the new user's schema+ err = executeStatements(ctx, driver2, definition)require.NoError(t, err, "Failed to execute generated definition")// Get metadata B after recreating from definition- metadataB, err := getSyncMetadataForGenerateMigration(ctx, container.GetHost(), portInt)+ metadataB, err := driver2.SyncDBSchema(ctx)require.NoError(t, err, "Failed to get metadata after recreation")// Step 4: Compare the database metadata A and B, should be the same@@ -124,40 +143,6 @@ CREATE INDEX IDX_EMP_NAME ON EMPLOYEES(NAME);}}-// cleanupSchema drops all user objects in the schema-func cleanupSchema(t *testing.T, db *sql.DB) {- // Set current schema to TESTUSER before cleanup- _, err := db.Exec("ALTER SESSION SET CURRENT_SCHEMA = TESTUSER")- require.NoError(t, err)-- // Drop all user objects in dependency order- dropStatements := []string{- // Drop triggers first- "BEGIN FOR c IN (SELECT trigger_name FROM user_triggers) LOOP EXECUTE IMMEDIATE 'DROP TRIGGER ' || c.trigger_name; END LOOP; END;",- // Drop materialized views- "BEGIN FOR c IN (SELECT mview_name FROM user_mviews) LOOP EXECUTE IMMEDIATE 'DROP MATERIALIZED VIEW ' || c.mview_name; END LOOP; END;",- // Drop views- "BEGIN FOR c IN (SELECT view_name FROM user_views) LOOP EXECUTE IMMEDIATE 'DROP VIEW ' || c.view_name || ' CASCADE CONSTRAINTS'; END LOOP; END;",- // Drop synonyms- "BEGIN FOR c IN (SELECT synonym_name FROM user_synonyms) LOOP EXECUTE IMMEDIATE 'DROP SYNONYM ' || c.synonym_name; END LOOP; END;",- // Drop procedures- "BEGIN FOR c IN (SELECT object_name FROM user_objects WHERE object_type = 'PROCEDURE') LOOP EXECUTE IMMEDIATE 'DROP PROCEDURE ' || c.object_name; END LOOP; END;",- // Drop functions- "BEGIN FOR c IN (SELECT object_name FROM user_objects WHERE object_type = 'FUNCTION') LOOP EXECUTE IMMEDIATE 'DROP FUNCTION ' || c.object_name; END LOOP; END;",- // Drop tables with cascade constraints- "BEGIN FOR c IN (SELECT table_name FROM user_tables) LOOP EXECUTE IMMEDIATE 'DROP TABLE ' || c.table_name || ' CASCADE CONSTRAINTS'; END LOOP; END;",- // Drop non-system sequences (system sequences cannot be dropped)- "BEGIN FOR c IN (SELECT sequence_name FROM user_sequences WHERE sequence_name NOT LIKE 'ISEQ$$_%') LOOP EXECUTE IMMEDIATE 'DROP SEQUENCE ' || c.sequence_name; END LOOP; END;",- }-- for _, stmt := range dropStatements {- _, err := db.Exec(stmt)- if err != nil {- t.Logf("Warning during cleanup: %v", err)- }- }-}-// normalizeOracleMetadata handles Oracle-specific normalization for metadata comparisonfunc normalizeOracleMetadata(metadata *storepb.DatabaseSchemaMetadata) {for _, schema := range metadata.Schemas {diff --git a/backend/plugin/schema/oracle/get_database_metadata_test.go b/backend/plugin/schema/oracle/get_database_metadata_test.goindex 902d673e8a..0b4a764cb2 100644--- a/backend/plugin/schema/oracle/get_database_metadata_test.go+++ b/backend/plugin/schema/oracle/get_database_metadata_test.go@@ -6,51 +6,32 @@ import ("strings""testing"+ "github.com/google/uuid""github.com/stretchr/testify/require""github.com/bytebase/bytebase/backend/common/testcontainer"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/db"- oracledb "github.com/bytebase/bytebase/backend/plugin/db/oracle")// TestGetDatabaseMetadataWithTestcontainer tests the get_database_metadata function// by comparing its output with the metadata retrieved from a real Oracle instance.+//+//nolint:tparallelfunc TestGetDatabaseMetadataWithTestcontainer(t *testing.T) {ctx := context.Background()// Start Oracle containercontainer := testcontainer.GetTestOracleContainer(ctx, t)- defer container.Close(ctx)+ t.Cleanup(func() { container.Close(ctx) })host := container.GetHost()port := container.GetPort()- // Create Oracle driver for metadata sync- driver := &oracledb.Driver{}- config := db.ConnectionConfig{- DataSource: &storepb.DataSource{- Type: storepb.DataSourceType_ADMIN,- Username: "testuser",- Host: host,- Port: port,- Database: "FREEPDB1",- ServiceName: "FREEPDB1",- },- Password: "testpass",- ConnectionContext: db.ConnectionContext{- EngineVersion: "21.0",- DatabaseName: "TESTUSER",- },- }-- openedDriver, err := driver.Open(ctx, storepb.Engine_ORACLE, config)+ // Create shared SYSTEM database connection for user management+ systemDB, err := openSystemDatabase(host, port)require.NoError(t, err)- defer openedDriver.Close(ctx)-- // Cast to Oracle driver for SyncDBSchema- oracleDriver, ok := openedDriver.(*oracledb.Driver)- require.True(t, ok, "failed to cast to oracle.Driver")+ t.Cleanup(func() { systemDB.Close() })// Test cases with various Oracle featurestestCases := []struct {@@ -773,13 +754,27 @@ COMMENT ON COLUMN ORDER_LINE_ITEMS.FULFILLMENT_STATUS IS 'Status: PENDING, PICKE}for _, tc := range testCases {+ tc := tc // Capture range variablet.Run(tc.name, func(t *testing.T) {+ t.Parallel()++ // Create unique Oracle user for this test (Oracle users are schemas)+ testUser := fmt.Sprintf("U_%s", strings.ReplaceAll(uuid.New().String(), "-", "_"))++ // Create user using shared SYSTEM connection+ require.NoError(t, createOracleUser(systemDB, testUser))++ // Create Oracle driver for metadata sync+ driver, err := createOracleDriver(ctx, host, port, testUser)+ require.NoError(t, err)+ defer driver.Close(ctx)+// Execute DDL using the driver- _, err = openedDriver.Execute(ctx, tc.ddl, db.ExecuteOptions{})+ _, err = driver.Execute(ctx, tc.ddl, db.ExecuteOptions{})require.NoError(t, err)// Get metadata from live database using driver- dbMetadata, err := oracleDriver.SyncDBSchema(ctx)+ dbMetadata, err := driver.SyncDBSchema(ctx)require.NoError(t, err)// Get metadata from parser@@ -789,51 +784,7 @@ COMMENT ON COLUMN ORDER_LINE_ITEMS.FULFILLMENT_STATUS IS 'Status: PENDING, PICKE// Compare metadatacompareMetadata(t, dbMetadata, parsedMetadata, tc.name)- // Clean up - drop all objects to avoid conflicts- cleanupStatements := []string{- // Drop packages first- "DROP PACKAGE BODY financial_utils",- "DROP PACKAGE financial_utils",- // Drop functions and procedures- "DROP FUNCTION get_available_credit",- "DROP FUNCTION calculate_account_risk_score",- "DROP PROCEDURE update_account_balance",- // Drop materialized views- "DROP MATERIALIZED VIEW PRODUCT_PERFORMANCE_MV",- "DROP MATERIALIZED VIEW SALES_MONTHLY_MV",- // Drop views- "DROP VIEW CUSTOMER_SALES_ANALYSIS",- "DROP VIEW MONTHLY_SALES_SUMMARY",- "DROP VIEW EXPENSIVE_PRODUCTS",- // Drop triggers- "DROP TRIGGER inventory_audit_trigger",- "DROP TRIGGER audit_log_trigger",- // Drop sequences- "DROP SEQUENCE inventory_seq",- "DROP SEQUENCE audit_log_seq",- "DROP SEQUENCE EMP_SEQ",- // Drop tables (order matters due to foreign keys)- "DROP TABLE ORDER_LINE_ITEMS CASCADE CONSTRAINTS",- "DROP TABLE PRODUCT_CATALOG CASCADE CONSTRAINTS",- "DROP TABLE CUSTOMER_ACCOUNTS CASCADE CONSTRAINTS",- "DROP TABLE PRODUCT_SALES_DAILY CASCADE CONSTRAINTS",- "DROP TABLE SALES_TRANSACTIONS CASCADE CONSTRAINTS",- "DROP TABLE INVENTORY CASCADE CONSTRAINTS",- "DROP TABLE AUDIT_LOG CASCADE CONSTRAINTS",- "DROP TABLE CUSTOMER_ORDERS CASCADE CONSTRAINTS",- "DROP TABLE EMPLOYEES_FK CASCADE CONSTRAINTS",- "DROP TABLE DEPARTMENTS CASCADE CONSTRAINTS",- "DROP TABLE ORDERS CASCADE CONSTRAINTS",- "DROP TABLE DATA_TYPES_COMPREHENSIVE CASCADE CONSTRAINTS",- "DROP TABLE TEST_TABLE CASCADE CONSTRAINTS",- "DROP TABLE EMPLOYEES CASCADE CONSTRAINTS",- "DROP TABLE PRODUCTS CASCADE CONSTRAINTS",- }-- for _, stmt := range cleanupStatements {- _, _ = openedDriver.Execute(ctx, stmt, db.ExecuteOptions{})- // Ignore errors during cleanup- }+ // No need to clean up - each test has its own isolated user})}}