Skip to content

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

feat(mysql): parallelize testcontainer tests with shared container pattern (#18901)

Danny Xuc9cbab9e9491
diff --git a/backend/common/testcontainer/testcontainer.go b/backend/common/testcontainer/testcontainer.go
index c11f5076d9..f1a5b8953d 100644
--- a/backend/common/testcontainer/testcontainer.go
+++ b/backend/common/testcontainer/testcontainer.go
@@ -218,7 +218,8 @@ func GetOracleContainer(ctx context.Context) (retC *Container, retErr error) {
}
// Oracle connection string format: oracle://username:password@host:port/service_name
- dsn := fmt.Sprintf("oracle://testuser:testpass@%s:%s/FREEPDB1", host, port.Port())
+ // Use SYSTEM account for privileged operations (like creating users), similar to MySQL root
+ dsn := fmt.Sprintf("oracle://system:test123@%s:%s/FREEPDB1", host, port.Port())
db, err := sql.Open("oracle", dsn)
if err != nil {
return nil, err
diff --git a/backend/plugin/db/mysql/sync.go b/backend/plugin/db/mysql/sync.go
index e843f951c6..034d6f824f 100644
--- a/backend/plugin/db/mysql/sync.go
+++ b/backend/plugin/db/mysql/sync.go
@@ -397,7 +397,9 @@ func (d *Driver) SyncDBSchema(ctx context.Context) (*storepb.DatabaseSchemaMetad
cc.CONSTRAINT_NAME,
cc.CHECK_CLAUSE
FROM information_schema.CHECK_CONSTRAINTS cc
- JOIN information_schema.TABLE_CONSTRAINTS tc ON cc.CONSTRAINT_NAME = tc.CONSTRAINT_NAME
+ JOIN information_schema.TABLE_CONSTRAINTS tc
+ ON cc.CONSTRAINT_NAME = tc.CONSTRAINT_NAME
+ AND cc.CONSTRAINT_SCHEMA = tc.CONSTRAINT_SCHEMA
WHERE tc.CONSTRAINT_TYPE = 'CHECK' AND tc.TABLE_SCHEMA = ?
`
checkRows, err := d.db.QueryContext(ctx, checkQuery, d.databaseName)
diff --git a/backend/plugin/db/tidb/sync.go b/backend/plugin/db/tidb/sync.go
index 2a8851015b..6b317ac95a 100644
--- a/backend/plugin/db/tidb/sync.go
+++ b/backend/plugin/db/tidb/sync.go
@@ -326,6 +326,12 @@ func (d *Driver) SyncDBSchema(ctx context.Context) (*storepb.DatabaseSchemaMetad
return nil, err
}
+ // Query check constraint info.
+ checkMap, err := d.getCheckConstraintList(ctx, d.databaseName)
+ if err != nil {
+ return nil, err
+ }
+
// Query sequence info.
sequences, err := d.getSequenceList(ctx, d.databaseName)
if err != nil {
@@ -420,21 +426,22 @@ func (d *Driver) SyncDBSchema(ctx context.Context) (*storepb.DatabaseSchemaMetad
}
tableMetadata := &storepb.TableMetadata{
- Name: tableName,
- Columns: columns,
- ForeignKeys: foreignKeysMap[key],
- Engine: engine,
- Collation: collation,
- RowCount: rowCount,
- DataSize: dataSize,
- IndexSize: indexSize,
- DataFree: dataFree,
- CreateOptions: createOptions,
- Comment: comment,
- Charset: convertCollationToCharset(collation),
- Partitions: partitionTables[key],
- ShardingInfo: shardingInfo,
- PrimaryKeyType: pkType,
+ Name: tableName,
+ Columns: columns,
+ ForeignKeys: foreignKeysMap[key],
+ Engine: engine,
+ Collation: collation,
+ RowCount: rowCount,
+ DataSize: dataSize,
+ IndexSize: indexSize,
+ DataFree: dataFree,
+ CreateOptions: createOptions,
+ Comment: comment,
+ Charset: convertCollationToCharset(collation),
+ Partitions: partitionTables[key],
+ CheckConstraints: checkMap[key],
+ ShardingInfo: shardingInfo,
+ PrimaryKeyType: pkType,
}
if tableCollation.Valid {
tableMetadata.Collation = tableCollation.String
@@ -774,6 +781,45 @@ func (d *Driver) getForeignKeyList(ctx context.Context, databaseName string) (ma
return foreignKeysMap, nil
}
+func (d *Driver) getCheckConstraintList(ctx context.Context, databaseName string) (map[db.TableKey][]*storepb.CheckConstraintMetadata, error) {
+ checkQuery := `
+ SELECT
+ tc.TABLE_NAME,
+ cc.CONSTRAINT_NAME,
+ cc.CHECK_CLAUSE
+ FROM information_schema.CHECK_CONSTRAINTS cc
+ JOIN information_schema.TABLE_CONSTRAINTS tc
+ ON cc.CONSTRAINT_NAME = tc.CONSTRAINT_NAME
+ AND cc.CONSTRAINT_SCHEMA = tc.CONSTRAINT_SCHEMA
+ WHERE tc.CONSTRAINT_TYPE = 'CHECK' AND tc.TABLE_SCHEMA = ?
+ `
+ checkRows, err := d.db.QueryContext(ctx, checkQuery, databaseName)
+ if err != nil {
+ return nil, util.FormatErrorWithQuery(err, checkQuery)
+ }
+ defer checkRows.Close()
+
+ checkMap := make(map[db.TableKey][]*storepb.CheckConstraintMetadata)
+ for checkRows.Next() {
+ check := &storepb.CheckConstraintMetadata{}
+ var tableName string
+ if err := checkRows.Scan(
+ &tableName,
+ &check.Name,
+ &check.Expression,
+ ); err != nil {
+ return nil, err
+ }
+ key := db.TableKey{Schema: "", Table: tableName}
+ checkMap[key] = append(checkMap[key], check)
+ }
+ if err := checkRows.Err(); err != nil {
+ return nil, util.FormatErrorWithQuery(err, checkQuery)
+ }
+
+ return checkMap, nil
+}
+
func stripSingleQuote(s string) string {
if len(s) >= 2 && s[0] == '\'' && s[len(s)-1] == '\'' {
return s[1 : len(s)-1]
diff --git a/backend/plugin/schema/mssql/generate_migration_testcontainer_test.go b/backend/plugin/schema/mssql/generate_migration_testcontainer_test.go
index 0f99f8127f..95fa352ceb 100644
--- a/backend/plugin/schema/mssql/generate_migration_testcontainer_test.go
+++ b/backend/plugin/schema/mssql/generate_migration_testcontainer_test.go
@@ -4,23 +4,19 @@ import (
"context"
"fmt"
"slices"
- "strconv"
"strings"
"testing"
- "time"
// Import MSSQL driver
"github.com/google/go-cmp/cmp"
+ "github.com/google/uuid"
_ "github.com/microsoft/go-mssqldb"
"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"
- mssqldb "github.com/bytebase/bytebase/backend/plugin/db/mssql"
"github.com/bytebase/bytebase/backend/plugin/schema"
"github.com/bytebase/bytebase/backend/store/model"
)
@@ -36,35 +32,13 @@ func TestGenerateMigrationWithTestcontainer(t *testing.T) {
ctx := context.Background()
- // Start MSSQL container
- req := testcontainers.ContainerRequest{
- Image: "mcr.microsoft.com/mssql/server:2022-latest",
- Env: map[string]string{
- "ACCEPT_EULA": "Y",
- "SA_PASSWORD": "Test123!",
- "MSSQL_PID": "Express",
- },
- ExposedPorts: []string{"1433/tcp"},
- WaitingFor: wait.ForLog("SQL Server is now ready for client connections").
- WithStartupTimeout(3 * time.Minute),
- }
-
- container, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{
- ContainerRequest: req,
- Started: true,
- })
- require.NoError(t, err)
- t.Cleanup(func() {
- if err := container.Terminate(ctx); err != nil {
- t.Logf("failed to terminate container: %s", err)
- }
- })
+ // Start shared MSSQL container for all subtests
+ container := testcontainer.GetTestMSSQLContainer(ctx, t)
+ t.Cleanup(func() { container.Close(ctx) })
// Get connection details
- host, err := container.Host(ctx)
- require.NoError(t, err)
- port, err := container.MappedPort(ctx, "1433")
- require.NoError(t, err)
+ host := container.GetHost()
+ port := container.GetPort()
// Test cases with various schema changes
testCases := []struct {
@@ -2379,249 +2353,58 @@ GO
for _, testCase := range testCases {
t.Run(testCase.name, func(t *testing.T) {
t.Parallel()
- // Step 1: Execute 5-step workflow
- portInt, err := strconv.Atoi(port.Port())
- require.NoError(t, err)
- err = executeFiveStepWorkflow(ctx, host, portInt, testCase.name, testCase.initialSchema, testCase.migrationDDL)
- require.NoError(t, err, "Failed 5-step workflow for test case: %s", testCase.description)
- })
- }
-}
-
-// executeFiveStepWorkflow implements the 5-step workflow:
-// 1. Initialize database schema, get schema result A via syncDBSchema
-// 2. Apply migration DDL, get schema result B via syncDBSchema
-// 3. Generate rollback DDL via generate_migration
-// 4. Execute rollback DDL, get schema result C via syncDBSchema
-// 5. Compare schema results A and C to verify they are identical
-func executeFiveStepWorkflow(ctx context.Context, host string, port int, testName, initialSchema, migrationDDL string) error {
- // Create driver instance
- driverInstance := &mssqldb.Driver{}
-
- // Create connection config
- config := db.ConnectionConfig{
- DataSource: &storepb.DataSource{
- Type: storepb.DataSourceType_ADMIN,
- Username: "sa",
- Host: host,
- Port: strconv.Itoa(port),
- Database: "master",
- },
- Password: "Test123!",
- ConnectionContext: db.ConnectionContext{
- DatabaseName: "master",
- },
- }
-
- // Open connection
- driver, err := driverInstance.Open(ctx, storepb.Engine_MSSQL, config)
- if err != nil {
- return errors.Wrap(err, "failed to connect to MSSQL")
- }
- defer driver.Close(ctx)
-
- // Create test database with unique name based on test case
- testDB := fmt.Sprintf("test_%s_%d", strings.ReplaceAll(strings.ReplaceAll(testName, " ", "_"), "-", "_"), time.Now().UnixNano()%1000000)
- if _, err := driver.Execute(ctx, fmt.Sprintf("CREATE DATABASE [%s]", testDB), db.ExecuteOptions{CreateDatabase: true}); err != nil {
- return errors.Wrap(err, "failed to create test database")
- }
-
- // Reconnect to test database
- driver.Close(ctx)
- config.DataSource.Database = testDB
- config.ConnectionContext.DatabaseName = testDB
- driver, err = driverInstance.Open(ctx, storepb.Engine_MSSQL, config)
- if err != nil {
- return errors.Wrap(err, "failed to reconnect to test database")
- }
- defer driver.Close(ctx)
-
- // Step 1: Initialize database schema and get schema result A
- if err := executeSQL(ctx, driver, initialSchema); err != nil {
- return errors.Wrap(err, "failed to execute initial schema")
- }
-
- mssqlDriver, ok := driver.(*mssqldb.Driver)
- if !ok {
- return errors.New("failed to cast to mssqldb.Driver")
- }
-
- schemaA, err := mssqlDriver.SyncDBSchema(ctx)
- if err != nil {
- return errors.Wrap(err, "failed to sync schema A")
- }
-
- // Step 2: Apply migration DDL and get schema result B
- if err := executeSQL(ctx, driver, migrationDDL); err != nil {
- return errors.Wrap(err, "failed to execute migration DDL")
- }
-
- schemaB, err := mssqlDriver.SyncDBSchema(ctx)
- if err != nil {
- return errors.Wrap(err, "failed to sync schema B")
- }
-
- // Debug: Print what tables are in each schema
- fmt.Printf("Schema A contents:\n")
- for _, s := range schemaA.Schemas {
- fmt.Printf(" Schema [%s]: %d tables\n", s.Name, len(s.Tables))
- for _, t := range s.Tables {
- fmt.Printf(" - [%s].[%s]\n", s.Name, t.Name)
- }
- }
- fmt.Printf("Schema B contents:\n")
- for _, s := range schemaB.Schemas {
- fmt.Printf(" Schema [%s]: %d tables\n", s.Name, len(s.Tables))
- for _, t := range s.Tables {
- fmt.Printf(" - [%s].[%s]\n", s.Name, t.Name)
- }
- }
- // Step 3: Generate rollback DDL using generate_migration
- // Convert to model schemas for diff
- dbMetadataA := model.NewDatabaseMetadata(schemaA, nil, nil, storepb.Engine_MSSQL, false)
- dbMetadataB := model.NewDatabaseMetadata(schemaB, nil, nil, storepb.Engine_MSSQL, false)
+ // Create test database with unique name
+ testDB := fmt.Sprintf("test_%s", strings.ReplaceAll(uuid.New().String(), "-", "_"))
+ _, err := container.GetDB().Exec(fmt.Sprintf("CREATE DATABASE [%s]", testDB))
+ require.NoError(t, err, "failed to create test database")
- // Get diff from B to A (to generate rollback)
- diff, err := schema.GetDatabaseSchemaDiff(storepb.Engine_MSSQL, dbMetadataB, dbMetadataA)
- if err != nil {
- return errors.Wrap(err, "failed to generate diff")
- }
-
- // Debug: Print what changes are detected
- fmt.Printf("Schema changes detected:\n")
- fmt.Printf("- Table changes: %d\n", len(diff.TableChanges))
- for i, tc := range diff.TableChanges {
- fmt.Printf(" %d. %s [%s].[%s]\n", i+1, tc.Action, tc.SchemaName, tc.TableName)
- }
- fmt.Printf("- Schema changes: %d\n", len(diff.SchemaChanges))
- for i, sc := range diff.SchemaChanges {
- fmt.Printf(" %d. %s [%s]\n", i+1, sc.Action, sc.SchemaName)
- }
-
- rollbackDDL, err := schema.GenerateMigration(storepb.Engine_MSSQL, diff)
- if err != nil {
- return errors.Wrap(err, "failed to generate rollback migration")
- }
-
- // Debug: Print the generated rollback DDL
- fmt.Printf("Generated rollback DDL:\n%s\n", rollbackDDL)
-
- // Only proceed if there's actual rollback DDL to execute
- if strings.TrimSpace(rollbackDDL) == "" {
- // No rollback needed, schemas should already be identical
- return nil
- }
-
- // Step 4: Execute rollback DDL and get schema result C
- if err := executeSQL(ctx, driver, rollbackDDL); err != nil {
- return errors.Wrapf(err, "failed to execute rollback DDL: %s", rollbackDDL)
- }
-
- schemaC, err := mssqlDriver.SyncDBSchema(ctx)
- if err != nil {
- return errors.Wrap(err, "failed to sync schema C")
- }
-
- // Step 5: Compare schema results A and C
- if err := compareSchemas(schemaA, schemaC); err != nil {
- return errors.Wrap(err, "schema comparison failed")
- }
-
- return nil
-}
+ // Connect to test database
+ driver, err := createMSSQLDriver(ctx, host, port, testDB)
+ require.NoError(t, err, "failed to connect to test database")
+ defer driver.Close(ctx)
-// executeSQL executes SQL statements, handling GO separators
-func executeSQL(ctx context.Context, driver db.Driver, sql string) error {
- if strings.TrimSpace(sql) == "" {
- return nil
- }
+ // Step 1: Initialize database schema and get schema result A
+ err = executeSQL(ctx, driver, testCase.initialSchema)
+ require.NoError(t, err, "failed to execute initial schema")
- // Split by GO statements (case insensitive)
- statements := splitByGO(sql)
+ schemaA, err := driver.SyncDBSchema(ctx)
+ require.NoError(t, err, "failed to sync schema A")
- for i, stmt := range statements {
- stmt = strings.TrimSpace(stmt)
- if stmt == "" {
- continue
- }
+ // Step 2: Apply migration DDL and get schema result B
+ err = executeSQL(ctx, driver, testCase.migrationDDL)
+ require.NoError(t, err, "failed to execute migration DDL")
- if _, err := driver.Execute(ctx, stmt, db.ExecuteOptions{}); err != nil {
- return errors.Wrapf(err, "failed to execute statement %d: %s", i+1, stmt)
- }
- }
+ schemaB, err := driver.SyncDBSchema(ctx)
+ require.NoError(t, err, "failed to sync schema B")
- return nil
-}
+ // Step 3: Generate rollback DDL using generate_migration
+ // Convert to model schemas for diff
+ dbMetadataA := model.NewDatabaseMetadata(schemaA, nil, nil, storepb.Engine_MSSQL, false)
+ dbMetadataB := model.NewDatabaseMetadata(schemaB, nil, nil, storepb.Engine_MSSQL, false)
-// splitByGO splits SQL by GO statements (case insensitive) or by semicolons if no GO statements
-func splitByGO(sql string) []string {
- sql = strings.TrimSpace(sql)
- if sql == "" {
- return []string{}
- }
+ // Get diff from B to A (to generate rollback)
+ diff, err := schema.GetDatabaseSchemaDiff(storepb.Engine_MSSQL, dbMetadataB, dbMetadataA)
+ require.NoError(t, err, "failed to generate diff")
- // First check if there are any GO statements
- hasGOStatements := false
- lines := strings.Split(sql, "\n")
- for _, line := range lines {
- trimmed := strings.TrimSpace(line)
- if strings.EqualFold(trimmed, "GO") {
- hasGOStatements = true
- break
- }
- }
+ rollbackDDL, err := schema.GenerateMigration(storepb.Engine_MSSQL, diff)
+ require.NoError(t, err, "failed to generate rollback migration")
- if hasGOStatements {
- // Split by GO statements
- var statements []string
- var currentStatement strings.Builder
-
- for _, line := range lines {
- trimmed := strings.TrimSpace(line)
- if strings.EqualFold(trimmed, "GO") {
- if currentStatement.Len() > 0 {
- statements = append(statements, currentStatement.String())
- currentStatement.Reset()
- }
- } else {
- if currentStatement.Len() > 0 {
- currentStatement.WriteString("\n")
- }
- currentStatement.WriteString(line)
- }
- }
+ // Only proceed if there's actual rollback DDL to execute
+ if strings.TrimSpace(rollbackDDL) != "" {
+ // Step 4: Execute rollback DDL and get schema result C
+ err = executeSQL(ctx, driver, rollbackDDL)
+ require.NoError(t, err, "failed to execute rollback DDL: %s", rollbackDDL)
- if currentStatement.Len() > 0 {
- statements = append(statements, currentStatement.String())
- }
+ schemaC, err := driver.SyncDBSchema(ctx)
+ require.NoError(t, err, "failed to sync schema C")
- return statements
- }
- // Split by semicolons for DDL statements
- statements := strings.Split(sql, ";")
- var result []string
- for _, stmt := range statements {
- stmt = strings.TrimSpace(stmt)
- if stmt != "" {
- // Check if this statement contains any non-comment SQL
- lines := strings.Split(stmt, "\n")
- hasSQL := false
- var sqlLines []string
- for _, line := range lines {
- line = strings.TrimSpace(line)
- if line != "" && !strings.HasPrefix(line, "--") {
- hasSQL = true
- sqlLines = append(sqlLines, line)
- }
- }
- // Only include if there's actual SQL (not just comments)
- if hasSQL {
- result = append(result, strings.Join(sqlLines, " "))
+ // Step 5: Compare schema results A and C
+ err = compareSchemas(schemaA, schemaC)
+ require.NoError(t, err, "schema comparison failed for test case: %s", testCase.description)
}
- }
+ })
}
- return result
}
// compareSchemas compares two database schemas and returns an error if they differ
diff --git a/backend/plugin/schema/mssql/get_database_definition_testcontainer_test.go b/backend/plugin/schema/mssql/get_database_definition_testcontainer_test.go
index 728e8c99b8..1917b92742 100644
--- a/backend/plugin/schema/mssql/get_database_definition_testcontainer_test.go
+++ b/backend/plugin/schema/mssql/get_database_definition_testcontainer_test.go
@@ -3,18 +3,14 @@ package mssql
import (
"context"
"fmt"
- "strconv"
"strings"
"testing"
_ "github.com/microsoft/go-mssqldb"
- "github.com/pkg/errors"
"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"
- mssqldb "github.com/bytebase/bytebase/backend/plugin/db/mssql"
"github.com/bytebase/bytebase/backend/plugin/schema"
)
@@ -26,8 +22,6 @@ func TestGetDatabaseDefinitionWithTestcontainer(t *testing.T) {
host := container.GetHost()
port := container.GetPort()
- portInt, err := strconv.Atoi(port)
- require.NoError(t, err)
testCases := []struct {
name string
@@ -408,46 +402,20 @@ GO
// Use test name for database name - each test case has a unique name
databaseName := fmt.Sprintf("test_%s", strings.ReplaceAll(tc.name, " ", "_"))
- // Create a new driver instance for this test
- driverInstance := &mssqldb.Driver{}
- config := db.ConnectionConfig{
- DataSource: &storepb.DataSource{
- Type: storepb.DataSourceType_ADMIN,
- Username: "sa",
- Host: host,
- Port: strconv.Itoa(portInt),
- Database: "master",
- },
- Password: "Test123!",
- ConnectionContext: db.ConnectionContext{
- DatabaseName: "master",
- },
- }
-
- // Open connection
- driver, err := driverInstance.Open(ctx, storepb.Engine_MSSQL, config)
+ // Create test database using container's master connection
+ _, err := container.GetDB().Exec(fmt.Sprintf("CREATE DATABASE [%s]", databaseName))
require.NoError(t, err)
- // Create test database
- _, err = driver.Execute(ctx, fmt.Sprintf("CREATE DATABASE [%s]", databaseName), db.ExecuteOptions{CreateDatabase: true})
- require.NoError(t, err)
-
- // Reconnect to test database
- driver.Close(ctx)
- config.DataSource.Database = databaseName
- config.ConnectionContext.DatabaseName = databaseName
- testDriver, err := driverInstance.Open(ctx, storepb.Engine_MSSQL, config)
+ // Connect to test database
+ testDriver, err := createMSSQLDriver(ctx, host, port, databaseName)
require.NoError(t, err)
defer testDriver.Close(ctx)
// Step 1: Initialize database schema and get metadata A
- err = executeSQLStatements(ctx, testDriver, tc.setupSQL)
+ err = executeSQL(ctx, testDriver, tc.setupSQL)
require.NoError(t, err)
- mssqlTestDriver, ok := testDriver.(*mssqldb.Driver)
- require.True(t, ok, "failed to cast to mssqldb.Driver")
-
- metadataA, err := mssqlTestDriver.SyncDBSchema(ctx)
+ metadataA, err := testDriver.SyncDBSchema(ctx)
require.NoError(t, err)
// Step 2: Call GetDatabaseDefinition to generate database definition X
@@ -458,33 +426,21 @@ GO
// Step 3: Create a new database and run the definition X
newDatabaseName := fmt.Sprintf("test_copy_%s", strings.ReplaceAll(tc.name, " ", "_"))
- // Reconnect to master to create new database
- testDriver.Close(ctx)
- config.DataSource.Database = "master"
- config.ConnectionContext.DatabaseName = "master"
- masterDriver, err := driverInstance.Open(ctx, storepb.Engine_MSSQL, config)
- require.NoError(t, err)
-
- _, err = masterDriver.Execute(ctx, fmt.Sprintf("CREATE DATABASE [%s]", newDatabaseName), db.ExecuteOptions{CreateDatabase: true})
+ // Create new database using container's master connection
+ _, err = container.GetDB().Exec(fmt.Sprintf("CREATE DATABASE [%s]", newDatabaseName))
require.NoError(t, err)
// Connect to the new database
- masterDriver.Close(ctx)
- config.DataSource.Database = newDatabaseName
- config.ConnectionContext.DatabaseName = newDatabaseName
- newDriver, err := driverInstance.Open(ctx, storepb.Engine_MSSQL, config)
+ newDriver, err := createMSSQLDriver(ctx, host, port, newDatabaseName)
require.NoError(t, err)
defer newDriver.Close(ctx)
// Execute the generated definition
- err = executeSQLStatements(ctx, newDriver, definitionX)
+ err = executeSQL(ctx, newDriver, definitionX)
require.NoError(t, err)
- mssqlNewDriver, ok := newDriver.(*mssqldb.Driver)
- require.True(t, ok, "failed to cast to mssqldb.Driver")
-
// Get metadata B
- metadataB, err := mssqlNewDriver.SyncDBSchema(ctx)
+ metadataB, err := newDriver.SyncDBSchema(ctx)
require.NoError(t, err)
// Step 4: Compare metadata A and B
@@ -593,42 +549,3 @@ GO
})
}
}
-
-func executeSQLStatements(ctx context.Context, driver db.Driver, sqlScript string) error {
- statements := splitSQLByGO(sqlScript)
- for _, stmt := range statements {
- stmt = strings.TrimSpace(stmt)
- if stmt == "" {
- continue
- }
- if _, err := driver.Execute(ctx, stmt, db.ExecuteOptions{}); err != nil {
- return errors.Wrapf(err, "failed to execute statement: %s", stmt)
- }
- }
- return nil
-}
-
-func splitSQLByGO(script string) []string {
- var statements []string
- lines := strings.Split(script, "\n")
- var currentStatement strings.Builder
-
- for _, line := range lines {
- trimmedLine := strings.TrimSpace(line)
- if strings.EqualFold(trimmedLine, "GO") {
- if currentStatement.Len() > 0 {
- statements = append(statements, currentStatement.String())
- currentStatement.Reset()
- }
- } else {
- currentStatement.WriteString(line)
- currentStatement.WriteString("\n")
- }
- }
-
- if currentStatement.Len() > 0 {
- statements = append(statements, currentStatement.String())
- }
-
- return statements
-}
diff --git a/backend/plugin/schema/mssql/get_database_metadata_testcontainer_test.go b/backend/plugin/schema/mssql/get_database_metadata_testcontainer_test.go
index 4ca496a225..7fe866f560 100644
--- a/backend/plugin/schema/mssql/get_database_metadata_testcontainer_test.go
+++ b/backend/plugin/schema/mssql/get_database_metadata_testcontainer_test.go
@@ -3,7 +3,6 @@ package mssql
import (
"context"
"fmt"
- "strconv"
"strings"
"testing"
@@ -12,8 +11,6 @@ import (
"github.com/bytebase/bytebase/backend/common/testcontainer"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
- "github.com/bytebase/bytebase/backend/plugin/db"
- mssqldb "github.com/bytebase/bytebase/backend/plugin/db/mssql"
)
//nolint:tparallel
@@ -24,8 +21,6 @@ func TestGetDatabaseMetadataWithTestcontainer(t *testing.T) {
host := container.GetHost()
port := container.GetPort()
- portInt, err := strconv.Atoi(port)
- require.NoError(t, err)
testCases := []struct {
name string
@@ -656,55 +651,21 @@ GO
t.Parallel() // Safe to parallelize - shared container, unique databases per test
databaseName := fmt.Sprintf("test_%s", strings.ReplaceAll(tc.name, " ", "_"))
- // Create driver instance
- driverInstance := &mssqldb.Driver{}
- config := db.ConnectionConfig{
- DataSource: &storepb.DataSource{
- Type: storepb.DataSourceType_ADMIN,
- Username: "sa",
- Host: host,
- Port: strconv.Itoa(portInt),
- Database: "master",
- },
- Password: "Test123!",
- ConnectionContext: db.ConnectionContext{
- DatabaseName: "master",
- },
- }
-
- // Open connection
- driver, err := driverInstance.Open(ctx, storepb.Engine_MSSQL, config)
- require.NoError(t, err)
- defer driver.Close(ctx)
-
- // Create test database
- _, err = driver.Execute(ctx, fmt.Sprintf("CREATE DATABASE [%s]", databaseName), db.ExecuteOptions{CreateDatabase: true})
+ // Create test database using container's master connection
+ _, err := container.GetDB().Exec(fmt.Sprintf("CREATE DATABASE [%s]", databaseName))
require.NoError(t, err)
// Connect to the test database
- driver.Close(ctx)
- config.DataSource.Database = databaseName
- config.ConnectionContext.DatabaseName = databaseName
- driver, err = driverInstance.Open(ctx, storepb.Engine_MSSQL, config)
+ driver, err := createMSSQLDriver(ctx, host, port, databaseName)
require.NoError(t, err)
+ defer driver.Close(ctx)
// Execute setup SQL
- statements := splitSQLStatements(tc.setupSQL)
- for _, stmt := range statements {
- stmt = strings.TrimSpace(stmt)
- if stmt == "" {
- continue
- }
- _, err = driver.Execute(ctx, stmt, db.ExecuteOptions{})
- require.NoError(t, err)
- }
-
- // Get metadata using parser
- mssqlDriver, ok := driver.(*mssqldb.Driver)
- require.True(t, ok)
+ err = executeSQL(ctx, driver, tc.setupSQL)
+ require.NoError(t, err)
// Sync database schema to get full metadata
- metadata, err := mssqlDriver.SyncDBSchema(ctx)
+ metadata, err := driver.SyncDBSchema(ctx)
require.NoError(t, err)
// Validate the metadata
@@ -712,28 +673,3 @@ GO
})
}
}
-
-func splitSQLStatements(script string) []string {
- var statements []string
- lines := strings.Split(script, "\n")
- var currentStatement strings.Builder
-
- for _, line := range lines {
- trimmedLine := strings.TrimSpace(line)
- if strings.EqualFold(trimmedLine, "GO") {
- if currentStatement.Len() > 0 {
- statements = append(statements, currentStatement.String())
- currentStatement.Reset()
- }
- } else {
- currentStatement.WriteString(line)
- currentStatement.WriteString("\n")
- }
- }
-
- if currentStatement.Len() > 0 {
- statements = append(statements, currentStatement.String())
- }
-
- return statements
-}
diff --git a/backend/plugin/schema/mssql/testutil_test.go b/backend/plugin/schema/mssql/testutil_test.go
new file mode 100644
index 0000000000..129069378c
--- /dev/null
+++ b/backend/plugin/schema/mssql/testutil_test.go
@@ -0,0 +1,124 @@
+package mssql
+
+import (
+ "context"
+ "strings"
+
+ "github.com/pkg/errors"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/db"
+ mssqldb "github.com/bytebase/bytebase/backend/plugin/db/mssql"
+)
+
+// createMSSQLDriver creates and opens a MSSQL driver connection
+func createMSSQLDriver(ctx context.Context, host, port, database string) (db.Driver, error) {
+ driver := &mssqldb.Driver{}
+ config := db.ConnectionConfig{
+ DataSource: &storepb.DataSource{
+ Type: storepb.DataSourceType_ADMIN,
+ Username: "sa",
+ Host: host,
+ Port: port,
+ Database: database,
+ },
+ Password: "Test123!",
+ ConnectionContext: db.ConnectionContext{
+ DatabaseName: database,
+ },
+ }
+ return driver.Open(ctx, storepb.Engine_MSSQL, config)
+}
+
+// executeSQL executes SQL statements, handling GO separators
+func executeSQL(ctx context.Context, driver db.Driver, sql string) error {
+ if strings.TrimSpace(sql) == "" {
+ return nil
+ }
+
+ // Split by GO statements (case insensitive)
+ statements := splitByGO(sql)
+
+ for i, stmt := range statements {
+ stmt = strings.TrimSpace(stmt)
+ if stmt == "" {
+ continue
+ }
+
+ if _, err := driver.Execute(ctx, stmt, db.ExecuteOptions{}); err != nil {
+ return errors.Wrapf(err, "failed to execute statement %d: %s", i+1, stmt)
+ }
+ }
+
+ return nil
+}
+
+// splitByGO splits SQL by GO statements (case insensitive) or by semicolons if no GO statements
+func splitByGO(sql string) []string {
+ sql = strings.TrimSpace(sql)
+ if sql == "" {
+ return []string{}
+ }
+
+ // First check if there are any GO statements
+ hasGOStatements := false
+ lines := strings.Split(sql, "\n")
+ for _, line := range lines {
+ trimmed := strings.TrimSpace(line)
+ if strings.EqualFold(trimmed, "GO") {
+ hasGOStatements = true
+ break
+ }
+ }
+
+ if hasGOStatements {
+ // Split by GO statements
+ var statements []string
+ var currentStatement strings.Builder
+
+ for _, line := range lines {
+ trimmed := strings.TrimSpace(line)
+ if strings.EqualFold(trimmed, "GO") {
+ if currentStatement.Len() > 0 {
+ statements = append(statements, currentStatement.String())
+ currentStatement.Reset()
+ }
+ } else {
+ if currentStatement.Len() > 0 {
+ currentStatement.WriteString("\n")
+ }
+ currentStatement.WriteString(line)
+ }
+ }
+
+ if currentStatement.Len() > 0 {
+ statements = append(statements, currentStatement.String())
+ }
+
+ return statements
+ }
+ // Split by semicolons for DDL statements
+ statements := strings.Split(sql, ";")
+ var result []string
+ for _, stmt := range statements {
+ stmt = strings.TrimSpace(stmt)
+ if stmt != "" {
+ // Check if this statement contains any non-comment SQL
+ lines := strings.Split(stmt, "\n")
+ hasSQL := false
+ var sqlLines []string
+ for _, line := range lines {
+ line = strings.TrimSpace(line)
+ if line != "" && !strings.HasPrefix(line, "--") {
+ hasSQL = true
+ sqlLines = append(sqlLines, line)
+ }
+ }
+ // Only include if there's actual SQL (not just comments)
+ if hasSQL {
+ result = append(result, strings.Join(sqlLines, " "))
+ }
+ }
+ }
+ return result
+}
diff --git a/backend/plugin/schema/mysql/generate_migration_testcontainer_test.go b/backend/plugin/schema/mysql/generate_migration_testcontainer_test.go
index adebcf1a16..99cd3892f0 100644
--- a/backend/plugin/schema/mysql/generate_migration_testcontainer_test.go
+++ b/backend/plugin/schema/mysql/generate_migration_testcontainer_test.go
@@ -2,10 +2,8 @@ package mysql
import (
"context"
- "database/sql"
"fmt"
"slices"
- "strconv"
"strings"
"testing"
@@ -13,20 +11,20 @@ import (
_ "github.com/go-sql-driver/mysql"
"github.com/google/go-cmp/cmp"
"github.com/google/uuid"
- "github.com/pkg/errors"
"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"
- mysqldb "github.com/bytebase/bytebase/backend/plugin/db/mysql"
"github.com/bytebase/bytebase/backend/plugin/schema"
"github.com/bytebase/bytebase/backend/store/model"
)
// 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 MySQL testcontainer test in short mode")
@@ -34,10 +32,10 @@ func TestGenerateMigrationWithTestcontainer(t *testing.T) {
ctx := context.Background()
- // Start MySQL container using common testcontainer interface
+ // Start shared MySQL container for all subtests
container, err := testcontainer.GetTestMySQLContainer(ctx)
require.NoError(t, err)
- defer container.Close(ctx)
+ t.Cleanup(func() { container.Close(ctx) })
// Get connection details
host := container.GetHost()
@@ -1637,44 +1635,35 @@ CREATE TABLE some_table (
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
- // Step 1: Initialize the database schema and get schema result A
- portInt, err := strconv.Atoi(port)
- require.NoError(t, err)
-
- // Get the database connection from container
- db := container.GetDB()
+ t.Parallel()
- // Create a test database
+ // Step 1: Initialize the database schema and get schema result A
+ // Create a unique test database for parallel execution
testDBName := fmt.Sprintf("test_%s", strings.ReplaceAll(uuid.New().String(), "-", "_"))
- _, err = db.Exec(fmt.Sprintf("DROP DATABASE IF EXISTS `%s`", testDBName))
- require.NoError(t, err)
- _, err = db.Exec(fmt.Sprintf("CREATE DATABASE `%s`", testDBName))
+ _, err = container.GetDB().Exec(fmt.Sprintf("CREATE DATABASE `%s`", testDBName))
require.NoError(t, err)
- defer func() {
- _, _ = db.Exec("USE mysql")
- _, _ = db.Exec(fmt.Sprintf("DROP DATABASE IF EXISTS `%s`", testDBName))
- }()
- // Use the test database
- _, err = db.Exec(fmt.Sprintf("USE `%s`", testDBName))
+ // Create MySQL driver for this test's database
+ driver, err := createMySQLDriver(ctx, host, port, testDBName)
require.NoError(t, err)
+ defer driver.Close(ctx)
// Execute initial schema
if strings.TrimSpace(tc.initialSchema) != "" {
- if err := executeStatements(db, tc.initialSchema); err != nil {
+ if _, err := driver.Execute(ctx, tc.initialSchema, db.ExecuteOptions{}); err != nil {
t.Fatalf("Failed to execute initial schema: %v", err)
}
}
- schemaA, err := getSyncMetadataForGenerateMigration(ctx, host, portInt, "root", "root-password", testDBName)
+ schemaA, err := driver.SyncDBSchema(ctx)
require.NoError(t, err)
// Step 2: Do some migration and get schema result B
- if err := executeStatements(db, tc.migrationDDL); err != nil {
+ if _, err := driver.Execute(ctx, tc.migrationDDL, db.ExecuteOptions{}); err != nil {
t.Fatalf("Failed to execute migration DDL: %v", err)
}
- schemaB, err := getSyncMetadataForGenerateMigration(ctx, host, portInt, "root", "root-password", testDBName)
+ schemaB, err := driver.SyncDBSchema(ctx)
require.NoError(t, err)
// Step 3: Call generate migration to get the rollback DDL
@@ -1717,11 +1706,11 @@ CREATE TABLE some_table (
}
// Step 4: Run rollback DDL and get schema result C
- if err := executeStatements(db, rollbackDDL); err != nil {
+ if _, err := driver.Execute(ctx, rollbackDDL, db.ExecuteOptions{}); err != nil {
t.Fatalf("Failed to execute rollback DDL: %v", err)
}
- schemaC, err := getSyncMetadataForGenerateMigration(ctx, host, portInt, "root", "root-password", testDBName)
+ schemaC, err := driver.SyncDBSchema(ctx)
require.NoError(t, err)
// Step 5: Compare schema result A and C to ensure they are the same
@@ -1736,57 +1725,6 @@ CREATE TABLE some_table (
}
}
-// executeStatements executes multiple SQL statements
-func executeStatements(db *sql.DB, statements string) error {
- // MySQL driver supports multi-statement execution natively
- if _, err := db.Exec(statements); err != nil {
- return errors.Wrapf(err, "failed to execute statements")
- }
- return nil
-}
-
-// getSyncMetadataForGenerateMigration retrieves metadata from the live database using Driver.SyncDBSchema
-func getSyncMetadataForGenerateMigration(ctx context.Context, host string, port int, username, password, database string) (*storepb.DatabaseSchemaMetadata, error) {
- // Create a driver instance using the mysql package
- driver := &mysqldb.Driver{}
-
- // Create connection config
- config := db.ConnectionConfig{
- DataSource: &storepb.DataSource{
- Type: storepb.DataSourceType_ADMIN,
- Username: username,
- Host: host,
- Port: fmt.Sprintf("%d", port),
- Database: database,
- },
- Password: password,
- ConnectionContext: db.ConnectionContext{
- EngineVersion: "8.0",
- DatabaseName: database,
- },
- }
-
- // Open connection using the driver
- openedDriver, err := driver.Open(ctx, storepb.Engine_MYSQL, config)
- if err != nil {
- return nil, err
- }
- defer openedDriver.Close(ctx)
-
- // Use SyncDBSchema to get the metadata
- mysqlDriver, ok := openedDriver.(*mysqldb.Driver)
- if !ok {
- return nil, errors.New("failed to cast to mysql.Driver")
- }
-
- metadata, err := mysqlDriver.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/mysql/get_database_definition_testcontainer_test.go b/backend/plugin/schema/mysql/get_database_definition_testcontainer_test.go
index 097fefebc7..84d25a3cdd 100644
--- a/backend/plugin/schema/mysql/get_database_definition_testcontainer_test.go
+++ b/backend/plugin/schema/mysql/get_database_definition_testcontainer_test.go
@@ -2,38 +2,47 @@ package mysql
import (
"context"
- "errors"
"fmt"
+ "strings"
"testing"
- "time"
// Import MySQL driver
_ "github.com/go-sql-driver/mysql"
"github.com/google/go-cmp/cmp"
+ "github.com/google/uuid"
"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"
- mysqldb "github.com/bytebase/bytebase/backend/plugin/db/mysql"
"github.com/bytebase/bytebase/backend/plugin/schema"
)
+//nolint:tparallel
func TestGetDatabaseDefinition(t *testing.T) {
if testing.Short() {
t.Skip("Skipping MySQL testcontainer test in short mode")
}
+
+ ctx := context.Background()
+
+ // Start shared MySQL container for all subtests
+ container, err := testcontainer.GetTestMySQLContainer(ctx)
+ require.NoError(t, err)
+ t.Cleanup(func() { container.Close(ctx) })
+
+ host := container.GetHost()
+ port := container.GetPort()
+
type testCase struct {
- description string
- databaseName string
- originalDDL string
+ description string
+ originalDDL string
}
testCases := []testCase{
{
- description: "Basic tables with various column types",
- databaseName: "test_basic",
+ description: "Basic tables with various column types",
originalDDL: `
CREATE TABLE users (
id INT PRIMARY KEY AUTO_INCREMENT,
@@ -60,8 +69,7 @@ CREATE TABLE posts (
`,
},
{
- description: "Generated columns and complex indexes",
- databaseName: "test_generated",
+ description: "Generated columns and complex indexes",
originalDDL: `
CREATE TABLE products (
id INT PRIMARY KEY AUTO_INCREMENT,
@@ -86,8 +94,7 @@ CREATE TABLE inventory (
`,
},
{
- description: "Views and triggers",
- databaseName: "test_views_triggers",
+ description: "Views and triggers",
originalDDL: `
CREATE TABLE orders (
id INT PRIMARY KEY AUTO_INCREMENT,
@@ -125,8 +132,7 @@ END;
`,
},
{
- description: "Stored procedures and functions",
- databaseName: "test_routines",
+ description: "Stored procedures and functions",
originalDDL: `
CREATE TABLE accounts (
id INT PRIMARY KEY AUTO_INCREMENT,
@@ -181,8 +187,7 @@ DELIMITER ;
`,
},
{
- description: "Partitioned tables",
- databaseName: "test_partitions",
+ description: "Partitioned tables",
originalDDL: `
-- RANGE partition
CREATE TABLE sales (
@@ -250,8 +255,7 @@ CREATE TABLE order_archive (
`,
},
{
- description: "Events",
- databaseName: "test_events",
+ description: "Events",
originalDDL: `
CREATE TABLE daily_stats (
id INT PRIMARY KEY AUTO_INCREMENT,
@@ -273,8 +277,7 @@ DO
`,
},
{
- description: "Character sets and collations",
- databaseName: "test_charset",
+ description: "Character sets and collations",
originalDDL: `
CREATE TABLE translations (
id INT PRIMARY KEY AUTO_INCREMENT,
@@ -287,28 +290,27 @@ CREATE TABLE translations (
},
}
- if testing.Short() {
- t.Skip("Skipping MySQL testcontainer test in short mode")
- }
-
- ctx := context.Background()
-
for _, tc := range testCases {
t.Run(tc.description, func(t *testing.T) {
- // Start MySQL container
- container, err := testcontainer.GetTestMySQLContainer(ctx)
+ t.Parallel()
+
+ // Create unique test databases for parallel execution
+ testDBName := fmt.Sprintf("test_%s", strings.ReplaceAll(uuid.New().String(), "-", "_"))
+ newDBName := fmt.Sprintf("test_%s", strings.ReplaceAll(uuid.New().String(), "-", "_"))
+
+ // Create initial test database
+ _, err := container.GetDB().Exec(fmt.Sprintf("CREATE DATABASE `%s`", testDBName))
require.NoError(t, err)
- defer container.Close(ctx)
- // Create test database
- _, err = container.GetDB().Exec(fmt.Sprintf("CREATE DATABASE IF NOT EXISTS `%s`", tc.databaseName))
+ // Step 1: Initialize the database schema and get metadata A
+ driverA, err := createMySQLDriver(ctx, host, port, testDBName)
require.NoError(t, err)
+ defer driverA.Close(ctx)
- host := container.GetHost()
- port := container.GetPort()
+ _, err = driverA.Execute(ctx, tc.originalDDL, db.ExecuteOptions{})
+ require.NoError(t, err)
- // Step 1: Initialize the database schema
- metadataA, err := initializeAndSyncDatabase(ctx, host, port, "root", "root-password", tc.databaseName, tc.originalDDL)
+ metadataA, err := driverA.SyncDBSchema(ctx)
require.NoError(t, err)
// Step 2: Call GetDatabaseDefinition to generate the database definition X
@@ -320,9 +322,18 @@ CREATE TABLE translations (
require.NoError(t, err)
require.NotEmpty(t, definitionX)
- // Step 3: Create a new database to run the database definition X
- newDBName := fmt.Sprintf("%s_recreated", tc.databaseName)
- metadataB, err := createDatabaseAndSync(ctx, host, port, "root", "root-password", tc.databaseName, newDBName, definitionX)
+ // Step 3: Create a new database and apply the generated DDL
+ _, err = container.GetDB().Exec(fmt.Sprintf("CREATE DATABASE `%s`", newDBName))
+ require.NoError(t, err)
+
+ driverB, err := createMySQLDriver(ctx, host, port, newDBName)
+ require.NoError(t, err)
+ defer driverB.Close(ctx)
+
+ _, err = driverB.Execute(ctx, definitionX, db.ExecuteOptions{})
+ require.NoError(t, err)
+
+ metadataB, err := driverB.SyncDBSchema(ctx)
require.NoError(t, err)
// Step 4: Compare the database metadata A and B, should be the same
@@ -439,7 +450,7 @@ CREATE TABLE project_member (
// Start MySQL container
container, err := testcontainer.GetTestMySQLContainer(ctx)
require.NoError(t, err)
- defer container.Close(ctx)
+ t.Cleanup(func() { container.Close(ctx) })
// Create test database
_, err = container.GetDB().Exec(fmt.Sprintf("CREATE DATABASE IF NOT EXISTS `%s`", databaseName))
@@ -449,7 +460,14 @@ CREATE TABLE project_member (
port := container.GetPort()
// Step 1: Initialize the database schema
- metadataA, err := initializeAndSyncDatabase(ctx, host, port, "root", "root-password", databaseName, originalDDL)
+ driverA, err := createMySQLDriver(ctx, host, port, databaseName)
+ require.NoError(t, err)
+ defer driverA.Close(ctx)
+
+ _, err = driverA.Execute(ctx, originalDDL, db.ExecuteOptions{})
+ require.NoError(t, err)
+
+ metadataA, err := driverA.SyncDBSchema(ctx)
require.NoError(t, err)
// Step 2: Generate definition
@@ -462,7 +480,17 @@ CREATE TABLE project_member (
// Step 3: Create new database and apply definition
newDBName := fmt.Sprintf("%s_recreated", databaseName)
- metadataB, err := createDatabaseAndSync(ctx, host, port, "root", "root-password", databaseName, newDBName, definitionX)
+ _, err = container.GetDB().Exec(fmt.Sprintf("CREATE DATABASE `%s`", newDBName))
+ require.NoError(t, err)
+
+ driverB, err := createMySQLDriver(ctx, host, port, newDBName)
+ require.NoError(t, err)
+ defer driverB.Close(ctx)
+
+ _, err = driverB.Execute(ctx, definitionX, db.ExecuteOptions{})
+ require.NoError(t, err)
+
+ metadataB, err := driverB.SyncDBSchema(ctx)
require.NoError(t, err)
// Compare
@@ -478,83 +506,3 @@ CREATE TABLE project_member (
t.Errorf("Metadata mismatch (-want +got):\n%s", diff)
}
}
-
-// initializeAndSyncDatabase creates a database connection, executes DDL, and returns the metadata
-func initializeAndSyncDatabase(ctx context.Context, host, port, username, password, database, ddl string) (*storepb.DatabaseSchemaMetadata, error) {
- // Create driver instance
- driver := &mysqldb.Driver{}
-
- // Create connection config
- config := db.ConnectionConfig{
- DataSource: &storepb.DataSource{
- Type: storepb.DataSourceType_ADMIN,
- Username: username,
- Host: host,
- Port: port,
- Database: database,
- },
- Password: password,
- ConnectionContext: db.ConnectionContext{
- EngineVersion: "8.0",
- DatabaseName: database,
- },
- }
-
- // Open connection
- openedDriver, err := driver.Open(ctx, storepb.Engine_MYSQL, config)
- if err != nil {
- return nil, err
- }
- defer openedDriver.Close(ctx)
-
- // Execute DDL
- _, err = openedDriver.Execute(ctx, ddl, db.ExecuteOptions{})
- if err != nil {
- return nil, err
- }
-
- // Wait for schema to be created
- time.Sleep(500 * time.Millisecond)
-
- // Sync metadata
- mysqlDriver, ok := openedDriver.(*mysqldb.Driver)
- if !ok {
- return nil, errors.New("failed to cast to mysql.Driver")
- }
-
- return mysqlDriver.SyncDBSchema(ctx)
-}
-
-// createDatabaseAndSync creates a new database, applies DDL, and returns the metadata
-func createDatabaseAndSync(ctx context.Context, host, port, username, password, sourceDB, targetDB, ddl string) (*storepb.DatabaseSchemaMetadata, error) {
- // First create the new database
- driver := &mysqldb.Driver{}
- config := db.ConnectionConfig{
- DataSource: &storepb.DataSource{
- Type: storepb.DataSourceType_ADMIN,
- Username: username,
- Host: host,
- Port: port,
- Database: sourceDB,
- },
- Password: password,
- ConnectionContext: db.ConnectionContext{
- EngineVersion: "8.0",
- DatabaseName: sourceDB,
- },
- }
-
- openedDriver, err := driver.Open(ctx, storepb.Engine_MYSQL, config)
- if err != nil {
- return nil, err
- }
-
- _, err = openedDriver.Execute(ctx, fmt.Sprintf("CREATE DATABASE `%s`", targetDB), db.ExecuteOptions{})
- openedDriver.Close(ctx)
- if err != nil {
- return nil, err
- }
-
- // Now connect to the new database and apply DDL
- return initializeAndSyncDatabase(ctx, host, port, username, password, targetDB, ddl)
-}
diff --git a/backend/plugin/schema/mysql/get_database_metadata_testcontainer_test.go b/backend/plugin/schema/mysql/get_database_metadata_testcontainer_test.go
index 354f402d06..93e4cc2e6f 100644
--- a/backend/plugin/schema/mysql/get_database_metadata_testcontainer_test.go
+++ b/backend/plugin/schema/mysql/get_database_metadata_testcontainer_test.go
@@ -2,61 +2,35 @@ package mysql
import (
"context"
+ "fmt"
"regexp"
"strings"
"testing"
_ "github.com/go-sql-driver/mysql"
+ "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"
- mysqldb "github.com/bytebase/bytebase/backend/plugin/db/mysql"
)
// TestGetDatabaseMetadataWithTestcontainer tests the get_database_metadata function
// by comparing its output with the metadata retrieved from a real MySQL instance.
+//
+//nolint:tparallel
func TestGetDatabaseMetadataWithTestcontainer(t *testing.T) {
ctx := context.Background()
- // Start MySQL container
+ // Start shared MySQL container for all subtests
container, err := testcontainer.GetTestMySQLContainer(ctx)
require.NoError(t, err)
- defer container.Close(ctx)
-
- // Create test database
- _, err = container.GetDB().Exec("CREATE DATABASE IF NOT EXISTS test_db")
- require.NoError(t, err)
+ t.Cleanup(func() { container.Close(ctx) })
host := container.GetHost()
port := container.GetPort()
- // Create MySQL driver for metadata sync
- driver := &mysqldb.Driver{}
- config := db.ConnectionConfig{
- DataSource: &storepb.DataSource{
- Type: storepb.DataSourceType_ADMIN,
- Username: "root",
- Host: host,
- Port: port,
- Database: "test_db",
- },
- Password: "root-password",
- ConnectionContext: db.ConnectionContext{
- EngineVersion: "8.0",
- DatabaseName: "test_db",
- },
- }
-
- openedDriver, err := driver.Open(ctx, storepb.Engine_MYSQL, config)
- require.NoError(t, err)
- defer openedDriver.Close(ctx)
-
- // Cast to MySQL driver for SyncDBSchema
- mysqlDriver, ok := openedDriver.(*mysqldb.Driver)
- require.True(t, ok, "failed to cast to mysql.Driver")
-
// Test cases with various MySQL features
testCases := []struct {
name string
@@ -540,18 +514,24 @@ CREATE TABLE json_features (
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
- // Create test database (drop first to avoid conflicts between test cases)
- _, err := container.GetDB().ExecContext(ctx, "DROP DATABASE IF EXISTS test_db")
+ t.Parallel()
+
+ // Create unique test database for parallel execution
+ testDBName := fmt.Sprintf("test_%s", strings.ReplaceAll(uuid.New().String(), "-", "_"))
+ _, err := container.GetDB().ExecContext(ctx, fmt.Sprintf("CREATE DATABASE `%s`", testDBName))
require.NoError(t, err)
- _, err = container.GetDB().ExecContext(ctx, "CREATE DATABASE test_db")
+
+ // Create MySQL driver for this test's database
+ driver, err := createMySQLDriver(ctx, host, port, testDBName)
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 := mysqlDriver.SyncDBSchema(ctx)
+ dbMetadata, err := driver.SyncDBSchema(ctx)
require.NoError(t, err)
// Get metadata from parser
diff --git a/backend/plugin/schema/mysql/testutil_test.go b/backend/plugin/schema/mysql/testutil_test.go
new file mode 100644
index 0000000000..f1b258b14c
--- /dev/null
+++ b/backend/plugin/schema/mysql/testutil_test.go
@@ -0,0 +1,30 @@
+package mysql
+
+import (
+ "context"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/db"
+ mysqldb "github.com/bytebase/bytebase/backend/plugin/db/mysql"
+)
+
+// createMySQLDriver creates and opens a MySQL driver for the specified database.
+// This is a shared helper function for tests.
+func createMySQLDriver(ctx context.Context, host, port, database string) (db.Driver, error) {
+ driver := &mysqldb.Driver{}
+ config := db.ConnectionConfig{
+ DataSource: &storepb.DataSource{
+ Type: storepb.DataSourceType_ADMIN,
+ Username: "root",
+ Host: host,
+ Port: port,
+ Database: database,
+ },
+ Password: "root-password",
+ ConnectionContext: db.ConnectionContext{
+ EngineVersion: "8.0",
+ DatabaseName: database,
+ },
+ }
+ return driver.Open(ctx, storepb.Engine_MYSQL, config)
+}
diff --git a/backend/plugin/schema/oracle/generate_migration_testcontainer_test.go b/backend/plugin/schema/oracle/generate_migration_testcontainer_test.go
index 14db89e01a..52521e7722 100644
--- a/backend/plugin/schema/oracle/generate_migration_testcontainer_test.go
+++ b/backend/plugin/schema/oracle/generate_migration_testcontainer_test.go
@@ -2,7 +2,6 @@ package oracle
import (
"context"
- "database/sql"
"fmt"
"slices"
"strings"
@@ -10,15 +9,11 @@ import (
"github.com/google/go-cmp/cmp"
"github.com/google/uuid"
- "github.com/pkg/errors"
"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"
- oracledb "github.com/bytebase/bytebase/backend/plugin/db/oracle"
- plsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/plsql"
"github.com/bytebase/bytebase/backend/plugin/schema"
"github.com/bytebase/bytebase/backend/store/model"
)
@@ -38,10 +33,8 @@ func TestGenerateMigrationWithTestcontainer(t *testing.T) {
container := testcontainer.GetTestOracleContainer(ctx, t)
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() })
+ // Get SYSTEM database connection for user management
+ systemDB := container.GetDB()
// Test cases with various schema changes
testCases := []struct {
@@ -1791,110 +1784,6 @@ COMMENT ON TABLE SPECIAL_DATA IS '';
}
}
-// 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
- }
- if err := db.Ping(); err != nil {
- return nil, err
- }
- return db, nil
-}
-
-// executeStatements executes multiple SQL statements, handling both regular DDL and PL/SQL blocks
-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 {
- return errors.Wrapf(err, "failed to split SQL statements")
- }
-
- // Execute each statement
- for _, singleSQL := range stmts {
- stmt := strings.TrimSpace(singleSQL.Text)
- if stmt == "" {
- continue
- }
-
- // Skip statements that contain only comments
- // Strip all comment lines and check if there's actual SQL
- lines := strings.Split(stmt, "\n")
- hasSQL := false
- for _, line := range lines {
- trimmed := strings.TrimSpace(line)
- if trimmed != "" && !strings.HasPrefix(trimmed, "--") {
- hasSQL = true
- break
- }
- }
- if !hasSQL {
- continue
- }
-
- // Execute the statement
- 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 := driver.Execute(ctx, fixedStmt, db.ExecuteOptions{}); retryErr == nil {
- continue // Successfully executed with corrected statement
- }
- }
- }
- // Handle system-generated virtual column indexes that cannot be manually created
- if strings.Contains(err.Error(), "invalid identifier") && strings.Contains(stmt, "SYS_NC") {
- // Skip statements that reference system-generated virtual columns
- continue
- }
- return errors.Wrapf(err, "failed to execute statement: %s", stmt)
- }
- }
-
- return 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_testcontainer_test.go b/backend/plugin/schema/oracle/get_database_definition_testcontainer_test.go
index 4f8e57e382..d428dabbe3 100644
--- a/backend/plugin/schema/oracle/get_database_definition_testcontainer_test.go
+++ b/backend/plugin/schema/oracle/get_database_definition_testcontainer_test.go
@@ -32,10 +32,8 @@ func TestGetDatabaseDefinitionWithTestcontainer(t *testing.T) {
container := testcontainer.GetTestOracleContainer(ctx, t)
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() })
+ // Get SYSTEM database connection for user management
+ systemDB := container.GetDB()
// Test cases with various schema configurations
testCases := []struct {
diff --git a/backend/plugin/schema/oracle/get_database_metadata_test.go b/backend/plugin/schema/oracle/get_database_metadata_test.go
index 0b4a764cb2..95a2df7942 100644
--- a/backend/plugin/schema/oracle/get_database_metadata_test.go
+++ b/backend/plugin/schema/oracle/get_database_metadata_test.go
@@ -28,10 +28,8 @@ func TestGetDatabaseMetadataWithTestcontainer(t *testing.T) {
host := container.GetHost()
port := container.GetPort()
- // Create shared SYSTEM database connection for user management
- systemDB, err := openSystemDatabase(host, port)
- require.NoError(t, err)
- t.Cleanup(func() { systemDB.Close() })
+ // Get SYSTEM database connection for user management
+ systemDB := container.GetDB()
// Test cases with various Oracle features
testCases := []struct {
diff --git a/backend/plugin/schema/oracle/testutil_test.go b/backend/plugin/schema/oracle/testutil_test.go
new file mode 100644
index 0000000000..0f3a303aa4
--- /dev/null
+++ b/backend/plugin/schema/oracle/testutil_test.go
@@ -0,0 +1,105 @@
+package oracle
+
+import (
+ "context"
+ "database/sql"
+ "fmt"
+ "strings"
+
+ "github.com/pkg/errors"
+
+ 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"
+ plsqlparser "github.com/bytebase/bytebase/backend/plugin/parser/plsql"
+)
+
+// 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)
+}
+
+// executeStatements executes multiple SQL statements, handling both regular DDL and PL/SQL blocks
+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 {
+ return errors.Wrapf(err, "failed to split SQL statements")
+ }
+
+ // Execute each statement
+ for _, singleSQL := range stmts {
+ stmt := strings.TrimSpace(singleSQL.Text)
+ if stmt == "" {
+ continue
+ }
+
+ // Skip statements that contain only comments
+ // Strip all comment lines and check if there's actual SQL
+ lines := strings.Split(stmt, "\n")
+ hasSQL := false
+ for _, line := range lines {
+ trimmed := strings.TrimSpace(line)
+ if trimmed != "" && !strings.HasPrefix(trimmed, "--") {
+ hasSQL = true
+ break
+ }
+ }
+ if !hasSQL {
+ continue
+ }
+
+ // Execute the statement
+ 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 := driver.Execute(ctx, fixedStmt, db.ExecuteOptions{}); retryErr == nil {
+ continue // Successfully executed with corrected statement
+ }
+ }
+ }
+ // Handle system-generated virtual column indexes that cannot be manually created
+ if strings.Contains(err.Error(), "invalid identifier") && strings.Contains(stmt, "SYS_NC") {
+ // Skip statements that reference system-generated virtual columns
+ continue
+ }
+ return errors.Wrapf(err, "failed to execute statement: %s", stmt)
+ }
+ }
+
+ return nil
+}
diff --git a/backend/plugin/schema/tidb/generate_migration_testcontainer_test.go b/backend/plugin/schema/tidb/generate_migration_testcontainer_test.go
index 97c2fb5b26..6635f16274 100644
--- a/backend/plugin/schema/tidb/generate_migration_testcontainer_test.go
+++ b/backend/plugin/schema/tidb/generate_migration_testcontainer_test.go
@@ -2,26 +2,20 @@ package tidb
import (
"context"
- "database/sql"
"fmt"
"slices"
- "strconv"
"strings"
"testing"
- "time"
// Import MySQL driver (TiDB is compatible with MySQL protocol)
_ "github.com/go-sql-driver/mysql"
"github.com/google/go-cmp/cmp"
- "github.com/pkg/errors"
+ "github.com/google/uuid"
"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"
- tidbdb "github.com/bytebase/bytebase/backend/plugin/db/tidb"
"github.com/bytebase/bytebase/backend/plugin/schema"
"github.com/bytebase/bytebase/backend/store/model"
)
@@ -29,36 +23,18 @@ import (
// TestGenerateMigrationWithTestcontainer tests the generate migration function
// by applying migrations and rollback to verify the schema can be restored.
func TestGenerateMigrationWithTestcontainer(t *testing.T) {
+ t.Parallel()
+
if testing.Short() {
t.Skip("Skipping TiDB testcontainer test in short mode")
}
ctx := context.Background()
+ container := testcontainer.GetTestTiDBContainer(ctx, t)
+ t.Cleanup(func() { container.Close(ctx) })
- // Start TiDB container
- req := testcontainers.ContainerRequest{
- Image: "pingcap/tidb:v8.5.0",
- ExposedPorts: []string{"4000/tcp"},
- WaitingFor: wait.ForLog("server is running MySQL protocol").
- WithStartupTimeout(5 * time.Minute),
- }
-
- container, err := testcontainers.GenericContainer(ctx, testcontainers.GenericContainerRequest{
- ContainerRequest: req,
- Started: true,
- })
- require.NoError(t, err)
- 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, "4000")
- require.NoError(t, err)
+ host := container.GetHost()
+ port := container.GetPort()
// Test cases with various schema changes
testCases := []struct {
@@ -1381,36 +1357,35 @@ ALTER TABLE test_table COMMENT = '';
}
for _, tc := range testCases {
+ tc := tc
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)
+ t.Parallel()
- // Add a delay to ensure TiDB is fully ready
- time.Sleep(3 * time.Second)
+ // Create unique test database using UUID
+ testDB := fmt.Sprintf("test_%s", strings.ReplaceAll(uuid.New().String(), "-", "_"))
+ _, err := container.GetDB().Exec(fmt.Sprintf("CREATE DATABASE `%s`", testDB))
+ require.NoError(t, err, "failed to create test database")
- t.Logf("Connecting to TiDB at %s:%d", host, portInt)
- testDB, err := openTestDatabase(host, portInt, "root", "", "test")
- require.NoError(t, err, "Failed to connect to TiDB database")
- defer testDB.Close()
+ // Create driver for this test database
+ driver, err := createTiDBDriver(ctx, host, port, testDB)
+ require.NoError(t, err, "failed to create driver")
+ defer driver.Close(ctx)
- // Clean up any existing objects from previous tests
- cleanupDatabase(t, testDB)
+ // Step 1: Initialize the database schema and get schema result A
+ require.NoError(t, err)
// Execute initial schema
- if err := executeStatements(testDB, tc.initialSchema); err != nil {
- t.Fatalf("Failed to execute initial schema: %v", err)
- }
+ _, err = driver.GetDB().Exec(tc.initialSchema)
+ require.NoError(t, err, "Failed to execute initial schema")
- schemaA, err := getSyncMetadataForGenerateMigration(ctx, host, portInt, "root", "", "test")
+ 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 {
- t.Fatalf("Failed to execute migration DDL: %v", err)
- }
+ _, err = driver.GetDB().Exec(tc.migrationDDL)
+ require.NoError(t, err, "Failed to execute migration DDL")
- schemaB, err := getSyncMetadataForGenerateMigration(ctx, host, portInt, "root", "", "test")
+ schemaB, err := driver.SyncDBSchema(ctx)
require.NoError(t, err)
// Step 3: Call generate migration to get the rollback DDL
@@ -1422,21 +1397,6 @@ ALTER TABLE test_table COMMENT = '';
diff, err := schema.GetDatabaseSchemaDiff(storepb.Engine_TIDB, dbMetadataB, dbMetadataA)
require.NoError(t, err)
- // Log the diff for debugging
- t.Logf("Test case: %s", tc.description)
- t.Logf("Table changes: %d", len(diff.TableChanges))
- for _, tc := range diff.TableChanges {
- t.Logf(" Table: %s, Action: %v", tc.TableName, tc.Action)
- }
- t.Logf("View changes: %d", len(diff.ViewChanges))
- for _, vc := range diff.ViewChanges {
- t.Logf(" View: %s, Action: %v", vc.ViewName, vc.Action)
- }
- t.Logf("Function changes: %d", len(diff.FunctionChanges))
- for _, fc := range diff.FunctionChanges {
- t.Logf(" Function: %s, Action: %v", fc.FunctionName, fc.Action)
- }
-
// Generate rollback migration
rollbackDDL, err := schema.GenerateMigration(storepb.Engine_TIDB, diff)
require.NoError(t, err)
@@ -1444,11 +1404,10 @@ ALTER TABLE test_table COMMENT = '';
t.Logf("Rollback DDL:\n%s", rollbackDDL)
// Step 4: Run rollback DDL and get schema result C
- if err := executeStatements(testDB, rollbackDDL); err != nil {
- t.Fatalf("Failed to execute rollback DDL: %v", err)
- }
+ _, err = driver.GetDB().Exec(rollbackDDL)
+ require.NoError(t, err, "Failed to execute rollback DDL")
- schemaC, err := getSyncMetadataForGenerateMigration(ctx, host, portInt, "root", "", "test")
+ schemaC, err := driver.SyncDBSchema(ctx)
require.NoError(t, err)
// Step 5: Compare schema result A and C to ensure they are the same
@@ -1463,187 +1422,6 @@ ALTER TABLE test_table COMMENT = '';
}
}
-// openTestDatabase opens a connection to the test TiDB database
-func openTestDatabase(host string, port int, username, password, database string) (*sql.DB, error) {
- var dsn string
- if password == "" {
- dsn = fmt.Sprintf("%s@tcp(%s:%d)/%s?charset=utf8mb4&parseTime=true&multiStatements=true",
- username, host, port, database)
- } else {
- dsn = fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=utf8mb4&parseTime=true&multiStatements=true",
- username, password, host, port, database)
- }
-
- db, err := sql.Open("mysql", dsn)
- if err != nil {
- return nil, errors.Wrapf(err, "failed to open connection to TiDB")
- }
-
- // Set connection pool settings
- db.SetMaxOpenConns(5)
- db.SetMaxIdleConns(5)
- db.SetConnMaxLifetime(5 * time.Minute)
-
- // Try to ping with retries
- var pingErr error
- for i := 0; i < 10; i++ {
- if pingErr = db.Ping(); pingErr == nil {
- break
- }
- time.Sleep(time.Second)
- }
- if pingErr != nil {
- return nil, errors.Wrapf(pingErr, "failed to ping TiDB database after retries")
- }
-
- return db, nil
-}
-
-// executeStatements executes multiple SQL statements
-func executeStatements(db *sql.DB, statements string) error {
- // MySQL driver supports multi-statement execution natively
- if _, err := db.Exec(statements); err != nil {
- return errors.Wrapf(err, "failed to execute statements")
- }
- return nil
-}
-
-// getSyncMetadataForGenerateMigration retrieves metadata from the live database using Driver.SyncDBSchema
-func getSyncMetadataForGenerateMigration(ctx context.Context, host string, port int, username, password, database string) (*storepb.DatabaseSchemaMetadata, error) {
- // Create a driver instance using the tidb package
- driver := &tidbdb.Driver{}
-
- // Create connection config
- config := db.ConnectionConfig{
- DataSource: &storepb.DataSource{
- Type: storepb.DataSourceType_ADMIN,
- Username: username,
- Host: host,
- Port: fmt.Sprintf("%d", port),
- Database: database,
- },
- Password: password,
- ConnectionContext: db.ConnectionContext{
- EngineVersion: "v8.5.0",
- DatabaseName: database,
- },
- }
-
- // Open connection using the driver
- openedDriver, err := driver.Open(ctx, storepb.Engine_TIDB, config)
- if err != nil {
- return nil, err
- }
- defer openedDriver.Close(ctx)
-
- // Use SyncDBSchema to get the metadata
- tidbDriver, ok := openedDriver.(*tidbdb.Driver)
- if !ok {
- return nil, errors.New("failed to cast to tidb.Driver")
- }
-
- metadata, err := tidbDriver.SyncDBSchema(ctx)
- if err != nil {
- return nil, err
- }
-
- return metadata, nil
-}
-
-// cleanupDatabase removes all objects from the database
-func cleanupDatabase(_ *testing.T, db *sql.DB) {
- // Disable foreign key checks
- _, _ = db.Exec("SET FOREIGN_KEY_CHECKS = 0")
- defer func() {
- _, _ = db.Exec("SET FOREIGN_KEY_CHECKS = 1")
- }()
-
- // Drop all tables
- rows, err := db.Query("SELECT table_name FROM information_schema.tables WHERE table_schema = DATABASE()")
- if err == nil {
- defer func() {
- rows.Close()
- }()
- var tables []string
- for rows.Next() {
- var table string
- if err := rows.Scan(&table); err == nil {
- tables = append(tables, table)
- }
- }
- if err := rows.Err(); err != nil {
- return
- }
- for _, table := range tables {
- _, _ = db.Exec(fmt.Sprintf("DROP TABLE IF EXISTS `%s`", table))
- }
- }
-
- // Drop all views
- rows, err = db.Query("SELECT table_name FROM information_schema.views WHERE table_schema = DATABASE()")
- if err == nil {
- defer func() {
- rows.Close()
- }()
- var views []string
- for rows.Next() {
- var view string
- if err := rows.Scan(&view); err == nil {
- views = append(views, view)
- }
- }
- if err := rows.Err(); err != nil {
- return
- }
- for _, view := range views {
- _, _ = db.Exec(fmt.Sprintf("DROP VIEW IF EXISTS `%s`", view))
- }
- }
-
- // Drop all procedures (TiDB may support them)
- rows, err = db.Query("SELECT routine_name FROM information_schema.routines WHERE routine_schema = DATABASE() AND routine_type = 'PROCEDURE'")
- if err == nil {
- defer func() {
- rows.Close()
- }()
- var procedures []string
- for rows.Next() {
- var proc string
- if err := rows.Scan(&proc); err == nil {
- procedures = append(procedures, proc)
- }
- }
- if err := rows.Err(); err != nil {
- return
- }
- for _, proc := range procedures {
- _, _ = db.Exec(fmt.Sprintf("DROP PROCEDURE IF EXISTS `%s`", proc))
- }
- }
-
- // Drop all functions (TiDB may support them)
- rows, err = db.Query("SELECT routine_name FROM information_schema.routines WHERE routine_schema = DATABASE() AND routine_type = 'FUNCTION'")
- if err == nil {
- defer func() {
- rows.Close()
- }()
- var functions []string
- for rows.Next() {
- var fn string
- if err := rows.Scan(&fn); err == nil {
- functions = append(functions, fn)
- }
- }
- if err := rows.Err(); err != nil {
- return
- }
- for _, fn := range functions {
- _, _ = db.Exec(fmt.Sprintf("DROP FUNCTION IF EXISTS `%s`", fn))
- }
- }
-}
-
-// normalizeMetadataForComparison normalizes metadata to ignore differences that don't affect schema equality
func normalizeMetadataForComparison(metadata *storepb.DatabaseSchemaMetadata) {
// Clear database name as it might differ
metadata.Name = ""
diff --git a/backend/plugin/schema/tidb/get_database_definition_testcontainer_test.go b/backend/plugin/schema/tidb/get_database_definition_testcontainer_test.go
index aa2014a7ec..fa035fed05 100644
--- a/backend/plugin/schema/tidb/get_database_definition_testcontainer_test.go
+++ b/backend/plugin/schema/tidb/get_database_definition_testcontainer_test.go
@@ -2,43 +2,44 @@ package tidb
import (
"context"
- "database/sql"
- "errors"
"fmt"
+ "strings"
"testing"
// Import MySQL driver (TiDB is compatible with MySQL protocol)
_ "github.com/go-sql-driver/mysql"
"github.com/google/go-cmp/cmp"
+ "github.com/google/uuid"
"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"
- tidbdb "github.com/bytebase/bytebase/backend/plugin/db/tidb"
"github.com/bytebase/bytebase/backend/plugin/schema"
)
func TestGetDatabaseDefinition(t *testing.T) {
+ t.Parallel()
+
if testing.Short() {
t.Skip("Skipping TiDB testcontainer test in short mode")
}
ctx := context.Background()
container := testcontainer.GetTestTiDBContainer(ctx, t)
- defer container.Close(ctx)
+ t.Cleanup(func() { container.Close(ctx) })
+
+ host := container.GetHost()
+ port := container.GetPort()
type testCase struct {
- description string
- databaseName string
- originalDDL string
+ description string
+ originalDDL string
}
testCases := []testCase{
{
- description: "Basic tables with various column types",
- databaseName: "test_basic",
+ description: "Basic tables with various column types",
originalDDL: `
CREATE TABLE users (
id INT PRIMARY KEY AUTO_INCREMENT,
@@ -65,8 +66,7 @@ CREATE TABLE posts (
`,
},
{
- description: "Generated columns and complex indexes",
- databaseName: "test_generated",
+ description: "Generated columns and complex indexes",
originalDDL: `
CREATE TABLE products (
id INT PRIMARY KEY AUTO_INCREMENT,
@@ -91,8 +91,7 @@ CREATE TABLE inventory (
`,
},
{
- description: "Views",
- databaseName: "test_views",
+ description: "Views",
originalDDL: `
CREATE TABLE orders (
id INT PRIMARY KEY AUTO_INCREMENT,
@@ -132,8 +131,7 @@ GROUP BY o.id, o.order_number, o.customer_name, o.total_amount;
`,
},
{
- description: "TiDB specific features - AUTO_RANDOM",
- databaseName: "test_tidb_features",
+ description: "TiDB specific features - AUTO_RANDOM",
originalDDL: `
CREATE TABLE distributed_data (
id BIGINT AUTO_RANDOM(5) PRIMARY KEY,
@@ -152,8 +150,7 @@ CREATE TABLE users_autorand (
`,
},
{
- description: "Character sets and collations",
- databaseName: "test_charset",
+ description: "Character sets and collations",
originalDDL: `
CREATE TABLE multilingual (
id INT PRIMARY KEY AUTO_INCREMENT,
@@ -170,8 +167,7 @@ CREATE TABLE charset_test (
`,
},
{
- description: "TiDB clustered and non-clustered indexes",
- databaseName: "test_tidb_indexes",
+ description: "TiDB clustered and non-clustered indexes",
originalDDL: `
CREATE TABLE clustered_pk (
id BIGINT PRIMARY KEY /*T![clustered_index] CLUSTERED */,
@@ -191,39 +187,46 @@ CREATE TABLE nonclustered_pk (
}
for _, tc := range testCases {
+ tc := tc
t.Run(tc.description, func(t *testing.T) {
- // Create database
- _, err := container.GetDB().ExecContext(ctx, fmt.Sprintf("CREATE DATABASE %s", tc.databaseName))
+ t.Parallel()
+
+ // Create unique test database using UUID
+ testDB := fmt.Sprintf("test_%s", strings.ReplaceAll(uuid.New().String(), "-", "_"))
+ _, err := container.GetDB().Exec(fmt.Sprintf("CREATE DATABASE `%s`", testDB))
require.NoError(t, err)
- // Execute original DDL
- _, err = container.GetDB().ExecContext(ctx, fmt.Sprintf("USE %s", tc.databaseName))
+ // Get the original database metadata using SyncDBSchema
+ driver, err := createTiDBDriver(ctx, host, port, testDB)
require.NoError(t, err)
- err = executeMultiStatements(ctx, container.GetDB(), tc.originalDDL)
+ defer driver.Close(ctx)
+ // Execute original DDL
+ _, err = driver.GetDB().Exec(tc.originalDDL)
require.NoError(t, err)
- // Get the original database metadata using SyncDBSchema
- originalMetadata, err := getMetadata(ctx, container.GetHost(), container.GetPort(), tc.databaseName)
+ originalMetadata, err := driver.SyncDBSchema(ctx)
require.NoError(t, err)
// Generate the database definition
- definition, err := generateDatabaseDefinition(ctx, container.GetHost(), container.GetPort(), tc.databaseName)
+ definition, err := schema.GetDatabaseDefinition(storepb.Engine_TIDB, schema.GetDefinitionContext{PrintHeader: true}, originalMetadata)
require.NoError(t, err)
require.NotEmpty(t, definition)
// Create a new database and apply the generated definition
- newDatabaseName := fmt.Sprintf("%s_new", tc.databaseName)
- _, err = container.GetDB().ExecContext(ctx, fmt.Sprintf("CREATE DATABASE %s", newDatabaseName))
+ newTestDB := fmt.Sprintf("test_%s", strings.ReplaceAll(uuid.New().String(), "-", "_"))
+ _, err = container.GetDB().Exec(fmt.Sprintf("CREATE DATABASE `%s`", newTestDB))
require.NoError(t, err)
- // Apply the generated definition to the new database
- _, err = container.GetDB().ExecContext(ctx, fmt.Sprintf("USE %s", newDatabaseName))
+ // Get the new database metadata
+ newDriver, err := createTiDBDriver(ctx, host, port, newTestDB)
+ require.NoError(t, err)
+ defer newDriver.Close(ctx)
+
require.NoError(t, err)
- err = executeMultiStatements(ctx, container.GetDB(), definition)
+ _, err = newDriver.GetDB().Exec(definition)
require.NoError(t, err)
- // Get the new database metadata
- newMetadata, err := getMetadata(ctx, container.GetHost(), container.GetPort(), newDatabaseName)
+ newMetadata, err := newDriver.SyncDBSchema(ctx)
require.NoError(t, err)
// Compare the metadata
@@ -245,9 +248,14 @@ func TestGetDatabaseDefinitionWithConnectedDeps(t *testing.T) {
ctx := context.Background()
container := testcontainer.GetTestTiDBContainer(ctx, t)
- defer container.Close(ctx)
+ t.Cleanup(func() { container.Close(ctx) })
+
+ host := container.GetHost()
+ port := container.GetPort()
+
+ // Create unique test database using UUID
+ testDB := fmt.Sprintf("test_%s", strings.ReplaceAll(uuid.New().String(), "-", "_"))
- databaseName := "test_deps"
originalDDL := `
-- Create tables with complex foreign key dependencies
CREATE TABLE departments (
@@ -292,37 +300,40 @@ CREATE TABLE project_members (
`
// Create database
- _, err := container.GetDB().ExecContext(ctx, fmt.Sprintf("CREATE DATABASE %s", databaseName))
+ _, err := container.GetDB().Exec(fmt.Sprintf("CREATE DATABASE `%s`", testDB))
require.NoError(t, err)
- // Execute original DDL
- _, err = container.GetDB().ExecContext(ctx, fmt.Sprintf("USE %s", databaseName))
+ // Get the original database metadata
+ driver, err := createTiDBDriver(ctx, host, port, testDB)
require.NoError(t, err)
- err = executeMultiStatements(ctx, container.GetDB(), originalDDL)
+ // Execute original DDL
+ _, err = driver.GetDB().Exec(originalDDL)
require.NoError(t, err)
+ defer driver.Close(ctx)
- // Get the original database metadata
- originalMetadata, err := getMetadata(ctx, container.GetHost(), container.GetPort(), databaseName)
+ originalMetadata, err := driver.SyncDBSchema(ctx)
require.NoError(t, err)
// Generate the database definition
- definition, err := generateDatabaseDefinition(ctx, container.GetHost(), container.GetPort(), databaseName)
+ definition, err := schema.GetDatabaseDefinition(storepb.Engine_TIDB, schema.GetDefinitionContext{PrintHeader: true}, originalMetadata)
require.NoError(t, err)
require.NotEmpty(t, definition)
// Create a new database and apply the generated definition
- newDatabaseName := fmt.Sprintf("%s_new", databaseName)
- _, err = container.GetDB().ExecContext(ctx, fmt.Sprintf("CREATE DATABASE %s", newDatabaseName))
+ newTestDB := fmt.Sprintf("test_%s", strings.ReplaceAll(uuid.New().String(), "-", "_"))
+ _, err = container.GetDB().Exec(fmt.Sprintf("CREATE DATABASE `%s`", newTestDB))
require.NoError(t, err)
- // Apply the generated definition to the new database
- _, err = container.GetDB().ExecContext(ctx, fmt.Sprintf("USE %s", newDatabaseName))
+ // Get the new database metadata
+ newDriver, err := createTiDBDriver(ctx, host, port, newTestDB)
require.NoError(t, err)
- err = executeMultiStatements(ctx, container.GetDB(), definition)
+ defer newDriver.Close(ctx)
+
+ // Apply the generated definition to the new database
+ _, err = newDriver.GetDB().Exec(definition)
require.NoError(t, err)
- // Get the new database metadata
- newMetadata, err := getMetadata(ctx, container.GetHost(), container.GetPort(), newDatabaseName)
+ newMetadata, err := newDriver.SyncDBSchema(ctx)
require.NoError(t, err)
// Compare the metadata
@@ -332,100 +343,3 @@ CREATE TABLE project_members (
diff := cmp.Diff(originalMetadata, newMetadata, protocmp.Transform())
require.Empty(t, diff, "Database metadata should be identical")
}
-
-// executeMultiStatements executes multiple SQL statements separated by semicolons
-func executeMultiStatements(ctx context.Context, db *sql.DB, statements string) error {
- tx, err := db.BeginTx(ctx, nil)
- if err != nil {
- return err
- }
- defer tx.Rollback()
-
- if _, err := tx.ExecContext(ctx, statements); err != nil {
- return errors.New("failed to execute context in a transaction: " + err.Error())
- }
-
- return tx.Commit()
-}
-
-// getMetadata creates a database connection and retrieves metadata
-func getMetadata(ctx context.Context, host, port, database string) (*storepb.DatabaseSchemaMetadata, error) {
- // Create driver instance
- driver := &tidbdb.Driver{}
-
- // Create connection config
- config := db.ConnectionConfig{
- DataSource: &storepb.DataSource{
- Type: storepb.DataSourceType_ADMIN,
- Username: "root",
- Host: host,
- Port: port,
- Database: database,
- },
- Password: "",
- ConnectionContext: db.ConnectionContext{
- EngineVersion: "8.5.0",
- DatabaseName: database,
- },
- }
-
- // Open connection
- openedDriver, err := driver.Open(ctx, storepb.Engine_TIDB, config)
- if err != nil {
- return nil, err
- }
- defer openedDriver.Close(ctx)
-
- // No DDL execution since it's not used
-
- // Sync metadata
- tidbDriver, ok := openedDriver.(*tidbdb.Driver)
- if !ok {
- return nil, errors.New("failed to cast to tidb.Driver")
- }
-
- return tidbDriver.SyncDBSchema(ctx)
-}
-
-// generateDatabaseDefinition generates the database definition using schema.GetDatabaseDefinition
-func generateDatabaseDefinition(ctx context.Context, host, port, database string) (string, error) {
- // Create driver instance
- driver := &tidbdb.Driver{}
-
- // Create connection config
- config := db.ConnectionConfig{
- DataSource: &storepb.DataSource{
- Type: storepb.DataSourceType_ADMIN,
- Username: "root",
- Host: host,
- Port: port,
- Database: database,
- },
- Password: "",
- ConnectionContext: db.ConnectionContext{
- EngineVersion: "8.5.0",
- DatabaseName: database,
- },
- }
-
- // Open connection
- openedDriver, err := driver.Open(ctx, storepb.Engine_TIDB, config)
- if err != nil {
- return "", err
- }
- defer openedDriver.Close(ctx)
-
- // Sync metadata first
- tidbDriver, ok := openedDriver.(*tidbdb.Driver)
- if !ok {
- return "", errors.New("failed to cast to tidb.Driver")
- }
-
- metadata, err := tidbDriver.SyncDBSchema(ctx)
- if err != nil {
- return "", err
- }
-
- // Generate definition
- return schema.GetDatabaseDefinition(storepb.Engine_TIDB, schema.GetDefinitionContext{PrintHeader: true}, metadata)
-}
diff --git a/backend/plugin/schema/tidb/get_database_metadata_testcontainer_test.go b/backend/plugin/schema/tidb/get_database_metadata_testcontainer_test.go
index 75277da965..8bb5b11f47 100644
--- a/backend/plugin/schema/tidb/get_database_metadata_testcontainer_test.go
+++ b/backend/plugin/schema/tidb/get_database_metadata_testcontainer_test.go
@@ -2,59 +2,33 @@ package tidb
import (
"context"
+ "fmt"
"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"
- tidbdb "github.com/bytebase/bytebase/backend/plugin/db/tidb"
)
// TestGetDatabaseMetadataWithTestcontainer tests the get_database_metadata function
// by comparing its output with the metadata retrieved from a real TiDB instance.
func TestGetDatabaseMetadataWithTestcontainer(t *testing.T) {
- ctx := context.Background()
+ t.Parallel()
- // Start TiDB container
- container, err := testcontainer.GetTiDBContainer(ctx)
- require.NoError(t, err)
- defer container.Close(ctx)
+ if testing.Short() {
+ t.Skip("Skipping TiDB testcontainer test in short mode")
+ }
- // Create test database
- _, err = container.GetDB().Exec("CREATE DATABASE IF NOT EXISTS test_db")
- require.NoError(t, err)
+ ctx := context.Background()
+ container := testcontainer.GetTestTiDBContainer(ctx, t)
+ t.Cleanup(func() { container.Close(ctx) })
host := container.GetHost()
port := container.GetPort()
- // Create TiDB driver for metadata sync
- driver := &tidbdb.Driver{}
- config := db.ConnectionConfig{
- DataSource: &storepb.DataSource{
- Type: storepb.DataSourceType_ADMIN,
- Username: "root",
- Host: host,
- Port: port,
- Database: "test_db",
- },
- Password: "",
- ConnectionContext: db.ConnectionContext{
- EngineVersion: "8.0",
- DatabaseName: "test_db",
- },
- }
-
- openedDriver, err := driver.Open(ctx, storepb.Engine_TIDB, config)
- require.NoError(t, err)
- defer openedDriver.Close(ctx)
-
- // Cast to TiDB driver for SyncDBSchema
- tidbDriver, ok := openedDriver.(*tidbdb.Driver)
- require.True(t, ok, "failed to cast to tidb.Driver")
-
// Test cases with various TiDB features
testCases := []struct {
name string
@@ -226,19 +200,27 @@ CREATE TABLE non_clustered_test (
}
for _, tc := range testCases {
+ tc := tc
t.Run(tc.name, func(t *testing.T) {
- // Create test database (drop first to avoid conflicts between test cases)
- _, err := container.GetDB().ExecContext(ctx, "DROP DATABASE IF EXISTS test_db")
+ t.Parallel()
+
+ // Create unique test database using UUID
+ testDB := fmt.Sprintf("test_%s", strings.ReplaceAll(uuid.New().String(), "-", "_"))
+ _, err := container.GetDB().Exec(fmt.Sprintf("CREATE DATABASE `%s`", testDB))
require.NoError(t, err)
- _, err = container.GetDB().ExecContext(ctx, "CREATE DATABASE test_db")
+
+ // Create TiDB driver for this test database
+ driver, err := createTiDBDriver(ctx, host, port, testDB)
require.NoError(t, err)
+ defer driver.Close(ctx)
- // Execute DDL using the driver
- _, err = openedDriver.Execute(ctx, tc.ddl, db.ExecuteOptions{})
+ // Execute DDL statements
+ require.NoError(t, err)
+ _, err = driver.GetDB().Exec(tc.ddl)
require.NoError(t, err)
// Get metadata from live database using driver
- dbMetadata, err := tidbDriver.SyncDBSchema(ctx)
+ dbMetadata, err := driver.SyncDBSchema(ctx)
require.NoError(t, err)
// Get metadata from parser
diff --git a/backend/plugin/schema/tidb/testutil_test.go b/backend/plugin/schema/tidb/testutil_test.go
new file mode 100644
index 0000000000..d6726fb76f
--- /dev/null
+++ b/backend/plugin/schema/tidb/testutil_test.go
@@ -0,0 +1,39 @@
+package tidb
+
+import (
+ "context"
+
+ "github.com/pkg/errors"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/db"
+ tidbdb "github.com/bytebase/bytebase/backend/plugin/db/tidb"
+)
+
+// createTiDBDriver creates and opens a TiDB driver connection
+func createTiDBDriver(ctx context.Context, host, port, database string) (*tidbdb.Driver, error) {
+ driver := &tidbdb.Driver{}
+ config := db.ConnectionConfig{
+ DataSource: &storepb.DataSource{
+ Type: storepb.DataSourceType_ADMIN,
+ Username: "root",
+ Host: host,
+ Port: port,
+ Database: database,
+ },
+ Password: "",
+ ConnectionContext: db.ConnectionContext{
+ EngineVersion: "8.5.0",
+ DatabaseName: database,
+ },
+ }
+ d, err := driver.Open(ctx, storepb.Engine_TIDB, config)
+ if err != nil {
+ return nil, err
+ }
+ tidbDriver, ok := d.(*tidbdb.Driver)
+ if !ok {
+ return nil, errors.Errorf("failed to cast to TiDB driver")
+ }
+ return tidbDriver, nil
+}