Skip to content

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

fix: return "database not synced" instead of panicking before a schema sync (#21566)

zchpetere886f159b383
diff --git a/backend/component/parsercontext/parsercontext_test.go b/backend/component/parsercontext/parsercontext_test.go
index 45daa796bb..f2af611dff 100644
--- a/backend/component/parsercontext/parsercontext_test.go
+++ b/backend/component/parsercontext/parsercontext_test.go
@@ -119,3 +119,44 @@ func TestBuildGetLinkedDatabaseMetadataFunc(t *testing.T) {
require.Empty(t, instanceID)
require.Nil(t, meta)
}
+
+func TestBuildGetDatabaseMetadataFunc(t *testing.T) {
+ ctx := context.WithValue(context.Background(), common.WorkspaceIDContextKey, "default")
+ db, s, _ := testcontainer.NewMetadataDB(t)
+ _, err := db.ExecContext(ctx, `
+ INSERT INTO workspace (resource_id) VALUES ('default');
+ INSERT INTO project (resource_id, workspace, name) VALUES ('project-a', 'default', 'Project A');
+ `)
+ require.NoError(t, err)
+ _, err = s.CreateInstance(ctx, &store.InstanceMessage{
+ ResourceID: "mssql",
+ Workspace: "default",
+ Metadata: &storepb.Instance{
+ Engine: storepb.Engine_MSSQL,
+ DataSources: []*storepb.DataSource{{Id: "admin", Type: storepb.DataSourceType_ADMIN, Host: "localhost", Port: "1433"}},
+ },
+ })
+ require.NoError(t, err)
+ for _, name := range []string{"synced", "unsynced"} {
+ _, err = s.UpsertDatabase(ctx, &store.DatabaseMessage{ProjectID: "project-a", InstanceID: "mssql", DatabaseName: name, Metadata: &storepb.DatabaseMetadata{}})
+ require.NoError(t, err)
+ }
+ require.NoError(t, s.UpsertDBSchema(ctx, "mssql", "synced", &metadatapb.DatabaseSchemaMetadata{
+ Name: "synced",
+ Schemas: []*metadatapb.SchemaMetadata{{Name: "dbo", Tables: []*metadatapb.TableMetadata{{Name: "t"}}}},
+ }, &storepb.DatabaseConfig{}, nil))
+
+ get := BuildGetDatabaseMetadataFunc(s)
+
+ name, meta, err := get(ctx, "mssql", "synced")
+ require.NoError(t, err)
+ require.Equal(t, "synced", name)
+ require.NotNil(t, meta.GetSchemaMetadata("dbo").GetTable("t"))
+
+ for _, database := range []string{"unsynced", "untracked"} {
+ name, meta, err := get(ctx, "mssql", database)
+ require.NoError(t, err, database)
+ require.Empty(t, name, database)
+ require.Nil(t, meta, database)
+ }
+}
diff --git a/backend/plugin/parser/base/span.go b/backend/plugin/parser/base/span.go
index 2d4801a733..2d4e052dea 100644
--- a/backend/plugin/parser/base/span.go
+++ b/backend/plugin/parser/base/span.go
@@ -382,6 +382,9 @@ type GetQuerySpanContext struct {
}
// GetDatabaseMetadataFunc is the function to get database metadata.
+// It may return nil metadata and a nil error when Bytebase has not synced the
+// database's schema, as in the window after an instance is added; callers must
+// check for nil before use.
type GetDatabaseMetadataFunc func(context.Context, string, string) (string, *model.DatabaseMetadata, error)
// ListDatabaseNamesFunc is the function to list database names.
diff --git a/backend/plugin/parser/pg/backup.go b/backend/plugin/parser/pg/backup.go
index b567b27443..17000b56e0 100644
--- a/backend/plugin/parser/pg/backup.go
+++ b/backend/plugin/parser/pg/backup.go
@@ -286,6 +286,9 @@ func prepareTransformation(ctx context.Context, tCtx base.TransformContext, stat
if err != nil {
return nil, errors.Wrap(err, "failed to get database metadata")
}
+ if metadata == nil {
+ return nil, errors.Errorf("database metadata for database %q not found (database not synced)", tCtx.DatabaseName)
+ }
searchPath := metadata.GetSearchPath()
var dmls []statementInfo
diff --git a/backend/plugin/parser/pg/backup_test.go b/backend/plugin/parser/pg/backup_test.go
index 16e58faa39..ec64cf3df1 100644
--- a/backend/plugin/parser/pg/backup_test.go
+++ b/backend/plugin/parser/pg/backup_test.go
@@ -12,6 +12,7 @@ import (
"github.com/bytebase/bytebase/backend/common/yamltest"
"github.com/bytebase/bytebase/backend/plugin/parser/base"
+ "github.com/bytebase/bytebase/backend/store/model"
)
type rollbackCase struct {
@@ -73,3 +74,13 @@ func TestBackup(t *testing.T) {
yamltest.Record(t, filepath, tests)
}
}
+
+func TestBackupUnsyncedDatabase(t *testing.T) {
+ _, err := TransformDMLToSelect(context.Background(), base.TransformContext{
+ GetDatabaseMetadataFunc: func(context.Context, string, string) (string, *model.DatabaseMetadata, error) {
+ return "", nil, nil
+ },
+ DatabaseName: "db",
+ }, "UPDATE t SET a = 1 WHERE b = 1;", "db", "backupSchema", "rollback")
+ require.ErrorContains(t, err, `database metadata for database "db" not found (database not synced)`)
+}
diff --git a/backend/plugin/parser/plsql/restore.go b/backend/plugin/parser/plsql/restore.go
index 4ec9fe51c0..d963068b95 100644
--- a/backend/plugin/parser/plsql/restore.go
+++ b/backend/plugin/parser/plsql/restore.go
@@ -116,6 +116,9 @@ func doGenerate(ctx context.Context, rCtx base.RestoreContext, sqlForComment str
if err != nil {
return "", errors.Wrapf(err, "failed to get database metadata for %s", sourceDatabase)
}
+ if metadata == nil {
+ return "", errors.Errorf("database metadata for database %q not found (database not synced)", sourceDatabase)
+ }
schemaMetadata := metadata.GetSchemaMetadata("")
if schemaMetadata == nil {
diff --git a/backend/plugin/parser/plsql/restore_test.go b/backend/plugin/parser/plsql/restore_test.go
index 705899eb6e..621f3076f6 100644
--- a/backend/plugin/parser/plsql/restore_test.go
+++ b/backend/plugin/parser/plsql/restore_test.go
@@ -178,6 +178,15 @@ INSERT INTO "DB"."TEST" ("A", "B", "C") SELECT "A", "B", "C" FROM "bbarchive"."p
})
}
+func TestRestoreUnsyncedDatabase(t *testing.T) {
+ _, err := GenerateRestoreSQL(context.Background(), base.RestoreContext{
+ GetDatabaseMetadataFunc: func(context.Context, string, string) (string, *model.DatabaseMetadata, error) {
+ return "", nil, nil
+ },
+ }, `UPDATE test SET a = 1 WHERE c1 = 1;`, restoreBackupItem(0, math.MaxInt32))
+ require.ErrorContains(t, err, `database metadata for database "DB" not found (database not synced)`)
+}
+
func restoreBackupItem(startLine, endLine int32) *store.PriorBackupDetail_Item {
return &store.PriorBackupDetail_Item{
SourceTable: &store.PriorBackupDetail_Item_Table{
diff --git a/backend/plugin/parser/redshift/query_span.go b/backend/plugin/parser/redshift/query_span.go
index e507db934b..d9e1c078b0 100644
--- a/backend/plugin/parser/redshift/query_span.go
+++ b/backend/plugin/parser/redshift/query_span.go
@@ -22,6 +22,9 @@ func GetQuerySpan(ctx context.Context, gCtx base.GetQuerySpanContext, stmt base.
if err != nil {
return nil, errors.Wrapf(err, "failed to get database metadata for instance %q and database %q", gCtx.InstanceID, database)
}
+ if meta == nil {
+ return nil, errors.Errorf("database metadata for database %q not found (database not synced)", database)
+ }
searchPath := meta.GetSearchPath()
if schema != "" {
searchPath = []string{schema}
diff --git a/backend/plugin/parser/redshift/query_span_test.go b/backend/plugin/parser/redshift/query_span_test.go
index c24f0cd265..945da20fd4 100644
--- a/backend/plugin/parser/redshift/query_span_test.go
+++ b/backend/plugin/parser/redshift/query_span_test.go
@@ -236,6 +236,18 @@ func TestRedshiftQuerySpanUsesOmniPath(t *testing.T) {
}, span.Results)
}
+func TestRedshiftQuerySpanUnsyncedDatabase(t *testing.T) {
+ _, err := GetQuerySpan(context.Background(), base.GetQuerySpanContext{
+ GetDatabaseMetadataFunc: func(context.Context, string, string) (string, *model.DatabaseMetadata, error) {
+ return "", nil, nil
+ },
+ ListDatabaseNamesFunc: func(context.Context, string) ([]string, error) {
+ return []string{"db"}, nil
+ },
+ }, base.Statement{Text: "SELECT id FROM orders"}, "db", "", false)
+ require.ErrorContains(t, err, `database metadata for database "db" not found (database not synced)`)
+}
+
func TestRedshiftOmniQuerySpanDefaultSearchPath(t *testing.T) {
span, err := newOmniQuerySpanExtractor("db", nil, redshiftOmniQuerySpanContext(t)).getOmniQuerySpan(context.Background(), "SELECT id FROM orders")
require.NoError(t, err)
diff --git a/backend/plugin/parser/snowflake/query_span_extractor.go b/backend/plugin/parser/snowflake/query_span_extractor.go
index adbc4d1ae7..94a1697c46 100644
--- a/backend/plugin/parser/snowflake/query_span_extractor.go
+++ b/backend/plugin/parser/snowflake/query_span_extractor.go
@@ -1046,6 +1046,9 @@ func (q *querySpanExtractor) findTableSchema(objectName *ast.ObjectName, normali
if err != nil {
return "", nil, errors.Wrapf(err, "failed to get database %s", normalizedDatabaseName)
}
+ if database == nil {
+ return "", nil, errors.Errorf("database metadata for database %q not found (database not synced)", normalizedDatabaseName)
+ }
allSchemaNames := database.ListSchemaNames()
for _, schemaSchema := range allSchemaNames {
if normalizedSchemaName != "" && normalizedSchemaName != schemaSchema {
diff --git a/backend/plugin/parser/snowflake/query_span_test.go b/backend/plugin/parser/snowflake/query_span_test.go
index 6ab0e7b8ea..2ffd1d5135 100644
--- a/backend/plugin/parser/snowflake/query_span_test.go
+++ b/backend/plugin/parser/snowflake/query_span_test.go
@@ -107,6 +107,18 @@ func buildMockDatabaseMetadataGetter(databaseMetadata []*metadatapb.DatabaseSche
}
}
+func TestGetQuerySpan_UnsyncedDatabase(t *testing.T) {
+ _, err := GetQuerySpan(context.Background(), base.GetQuerySpanContext{
+ GetDatabaseMetadataFunc: func(context.Context, string, string) (string, *model.DatabaseMetadata, error) {
+ return "", nil, nil
+ },
+ ListDatabaseNamesFunc: func(context.Context, string) ([]string, error) {
+ return []string{"DB1"}, nil
+ },
+ }, base.Statement{Text: "SELECT * FROM T1"}, "DB1", "PUBLIC", false)
+ require.ErrorContains(t, err, `database metadata for database "DB1" not found (database not synced)`)
+}
+
// TestGetQuerySpan_PivotFailsClosed locks the PIVOT/UNPIVOT fail-closed
// behavior: until pivot projection lineage is implemented, GetQuerySpan must
// return an explicit error for pivoted table sources — never silently resolve
diff --git a/backend/plugin/parser/tsql/completion.go b/backend/plugin/parser/tsql/completion.go
index a0f7591daf..66443fb82b 100644
--- a/backend/plugin/parser/tsql/completion.go
+++ b/backend/plugin/parser/tsql/completion.go
@@ -137,7 +137,7 @@ func (m CompletionMap) insertMetadataSchemas(c *Completer, linkedServer string,
}
_, databaseMetadata, err := c.metadataGetter(c.ctx, c.instanceID, anchor)
- if err != nil {
+ if err != nil || databaseMetadata == nil {
return
}
@@ -161,7 +161,7 @@ func (m CompletionMap) insertMetadataTables(c *Completer, linkedServer string, d
func (m CompletionMap) insertAllColumns(c *Completer) {
_, databaseMeta, err := c.metadataGetter(c.ctx, c.instanceID, c.defaultDatabase)
- if err != nil {
+ if err != nil || databaseMeta == nil {
return
}
for _, schema := range databaseMeta.ListSchemaNames() {
diff --git a/backend/plugin/parser/tsql/completion_test.go b/backend/plugin/parser/tsql/completion_test.go
index 21b61ea671..84480e8072 100644
--- a/backend/plugin/parser/tsql/completion_test.go
+++ b/backend/plugin/parser/tsql/completion_test.go
@@ -124,6 +124,26 @@ func TestCompletionOmniTableRefRule(t *testing.T) {
})
}
+func TestCompletionUnsyncedDatabase(t *testing.T) {
+ for _, input := range []string{"SELECT * FROM |", "SELECT |"} {
+ statement, caretLine, caretPosition := getCaretPosition(input)
+ results, err := Completion(context.Background(), base.CompletionContext{
+ Scene: base.SceneTypeAll,
+ DefaultDatabase: "Company",
+ Metadata: func(context.Context, string, string) (string, *model.DatabaseMetadata, error) {
+ return "", nil, nil
+ },
+ ListDatabaseNames: func(context.Context, string) ([]string, error) {
+ return []string{"Company"}, nil
+ },
+ }, statement, caretLine, caretPosition)
+ require.NoError(t, err, input)
+ for _, candidate := range results {
+ require.NotContains(t, []base.CandidateType{base.CandidateTypeSchema, base.CandidateTypeTable, base.CandidateTypeColumn}, candidate.Type, input)
+ }
+ }
+}
+
func TestCompletionDoesNotDependOnANTLR(t *testing.T) {
content, err := os.ReadFile("completion.go")
require.NoError(t, err)
diff --git a/backend/plugin/parser/tsql/query_span_extractor.go b/backend/plugin/parser/tsql/query_span_extractor.go
index 8e20880d4f..4ae721e119 100644
--- a/backend/plugin/parser/tsql/query_span_extractor.go
+++ b/backend/plugin/parser/tsql/query_span_extractor.go
@@ -109,6 +109,9 @@ func (q *querySpanExtractor) tsqlFindTableSchemaByParts(linkedServer, rawDatabas
if err != nil {
return nil, errors.Wrapf(err, "failed to get database %s metadata", databaseName)
}
+ if databaseMeta == nil {
+ return nil, errors.Errorf("database metadata for database %q not found (database not synced)", databaseName)
+ }
for _, schemaName := range databaseMeta.ListSchemaNames() {
if schema != "" && !q.isIdentifierEqual(schema, schemaName) {
diff --git a/backend/plugin/parser/tsql/query_span_test.go b/backend/plugin/parser/tsql/query_span_test.go
index 1c692f5aa8..0836cd128d 100644
--- a/backend/plugin/parser/tsql/query_span_test.go
+++ b/backend/plugin/parser/tsql/query_span_test.go
@@ -102,6 +102,54 @@ func buildMockDatabaseMetadataGetter(databaseMetadata []*metadatapb.DatabaseSche
}
}
+func TestGetQuerySpanUnsyncedDatabase(t *testing.T) {
+ synced := &metadatapb.DatabaseSchemaMetadata{
+ Name: "db",
+ Schemas: []*metadatapb.SchemaMetadata{{
+ Name: "dbo",
+ Tables: []*metadatapb.TableMetadata{{Name: "t", Columns: []*metadatapb.ColumnMetadata{{Name: "a"}}}},
+ }},
+ }
+ syncedGetter, _ := buildMockDatabaseMetadataGetter([]*metadatapb.DatabaseSchemaMetadata{synced})
+ gCtx := base.GetQuerySpanContext{
+ GetDatabaseMetadataFunc: func(ctx context.Context, instanceID, databaseName string) (string, *model.DatabaseMetadata, error) {
+ if databaseName == "appdb" {
+ return "", nil, nil
+ }
+ return syncedGetter(ctx, instanceID, databaseName)
+ },
+ ListDatabaseNamesFunc: func(context.Context, string) ([]string, error) {
+ return []string{"db", "appdb"}, nil
+ },
+ TempTables: make(map[string]*base.PhysicalTable),
+ }
+ const notSynced = `database metadata for database "appdb" not found (database not synced)`
+
+ tests := []struct {
+ name string
+ statement string
+ defaultDatabase string
+ wantErr string
+ wantNotFound bool
+ }{
+ {name: "table in the unsynced connected database", statement: "SELECT * FROM t", defaultDatabase: "appdb", wantErr: notSynced},
+ {name: "cross-database reference to an unsynced database", statement: "SELECT * FROM appdb.dbo.t", defaultDatabase: "db", wantErr: notSynced},
+ {name: "statement that reads no table", statement: "SELECT 1", defaultDatabase: "appdb"},
+ {name: "table missing from a synced database", statement: "SELECT * FROM missing", defaultDatabase: "db", wantNotFound: true},
+ }
+ for _, tc := range tests {
+ t.Run(tc.name, func(t *testing.T) {
+ span, err := GetQuerySpan(context.Background(), gCtx, base.Statement{Text: tc.statement}, tc.defaultDatabase, "dbo", true)
+ if tc.wantErr != "" {
+ require.ErrorContains(t, err, tc.wantErr)
+ return
+ }
+ require.NoError(t, err)
+ require.Equal(t, tc.wantNotFound, span.NotFoundError != nil)
+ })
+ }
+}
+
func TestGetQuerySpanCyclicViewReference(t *testing.T) {
metadata := &metadatapb.DatabaseSchemaMetadata{
Name: "db",