Skip to content

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

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.go
index 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 portability
rConstraintKey := 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.String
foreignKey.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.go
index 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:tparallel
func 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 changes
testCases := []struct {
@@ -1758,50 +1719,38 @@ COMMENT ON TABLE SPECIAL_DATA IS '';
}
for _, tc := range testCases {
+ tc := tc // Capture range variable
t.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 statements
stmts, 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 tables
if strings.Contains(err.Error(), "must use DROP MATERIALIZED VIEW") {
// Try to fix the statement by replacing DROP TABLE with DROP MATERIALIZED VIEW
if 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 equality
func normalizeMetadataForComparison(metadata *storepb.DatabaseSchemaMetadata) {
// Clear database name as it might differ
diff --git a/backend/plugin/schema/oracle/get_database_definition.go b/backend/plugin/schema/oracle/get_database_definition.go
index 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.DatabaseSc
var buf strings.Builder
schema := 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 graph
for _, table := range schema.Tables {
- tableID := getObjectID(schema.Name, table.Name)
+ tableID := getObjectID(databaseName, table.Name)
tableMap[tableID] = table
graph.AddNode(tableID)
}
// Add views to graph
for _, view := range schema.Views {
- viewID := getObjectID(schema.Name, view.Name)
+ viewID := getObjectID(databaseName, view.Name)
viewMap[viewID] = view
graph.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 graph
for _, view := range schema.MaterializedViews {
- viewID := getObjectID(schema.Name, view.Name)
+ viewID := getObjectID(databaseName, view.Name)
materializedViewMap[viewID] = view
graph.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 graph
for _, function := range schema.Functions {
- functionID := getObjectID(schema.Name, function.Name)
+ functionID := getObjectID(databaseName, function.Name)
functionMap[functionID] = function
graph.AddNode(functionID)
// Add dependencies from function to tables it references
@@ -84,7 +86,7 @@ func GetDatabaseDefinition(_ schema.GetDefinitionContext, to *storepb.DatabaseSc
// Add procedures to graph
for _, procedure := range schema.Procedures {
- procedureID := getObjectID(schema.Name, procedure.Name)
+ procedureID := getObjectID(databaseName, procedure.Name)
procedureMap[procedureID] = procedure
graph.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 tables
for _, 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.DatabaseSc
if err != nil {
// If there are cycles, fall back to original order
for _, 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 order
for _, 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.DatabaseSc
return 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.TableMetadat
if _, 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 table
for _, 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.IndexMetadata
return 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.ForeignKey
if _, 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 prefix
if !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 prefix
if !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 statement
if _, err := buf.WriteString(trigger.Body); err != nil {
return err
diff --git a/backend/plugin/schema/oracle/get_database_definition_testcontainer_test.go b/backend/plugin/schema/oracle/get_database_definition_testcontainer_test.go
index 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 oracle
import (
"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:tparallel
func 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 utility
container := 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 configurations
testCases := []struct {
@@ -64,24 +71,28 @@ CREATE INDEX IDX_EMP_NAME ON EMPLOYEES(NAME);
}
for _, tc := range testCases {
+ tc := tc // Capture range variable
t.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 debugging
t.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 comparison
func 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.go
index 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:tparallel
func TestGetDatabaseMetadataWithTestcontainer(t *testing.T) {
ctx := context.Background()
// Start Oracle container
container := 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 features
testCases := []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 variable
t.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 metadata
compareMetadata(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
})
}
}