Skip to content

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

fix(oceanbase): sync databases that contain events (#21687)

rebelice40ca87e3093c
diff --git a/backend/plugin/db/mysql/sync.go b/backend/plugin/db/mysql/sync.go
index fcf1cdf392..6d6d1b2b7e 100644
--- a/backend/plugin/db/mysql/sync.go
+++ b/backend/plugin/db/mysql/sync.go
@@ -813,6 +813,9 @@ func (d *Driver) listOceanBaseMaterializedViews(ctx context.Context, databaseNam
}
func (d *Driver) getEventList(ctx context.Context, databaseName string) ([]*metadatapb.EventMetadata, error) {
+ if d.dbType == storepb.Engine_OCEANBASE {
+ return d.listOceanBaseEvents(ctx, databaseName)
+ }
listEventsQuery := `
SELECT
EVENT_NAME,
@@ -862,6 +865,39 @@ func (d *Driver) getEventList(ctx context.Context, databaseName string) ([]*meta
return events, nil
}
+// listOceanBaseEvents lists the database's events by name only. OceanBase rejects SHOW CREATE
+// EVENT, and information_schema.EVENTS cannot rebuild it: it shows the schedule in the session
+// time zone, flattens a BEGIN...END body, and does not record the creating session's time zone,
+// SQL mode, or character set. The definition stays empty, so the DDL writers in
+// backend/plugin/schema/mysql skip the event.
+//
+// A database created under a dropped one's name also lists the dropped one's events, which
+// information_schema cannot tell from its own; DISTINCT lists a name both have once.
+func (d *Driver) listOceanBaseEvents(ctx context.Context, databaseName string) ([]*metadatapb.EventMetadata, error) {
+ query := `
+ SELECT DISTINCT EVENT_NAME
+ FROM information_schema.EVENTS
+ WHERE EVENT_SCHEMA = ?
+ ORDER BY EVENT_NAME`
+ rows, err := d.db.QueryContext(ctx, query, databaseName)
+ if err != nil {
+ return nil, util.FormatErrorWithQuery(err, query)
+ }
+ defer rows.Close()
+ var events []*metadatapb.EventMetadata
+ for rows.Next() {
+ event := &metadatapb.EventMetadata{}
+ if err := rows.Scan(&event.Name); err != nil {
+ return nil, err
+ }
+ events = append(events, event)
+ }
+ if err := rows.Err(); err != nil {
+ return nil, util.FormatErrorWithQuery(err, query)
+ }
+ return events, nil
+}
+
func (d *Driver) getCreateEventStmt(ctx context.Context, databaseName string, name string) (string, error) {
query := fmt.Sprintf("SHOW CREATE EVENT `%s`.`%s`", databaseName, name)
rows, err := d.db.QueryContext(ctx, query)
diff --git a/backend/plugin/db/mysql/sync_oceanbase_test.go b/backend/plugin/db/mysql/sync_oceanbase_test.go
index c0ec31fc07..f863a3fa70 100644
--- a/backend/plugin/db/mysql/sync_oceanbase_test.go
+++ b/backend/plugin/db/mysql/sync_oceanbase_test.go
@@ -168,6 +168,82 @@ func TestSyncOceanBaseTableNamespace(t *testing.T) {
require.ElementsMatch(t, []string{"t", "v", "mlog$_t", container}, syncedRelationNames(metadata.Schemas[0]))
}
+func TestSyncOceanBaseEvents(t *testing.T) {
+ server := newOceanBaseTestServer(t)
+ ctx := context.Background()
+ database := fmt.Sprintf("sync_events_%d", time.Now().UnixNano())
+
+ admin := server.open(ctx, t, storepb.Engine_OCEANBASE, server.user, server.password, "")
+ _, err := admin.db.ExecContext(ctx, fmt.Sprintf("CREATE DATABASE `%s`", database))
+ require.NoError(t, err)
+ t.Cleanup(func() {
+ _, err := admin.db.ExecContext(ctx, fmt.Sprintf("DROP DATABASE `%s`", database))
+ require.NoError(t, err)
+ })
+
+ driver := server.open(ctx, t, storepb.Engine_OCEANBASE, server.user, server.password, database)
+ for _, statement := range []string{
+ "CREATE TABLE t (id INT)",
+ "CREATE EVENT e_every ON SCHEDULE EVERY 1 DAY STARTS '2030-01-01 00:00:00' ON COMPLETION PRESERVE DISABLE DO INSERT INTO t VALUES (1)",
+ "CREATE EVENT e_at ON SCHEDULE AT '2030-06-01 12:00:00' DO BEGIN INSERT INTO t VALUES (2); DELETE FROM t WHERE id = 1; END",
+ } {
+ _, err := driver.db.ExecContext(ctx, statement)
+ require.NoError(t, err, statement)
+ }
+
+ metadata, err := driver.SyncDBSchema(ctx)
+ require.NoError(t, err)
+ schema := metadata.Schemas[0]
+ require.Equal(t, []string{"t"}, syncedRelationNames(schema))
+ require.Empty(t, cmp.Diff([]*metadatapb.EventMetadata{
+ {Name: "e_at"},
+ {Name: "e_every"},
+ }, schema.Events, protocmp.Transform()))
+
+ // The same server registered as a MySQL instance keeps the MySQL event sync, which cannot
+ // read OceanBase's events.
+ asMySQL := server.open(ctx, t, storepb.Engine_MYSQL, server.user, server.password, database)
+ _, err = asMySQL.SyncDBSchema(ctx)
+ require.ErrorContains(t, err, "CHARACTER_SET_CLIENT")
+}
+
+// OceanBase keeps listing a dropped database's events under its name, so a database created
+// again under that name lists an event created again twice.
+func TestSyncOceanBaseEventsOfRecreatedDatabase(t *testing.T) {
+ server := newOceanBaseTestServer(t)
+ ctx := context.Background()
+ database := fmt.Sprintf("sync_recreated_%d", time.Now().UnixNano())
+
+ admin := server.open(ctx, t, storepb.Engine_OCEANBASE, server.user, server.password, "")
+ t.Cleanup(func() {
+ _, err := admin.db.ExecContext(ctx, fmt.Sprintf("DROP DATABASE IF EXISTS `%s`", database))
+ require.NoError(t, err)
+ })
+ var listed int
+ for range 2 {
+ _, err := admin.db.ExecContext(ctx, fmt.Sprintf("DROP DATABASE IF EXISTS `%s`", database))
+ require.NoError(t, err)
+ _, err = admin.db.ExecContext(ctx, fmt.Sprintf("CREATE DATABASE `%s`", database))
+ require.NoError(t, err)
+ driver := server.open(ctx, t, storepb.Engine_OCEANBASE, server.user, server.password, database)
+ for _, statement := range []string{
+ "CREATE TABLE t (id INT)",
+ "CREATE EVENT e ON SCHEDULE EVERY 1 DAY STARTS '2030-01-01 00:00:00' DO DELETE FROM t",
+ } {
+ _, err := driver.db.ExecContext(ctx, statement)
+ require.NoError(t, err, statement)
+ }
+ require.NoError(t, admin.db.QueryRowContext(ctx,
+ "SELECT COUNT(*) FROM information_schema.EVENTS WHERE EVENT_SCHEMA = ? AND EVENT_NAME = 'e'", database,
+ ).Scan(&listed))
+
+ metadata, err := driver.SyncDBSchema(ctx)
+ require.NoError(t, err)
+ require.Empty(t, cmp.Diff([]*metadatapb.EventMetadata{{Name: "e"}}, metadata.Schemas[0].Events, protocmp.Transform()))
+ }
+ require.Equal(t, 2, listed)
+}
+
// oceanBaseObjectCensus lists every object the catalog holds in the database except the
// database itself and its indexes.
func oceanBaseObjectCensus(ctx context.Context, t *testing.T, driver *Driver, database string) []string {
diff --git a/backend/plugin/schema/mysql/generate_migration.go b/backend/plugin/schema/mysql/generate_migration.go
index 063955daaf..684c0a19e2 100644
--- a/backend/plugin/schema/mysql/generate_migration.go
+++ b/backend/plugin/schema/mysql/generate_migration.go
@@ -978,6 +978,10 @@ func writeProcedureDiff(buf *strings.Builder, procDiff *schema.ProcedureDiff) er
func writeEventDiff(buf *strings.Builder, eventDiff *schema.EventDiff) error {
if eventDiff.Action == schema.MetadataDiffActionCreate || eventDiff.Action == schema.MetadataDiffActionAlter {
+ // An event synced without its CREATE EVENT, as on OceanBase, has nothing faithful to write.
+ if eventDiff.NewEvent.Definition == "" {
+ return nil
+ }
// Write the event definition
_, _ = buf.WriteString(eventDiff.NewEvent.Definition)
if !strings.HasSuffix(strings.TrimSpace(eventDiff.NewEvent.Definition), ";") {
diff --git a/backend/plugin/schema/mysql/generate_migration_test.go b/backend/plugin/schema/mysql/generate_migration_test.go
index 6631d0677e..70f932013f 100644
--- a/backend/plugin/schema/mysql/generate_migration_test.go
+++ b/backend/plugin/schema/mysql/generate_migration_test.go
@@ -110,6 +110,24 @@ func databaseOf(tables ...*metadatapb.TableMetadata) *model.DatabaseMetadata {
}, nil, &storepb.DatabaseConfig{}, storepb.Engine_MYSQL, true)
}
+func TestDiffMigrationEventWithoutDefinition(t *testing.T) {
+ oceanBaseDatabaseOf := func(events ...*metadatapb.EventMetadata) *model.DatabaseMetadata {
+ return model.NewDatabaseMetadata(&metadatapb.DatabaseSchemaMetadata{
+ Name: "db",
+ Schemas: []*metadatapb.SchemaMetadata{{Name: "", Events: events}},
+ }, nil, &storepb.DatabaseConfig{}, storepb.Engine_OCEANBASE, true)
+ }
+ withEvent := oceanBaseDatabaseOf(&metadatapb.EventMetadata{Name: "e"})
+
+ migration, err := schema.DiffMigration(storepb.Engine_OCEANBASE, oceanBaseDatabaseOf(), withEvent)
+ require.NoError(t, err)
+ require.Empty(t, migration)
+
+ migration, err = schema.DiffMigration(storepb.Engine_OCEANBASE, withEvent, oceanBaseDatabaseOf())
+ require.NoError(t, err)
+ require.Equal(t, "DROP EVENT IF EXISTS `e`;\n\n", migration)
+}
+
func TestDiffMigrationPartitionedTableEmittedOnce(t *testing.T) {
for _, partitionCount := range []int{0, 1, 3, 180} {
t.Run(fmt.Sprintf("partitions=%d", partitionCount), func(t *testing.T) {
diff --git a/backend/plugin/schema/mysql/get_database_definition.go b/backend/plugin/schema/mysql/get_database_definition.go
index 42a91df95f..4ac693df34 100644
--- a/backend/plugin/schema/mysql/get_database_definition.go
+++ b/backend/plugin/schema/mysql/get_database_definition.go
@@ -194,6 +194,10 @@ func GetProcedureDefinition(_ string, procedure *metadatapb.ProcedureMetadata) (
}
func writeEvent(out io.Writer, event *metadatapb.EventMetadata) error {
+ // An event synced without its CREATE EVENT, as on OceanBase, has nothing faithful to write.
+ if event.Definition == "" {
+ return nil
+ }
// Header.
if _, err := io.WriteString(out, emptyCommentLine); err != nil {
return err
diff --git a/backend/plugin/schema/mysql/get_database_definition_test.go b/backend/plugin/schema/mysql/get_database_definition_test.go
index 410292aeb7..4745eae042 100644
--- a/backend/plugin/schema/mysql/get_database_definition_test.go
+++ b/backend/plugin/schema/mysql/get_database_definition_test.go
@@ -130,6 +130,18 @@ func TestGetFunctionDefinitionWithMultilineParameters(t *testing.T) {
require.Equal(t, want, got)
}
+func TestGetDatabaseDefinitionSkipsEventWithoutDefinition(t *testing.T) {
+ metadata := &metadatapb.DatabaseSchemaMetadata{
+ Name: "db",
+ Schemas: []*metadatapb.SchemaMetadata{{Events: []*metadatapb.EventMetadata{{Name: "e"}}}},
+ }
+ for _, sdl := range []bool{false, true} {
+ definition, err := GetDatabaseDefinition(schema.GetDefinitionContext{SDLFormat: sdl}, metadata)
+ require.NoError(t, err)
+ require.Empty(t, definition, "SDLFormat=%t", sdl)
+ }
+}
+
func TestRenderColumnDefaultBitLiteral(t *testing.T) {
testCases := []struct {
name string