Skip to content

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

refactor: rename dbSchema variables to dbMetadata for consistency (#18140)

Danny Xu72f15e614797
diff --git a/backend/api/lsp/completion.go b/backend/api/lsp/completion.go
index 95759d1f5e..01c082fc50 100644
--- a/backend/api/lsp/completion.go
+++ b/backend/api/lsp/completion.go
@@ -168,7 +168,7 @@ func (h *Handler) GetDatabaseMetadataFunc(ctx context.Context, instanceID, datab
if metadata == nil {
return "", nil, errors.Errorf("database %s schema for instance %s not found", databaseName, instanceID)
}
- return databaseName, metadata.GetDatabaseMetadata(), nil
+ return databaseName, metadata, nil
}
func (h *Handler) ListDatabaseNamesFunc(ctx context.Context, instanceID string) ([]string, error) {
diff --git a/backend/api/v1/database_catalog_service.go b/backend/api/v1/database_catalog_service.go
index 3f7728f0a2..08d500b646 100644
--- a/backend/api/v1/database_catalog_service.go
+++ b/backend/api/v1/database_catalog_service.go
@@ -41,20 +41,20 @@ func (s *DatabaseCatalogService) GetDatabaseCatalog(ctx context.Context, req *co
if err != nil {
return nil, connect.NewError(connect.CodeInternal, err)
}
- dbSchema, err := s.store.GetDBSchema(ctx, &store.FindDBSchemaMessage{
+ dbMetadata, err := s.store.GetDBSchema(ctx, &store.FindDBSchemaMessage{
InstanceID: database.InstanceID,
DatabaseName: database.DatabaseName,
})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, err)
}
- if dbSchema == nil {
+ if dbMetadata == nil {
return connect.NewResponse(&v1pb.DatabaseCatalog{
Name: fmt.Sprintf("%s%s/%s%s%s", common.InstanceNamePrefix, database.InstanceID, common.DatabaseIDPrefix, database.DatabaseName, common.CatalogSuffix),
}), nil
}
- return connect.NewResponse(convertDatabaseConfig(database, dbSchema.GetConfig())), nil
+ return connect.NewResponse(convertDatabaseConfig(database, dbMetadata.GetConfig())), nil
}
// UpdateDatabaseCatalog updates a database catalog.
@@ -69,14 +69,14 @@ func (s *DatabaseCatalogService) UpdateDatabaseCatalog(ctx context.Context, req
return nil, connect.NewError(connect.CodeInternal, err)
}
- dbSchema, err := s.store.GetDBSchema(ctx, &store.FindDBSchemaMessage{
+ dbMetadata, err := s.store.GetDBSchema(ctx, &store.FindDBSchemaMessage{
InstanceID: database.InstanceID,
DatabaseName: database.DatabaseName,
})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, err)
}
- if dbSchema == nil {
+ if dbMetadata == nil {
return nil, connect.NewError(connect.CodeFailedPrecondition, errors.New("database schema metadata not found"))
}
diff --git a/backend/api/v1/database_service.go b/backend/api/v1/database_service.go
index 9fd7e4bb43..d9f2417104 100644
--- a/backend/api/v1/database_service.go
+++ b/backend/api/v1/database_service.go
@@ -589,14 +589,14 @@ func (s *DatabaseService) GetDatabaseMetadata(ctx context.Context, req *connect.
if database.Deleted {
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("database %q was deleted", name))
}
- dbSchema, err := s.store.GetDBSchema(ctx, &store.FindDBSchemaMessage{
+ dbMetadata, err := s.store.GetDBSchema(ctx, &store.FindDBSchemaMessage{
InstanceID: database.InstanceID,
DatabaseName: database.DatabaseName,
})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("%v", err.Error()))
}
- if dbSchema == nil {
+ if dbMetadata == nil {
if err := s.schemaSyncer.SyncDatabaseSchema(ctx, database); err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to sync database schema for database %q, error %v", name, err))
}
@@ -610,14 +610,14 @@ func (s *DatabaseService) GetDatabaseMetadata(ctx context.Context, req *connect.
if newDBSchema == nil {
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("database schema %q not found", name))
}
- dbSchema = newDBSchema
+ dbMetadata = newDBSchema
}
filter, err := getDatabaseMetadataFilter(req.Msg.Filter)
if err != nil {
return nil, err
}
- v1pbMetadata := convertStoreDatabaseMetadata(dbSchema.GetMetadata(), filter, int(req.Msg.Limit))
+ v1pbMetadata := convertStoreDatabaseMetadata(dbMetadata.GetMetadata(), filter, int(req.Msg.Limit))
v1pbMetadata.Name = fmt.Sprintf("%s%s/%s%s%s", common.InstanceNamePrefix, database.InstanceID, common.DatabaseIDPrefix, database.DatabaseName, common.MetadataSuffix)
return connect.NewResponse(v1pbMetadata), nil
@@ -647,14 +647,14 @@ func (s *DatabaseService) GetDatabaseSchema(ctx context.Context, req *connect.Re
if database == nil {
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("database %q not found", databaseName))
}
- dbSchema, err := s.store.GetDBSchema(ctx, &store.FindDBSchemaMessage{
+ dbMetadata, err := s.store.GetDBSchema(ctx, &store.FindDBSchemaMessage{
InstanceID: database.InstanceID,
DatabaseName: database.DatabaseName,
})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("%v", err.Error()))
}
- if dbSchema == nil {
+ if dbMetadata == nil {
if err := s.schemaSyncer.SyncDatabaseSchema(ctx, database); err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to sync database schema for database %q, error %v", databaseName, err))
}
@@ -668,9 +668,9 @@ func (s *DatabaseService) GetDatabaseSchema(ctx context.Context, req *connect.Re
if newDBSchema == nil {
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("database schema %q not found", databaseName))
}
- dbSchema = newDBSchema
+ dbMetadata = newDBSchema
}
- schemaString := string(dbSchema.GetSchema())
+ schemaString := string(dbMetadata.GetSchema())
return connect.NewResponse(&v1pb.DatabaseSchema{Schema: schemaString}), nil
}
@@ -701,14 +701,14 @@ func (s *DatabaseService) GetDatabaseSDLSchema(ctx context.Context, req *connect
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("database %q not found", databaseName))
}
- dbSchema, err := s.store.GetDBSchema(ctx, &store.FindDBSchemaMessage{
+ dbMetadata, err := s.store.GetDBSchema(ctx, &store.FindDBSchemaMessage{
InstanceID: database.InstanceID,
DatabaseName: database.DatabaseName,
})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("%v", err.Error()))
}
- if dbSchema == nil {
+ if dbMetadata == nil {
if err := s.schemaSyncer.SyncDatabaseSchema(ctx, database); err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to sync database schema for database %q, error %v", databaseName, err))
}
@@ -722,10 +722,10 @@ func (s *DatabaseService) GetDatabaseSDLSchema(ctx context.Context, req *connect
if newDBSchema == nil {
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("database schema %q not found", databaseName))
}
- dbSchema = newDBSchema
+ dbMetadata = newDBSchema
}
- metadata := dbSchema.GetMetadata()
+ metadata := dbMetadata.GetMetadata()
if metadata == nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("database metadata not found for database %q", databaseName))
}
@@ -748,12 +748,12 @@ func (s *DatabaseService) GetDatabaseSDLSchema(ctx context.Context, req *connect
// DiffSchema diff the database schema.
func (s *DatabaseService) DiffSchema(ctx context.Context, req *connect.Request[v1pb.DiffSchemaRequest]) (*connect.Response[v1pb.DiffSchemaResponse], error) {
// Use unified SDL-based approach for all scenarios
- sourceDBSchema, err := s.getSourceDBSchema(ctx, req.Msg)
+ sourceDBSchema, err := s.getSourceDBMetadata(ctx, req.Msg)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get source schema, error: %v", err))
}
- targetDBSchema, err := s.getTargetDBSchema(ctx, req.Msg)
+ targetDBSchema, err := s.getTargetDBMetadata(ctx, req.Msg)
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to get target schema, error: %v", err))
}
@@ -783,7 +783,7 @@ func (s *DatabaseService) DiffSchema(ctx context.Context, req *connect.Request[v
}), nil
}
-func (s *DatabaseService) getSourceDBSchema(ctx context.Context, request *v1pb.DiffSchemaRequest) (*model.DatabaseSchema, error) {
+func (s *DatabaseService) getSourceDBMetadata(ctx context.Context, request *v1pb.DiffSchemaRequest) (*model.DatabaseMetadata, error) {
if strings.Contains(request.Name, common.ChangelogPrefix) {
instanceID, databaseName, changelogUID, err := common.GetInstanceDatabaseChangelogUID(request.Name)
if err != nil {
@@ -819,7 +819,7 @@ func (s *DatabaseService) getSourceDBSchema(ctx context.Context, request *v1pb.D
return nil, errors.Errorf("instance %s not found", instanceID)
}
- return model.NewDatabaseSchema(
+ return model.NewDatabaseMetadata(
syncHistory.Metadata,
[]byte(syncHistory.Schema),
&storepb.DatabaseConfig{},
@@ -829,17 +829,17 @@ func (s *DatabaseService) getSourceDBSchema(ctx context.Context, request *v1pb.D
}
// Fallback to current database schema if no sync history
- dbSchema, err := s.store.GetDBSchema(ctx, &store.FindDBSchemaMessage{
+ dbMetadata, err := s.store.GetDBSchema(ctx, &store.FindDBSchemaMessage{
InstanceID: instanceID,
DatabaseName: databaseName,
})
if err != nil {
return nil, err
}
- if dbSchema == nil {
+ if dbMetadata == nil {
return nil, errors.Errorf("database schema not found for %s/%s", instanceID, databaseName)
}
- return dbSchema, nil
+ return dbMetadata, nil
}
instanceID, databaseName, err := common.GetInstanceDatabaseID(request.Name)
@@ -847,20 +847,20 @@ func (s *DatabaseService) getSourceDBSchema(ctx context.Context, request *v1pb.D
return nil, err
}
- dbSchema, err := s.store.GetDBSchema(ctx, &store.FindDBSchemaMessage{
+ dbMetadata, err := s.store.GetDBSchema(ctx, &store.FindDBSchemaMessage{
InstanceID: instanceID,
DatabaseName: databaseName,
})
if err != nil {
return nil, err
}
- if dbSchema == nil {
+ if dbMetadata == nil {
return nil, errors.Errorf("database schema not found for %s/%s", instanceID, databaseName)
}
- return dbSchema, nil
+ return dbMetadata, nil
}
-func (s *DatabaseService) getTargetDBSchema(ctx context.Context, request *v1pb.DiffSchemaRequest) (*model.DatabaseSchema, error) {
+func (s *DatabaseService) getTargetDBMetadata(ctx context.Context, request *v1pb.DiffSchemaRequest) (*model.DatabaseMetadata, error) {
changeHistoryID := request.GetChangelog()
// If the change history id is set, use the schema of the change history as the target.
@@ -899,7 +899,7 @@ func (s *DatabaseService) getTargetDBSchema(ctx context.Context, request *v1pb.D
return nil, errors.Errorf("instance %s not found", instanceID)
}
- return model.NewDatabaseSchema(
+ return model.NewDatabaseMetadata(
syncHistory.Metadata,
[]byte(syncHistory.Schema),
&storepb.DatabaseConfig{},
@@ -909,17 +909,17 @@ func (s *DatabaseService) getTargetDBSchema(ctx context.Context, request *v1pb.D
}
// Fallback to current database schema if no sync history
- dbSchema, err := s.store.GetDBSchema(ctx, &store.FindDBSchemaMessage{
+ dbMetadata, err := s.store.GetDBSchema(ctx, &store.FindDBSchemaMessage{
InstanceID: instanceID,
DatabaseName: databaseName,
})
if err != nil {
return nil, err
}
- if dbSchema == nil {
+ if dbMetadata == nil {
return nil, errors.Errorf("database schema not found for %s/%s", instanceID, databaseName)
}
- return dbSchema, nil
+ return dbMetadata, nil
}
// If schema is provided, we need to parse it using GetDatabaseMetadata
@@ -951,7 +951,7 @@ func (s *DatabaseService) getTargetDBSchema(ctx context.Context, request *v1pb.D
}
// Create DatabaseSchema from the parsed metadata
- return model.NewDatabaseSchema(
+ return model.NewDatabaseMetadata(
metadata,
[]byte(schemaStr),
&storepb.DatabaseConfig{},
@@ -1105,7 +1105,7 @@ func (s *DatabaseService) GetSchemaString(ctx context.Context, req *connect.Requ
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("instance %q not found", database.InstanceID))
}
- dbSchema, err := s.store.GetDBSchema(ctx, &store.FindDBSchemaMessage{
+ dbMetadata, err := s.store.GetDBSchema(ctx, &store.FindDBSchemaMessage{
InstanceID: database.InstanceID,
DatabaseName: database.DatabaseName,
})
@@ -1128,7 +1128,7 @@ func (s *DatabaseService) GetSchemaString(ctx context.Context, req *connect.Requ
}
return connect.NewResponse(&v1pb.GetSchemaStringResponse{SchemaString: s}), nil
case v1pb.GetSchemaStringRequest_DATABASE:
- metadata := dbSchema.GetMetadata()
+ metadata := dbMetadata.GetMetadata()
s, err := schema.GetDatabaseDefinition(instance.Metadata.Engine, schema.GetDefinitionContext{
SkipBackupSchema: false,
PrintHeader: false,
@@ -1138,7 +1138,7 @@ func (s *DatabaseService) GetSchemaString(ctx context.Context, req *connect.Requ
}
return connect.NewResponse(&v1pb.GetSchemaStringResponse{SchemaString: s}), nil
case v1pb.GetSchemaStringRequest_SCHEMA:
- schemaMetadata := dbSchema.GetDatabaseMetadata().GetSchema(req.Msg.Schema)
+ schemaMetadata := dbMetadata.GetSchemaMetadata(req.Msg.Schema)
if schemaMetadata == nil {
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("schema %q not found", req.Msg.Schema))
}
@@ -1149,7 +1149,7 @@ func (s *DatabaseService) GetSchemaString(ctx context.Context, req *connect.Requ
}
return connect.NewResponse(&v1pb.GetSchemaStringResponse{SchemaString: s}), nil
case v1pb.GetSchemaStringRequest_TABLE:
- schemaMetadata := dbSchema.GetDatabaseMetadata().GetSchema(req.Msg.Schema)
+ schemaMetadata := dbMetadata.GetSchemaMetadata(req.Msg.Schema)
if schemaMetadata == nil {
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("schema %q not found", req.Msg.Schema))
}
@@ -1168,7 +1168,7 @@ func (s *DatabaseService) GetSchemaString(ctx context.Context, req *connect.Requ
}
return connect.NewResponse(&v1pb.GetSchemaStringResponse{SchemaString: s}), nil
case v1pb.GetSchemaStringRequest_VIEW:
- schemaMetadata := dbSchema.GetDatabaseMetadata().GetSchema(req.Msg.Schema)
+ schemaMetadata := dbMetadata.GetSchemaMetadata(req.Msg.Schema)
if schemaMetadata == nil {
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("schema %q not found", req.Msg.Schema))
}
@@ -1182,7 +1182,7 @@ func (s *DatabaseService) GetSchemaString(ctx context.Context, req *connect.Requ
}
return connect.NewResponse(&v1pb.GetSchemaStringResponse{SchemaString: s}), nil
case v1pb.GetSchemaStringRequest_MATERIALIZED_VIEW:
- schemaMetadata := dbSchema.GetDatabaseMetadata().GetSchema(req.Msg.Schema)
+ schemaMetadata := dbMetadata.GetSchemaMetadata(req.Msg.Schema)
if schemaMetadata == nil {
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("schema %q not found", req.Msg.Schema))
}
@@ -1196,7 +1196,7 @@ func (s *DatabaseService) GetSchemaString(ctx context.Context, req *connect.Requ
}
return connect.NewResponse(&v1pb.GetSchemaStringResponse{SchemaString: s}), nil
case v1pb.GetSchemaStringRequest_FUNCTION:
- schemaMetadata := dbSchema.GetDatabaseMetadata().GetSchema(req.Msg.Schema)
+ schemaMetadata := dbMetadata.GetSchemaMetadata(req.Msg.Schema)
if schemaMetadata == nil {
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("schema %q not found", req.Msg.Schema))
}
@@ -1210,7 +1210,7 @@ func (s *DatabaseService) GetSchemaString(ctx context.Context, req *connect.Requ
}
return connect.NewResponse(&v1pb.GetSchemaStringResponse{SchemaString: s}), nil
case v1pb.GetSchemaStringRequest_PROCEDURE:
- schemaMetadata := dbSchema.GetDatabaseMetadata().GetSchema(req.Msg.Schema)
+ schemaMetadata := dbMetadata.GetSchemaMetadata(req.Msg.Schema)
if schemaMetadata == nil {
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("schema %q not found", req.Msg.Schema))
}
@@ -1224,7 +1224,7 @@ func (s *DatabaseService) GetSchemaString(ctx context.Context, req *connect.Requ
}
return connect.NewResponse(&v1pb.GetSchemaStringResponse{SchemaString: s}), nil
case v1pb.GetSchemaStringRequest_SEQUENCE:
- schemaMetadata := dbSchema.GetDatabaseMetadata().GetSchema(req.Msg.Schema)
+ schemaMetadata := dbMetadata.GetSchemaMetadata(req.Msg.Schema)
if schemaMetadata == nil {
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("schema %q not found", req.Msg.Schema))
}
diff --git a/backend/api/v1/query_result_masker.go b/backend/api/v1/query_result_masker.go
index 43907d2a3b..1543478a6d 100644
--- a/backend/api/v1/query_result_masker.go
+++ b/backend/api/v1/query_result_masker.go
@@ -320,23 +320,19 @@ func (s *QueryResultMasker) getColumnForColumnResource(ctx context.Context, inst
if database == nil {
return nil, nil, nil
}
- dbSchema, err := s.store.GetDBSchema(ctx, &store.FindDBSchemaMessage{
+ dbMetadata, err := s.store.GetDBSchema(ctx, &store.FindDBSchemaMessage{
InstanceID: database.InstanceID,
DatabaseName: database.DatabaseName,
})
if err != nil {
return nil, nil, errors.Wrapf(err, "failed to find database schema: %q", sourceColumn.Database)
}
- if dbSchema == nil {
+ if dbMetadata == nil {
return nil, nil, nil
}
var columnMetadata *storepb.ColumnMetadata
- metadata := dbSchema.GetDatabaseMetadata()
- if metadata == nil {
- return nil, nil, nil
- }
- schema := metadata.GetSchema(sourceColumn.Schema)
+ schema := dbMetadata.GetSchemaMetadata(sourceColumn.Schema)
if schema == nil {
return nil, nil, nil
}
@@ -351,11 +347,7 @@ func (s *QueryResultMasker) getColumnForColumnResource(ctx context.Context, inst
columnMetadata = column
var columnConfig *storepb.ColumnCatalog
- config := dbSchema.GetInternalConfig()
- if config == nil {
- return columnMetadata, nil, nil
- }
- schemaConfig := config.GetSchemaConfig(sourceColumn.Schema)
+ schemaConfig := dbMetadata.GetSchemaConfig(sourceColumn.Schema)
tableConfig := schemaConfig.GetTableConfig(sourceColumn.Table)
columnConfig = tableConfig.GetColumnConfig(sourceColumn.Column)
return columnMetadata, columnConfig, nil
diff --git a/backend/api/v1/release_service_check.go b/backend/api/v1/release_service_check.go
index 1513028df1..a648e13601 100644
--- a/backend/api/v1/release_service_check.go
+++ b/backend/api/v1/release_service_check.go
@@ -163,25 +163,25 @@ loop:
engine := instance.Metadata.GetEngine()
// Get the database metadata
- dbSchema, err := s.store.GetDBSchema(ctx, &store.FindDBSchemaMessage{
+ dbMetadata, err := s.store.GetDBSchema(ctx, &store.FindDBSchemaMessage{
InstanceID: database.InstanceID,
DatabaseName: database.DatabaseName,
})
if err != nil {
return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get database schema"))
}
- if dbSchema == nil {
+ if dbMetadata == nil {
return nil, connect.NewError(connect.CodeNotFound, errors.Errorf("database schema not found for %s", database.DatabaseName))
}
// Create original metadata as read-only
- originMetadata := model.NewDatabaseMetadata(dbSchema.GetMetadata(), engine, store.IsObjectCaseSensitive(instance))
+ originMetadata := model.NewDatabaseMetadata(dbMetadata.GetMetadata(), nil, nil, engine, store.IsObjectCaseSensitive(instance))
// Clone metadata for final to avoid modifying the original
- clonedMetadata, ok := proto.Clone(dbSchema.GetMetadata()).(*storepb.DatabaseSchemaMetadata)
+ clonedMetadata, ok := proto.Clone(dbMetadata.GetMetadata()).(*storepb.DatabaseSchemaMetadata)
if !ok {
return nil, connect.NewError(connect.CodeInternal, errors.New("failed to clone database schema metadata"))
}
- finalMetadata := model.NewDatabaseMetadata(clonedMetadata, engine, store.IsObjectCaseSensitive(instance))
+ finalMetadata := model.NewDatabaseMetadata(clonedMetadata, nil, nil, engine, store.IsObjectCaseSensitive(instance))
// Batch fetch all revisions for this database
revisions, err := s.store.ListRevisions(ctx, &store.FindRevisionMessage{
InstanceID: &database.InstanceID,
@@ -627,30 +627,30 @@ func (s *ReleaseService) runSQLReviewCheckForFile(
changeType storepb.PlanCheckRunConfig_ChangeDatabaseType,
statement string,
) (storepb.Advice_Status, []*v1pb.Advice, error) {
- dbSchema, err := s.store.GetDBSchema(ctx, &store.FindDBSchemaMessage{
+ dbMetadata, err := s.store.GetDBSchema(ctx, &store.FindDBSchemaMessage{
InstanceID: database.InstanceID,
DatabaseName: database.DatabaseName,
})
if err != nil {
return storepb.Advice_ERROR, nil, errors.Wrapf(err, "failed to fetch database schema for database %s", database.String())
}
- if dbSchema == nil {
+ if dbMetadata == nil {
if err := s.schemaSyncer.SyncDatabaseSchema(ctx, database); err != nil {
return storepb.Advice_ERROR, nil, errors.Wrapf(err, "failed to sync database schema for database %s", database.String())
}
- dbSchema, err = s.store.GetDBSchema(ctx, &store.FindDBSchemaMessage{
+ dbMetadata, err = s.store.GetDBSchema(ctx, &store.FindDBSchemaMessage{
InstanceID: database.InstanceID,
DatabaseName: database.DatabaseName,
})
if err != nil {
return storepb.Advice_ERROR, nil, errors.Wrapf(err, "failed to fetch database schema for database %s", database.String())
}
- if dbSchema == nil {
+ if dbMetadata == nil {
return storepb.Advice_ERROR, nil, errors.Wrapf(err, "cannot found schema for database %s", database.String())
}
}
- dbMetadata := dbSchema.GetMetadata()
+ dbMetadataProto := dbMetadata.GetMetadata()
useDatabaseOwner, err := getUseDatabaseOwner(ctx, s.store, instance, database)
if err != nil {
return storepb.Advice_ERROR, nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to get use database owner"))
@@ -664,10 +664,10 @@ func (s *ReleaseService) runSQLReviewCheckForFile(
classificationConfig := getClassificationByProject(ctx, s.store, database.ProjectID)
context := advisor.SQLReviewCheckContext{
- Charset: dbMetadata.CharacterSet,
- Collation: dbMetadata.Collation,
+ Charset: dbMetadataProto.CharacterSet,
+ Collation: dbMetadataProto.Collation,
ChangeType: changeType,
- DBSchema: dbMetadata,
+ DBSchema: dbMetadataProto,
DBType: instance.Metadata.GetEngine(),
OriginalMetadata: originMetadata,
FinalMetadata: finalMetadata,
diff --git a/backend/api/v1/sql_service.go b/backend/api/v1/sql_service.go
index aa055c4141..f3763d47b9 100644
--- a/backend/api/v1/sql_service.go
+++ b/backend/api/v1/sql_service.go
@@ -357,14 +357,14 @@ func extractSourceTable(comment string) (string, string, string, error) {
return "", "", "", errors.Errorf("failed to extract source table from comment: %s", comment)
}
-func getSchemaMetadata(engine storepb.Engine, dbSchema *model.DatabaseSchema) *model.SchemaMetadata {
+func getSchemaMetadata(engine storepb.Engine, dbMetadata *model.DatabaseMetadata) *model.SchemaMetadata {
switch engine {
case storepb.Engine_POSTGRES:
- return dbSchema.GetDatabaseMetadata().GetSchema(common.BackupDatabaseNameOfEngine(storepb.Engine_POSTGRES))
+ return dbMetadata.GetSchemaMetadata(common.BackupDatabaseNameOfEngine(storepb.Engine_POSTGRES))
case storepb.Engine_MSSQL:
- return dbSchema.GetDatabaseMetadata().GetSchema("dbo")
+ return dbMetadata.GetSchemaMetadata("dbo")
default:
- return dbSchema.GetDatabaseMetadata().GetSchema("")
+ return dbMetadata.GetSchemaMetadata("")
}
}
@@ -382,14 +382,14 @@ func replaceBackupTableWithSource(ctx context.Context, stores *store.Store, inst
return nil
}
}
- dbSchema, err := stores.GetDBSchema(ctx, &store.FindDBSchemaMessage{
+ dbMetadata, err := stores.GetDBSchema(ctx, &store.FindDBSchemaMessage{
InstanceID: database.InstanceID,
DatabaseName: database.DatabaseName,
})
if err != nil {
return err
}
- schema := getSchemaMetadata(instance.Metadata.GetEngine(), dbSchema)
+ schema := getSchemaMetadata(instance.Metadata.GetEngine(), dbMetadata)
if schema == nil {
return nil
}
@@ -686,7 +686,7 @@ func queryRetry(
}
func getCosmosDBContainerObjectSchema(ctx context.Context, stores *store.Store, instanceID string, databaseName string, containerName string) (*storepb.ObjectSchema, error) {
- dbSchema, err := stores.GetDBSchema(ctx, &store.FindDBSchemaMessage{
+ dbMetadata, err := stores.GetDBSchema(ctx, &store.FindDBSchemaMessage{
InstanceID: instanceID,
DatabaseName: databaseName,
})
@@ -694,11 +694,11 @@ func getCosmosDBContainerObjectSchema(ctx context.Context, stores *store.Store,
return nil, errors.Wrapf(err, "failed to get database schema: %q", databaseName)
}
- if dbSchema == nil {
+ if dbMetadata == nil {
return nil, nil
}
- schemas := dbSchema.GetConfig().GetSchemas()
+ schemas := dbMetadata.GetConfig().GetSchemas()
if len(schemas) == 0 {
return nil, nil
}
@@ -1343,7 +1343,7 @@ func BuildGetLinkedDatabaseMetadataFunc(storeInstance *store.Store, engine store
if err != nil {
return "", "", nil, err
}
- if linkedMeta = meta.GetDatabaseMetadata().GetLinkedDatabase(linkedDatabaseName); linkedMeta != nil {
+ if linkedMeta = meta.GetLinkedDatabase(linkedDatabaseName); linkedMeta != nil {
break
}
}
@@ -1394,7 +1394,7 @@ func BuildGetLinkedDatabaseMetadataFunc(storeInstance *store.Store, engine store
if linkedDatabaseMetadata == nil {
return "", "", nil, nil
}
- return linkedDatabase.InstanceID, linkedDatabaseName, linkedDatabaseMetadata.GetDatabaseMetadata(), nil
+ return linkedDatabase.InstanceID, linkedDatabaseName, linkedDatabaseMetadata, nil
}
}
@@ -1420,7 +1420,7 @@ func BuildGetDatabaseMetadataFunc(storeInstance *store.Store) parserbase.GetData
if databaseMetadata == nil {
return "", nil, nil
}
- return databaseName, databaseMetadata.GetDatabaseMetadata(), nil
+ return databaseName, databaseMetadata, nil
}
}
@@ -1724,7 +1724,7 @@ func (*SQLService) DiffMetadata(_ context.Context, req *connect.Request[v1pb.Dif
storeSourceMetadata := convertV1DatabaseMetadata(request.SourceMetadata)
sourceConfig := convertDatabaseCatalog(request.GetSourceCatalog())
- sanitizeCommentForSchemaMetadata(storeSourceMetadata, model.NewDatabaseConfig(sourceConfig), request.ClassificationFromConfig)
+ sanitizeCommentForSchemaMetadata(storeSourceMetadata, model.NewDatabaseMetadata(storeSourceMetadata, nil, sourceConfig, storepb.Engine(request.Engine), true /* isObjectCaseSensitive */), request.ClassificationFromConfig)
storeTargetMetadata := convertV1DatabaseMetadata(request.TargetMetadata)
@@ -1732,12 +1732,12 @@ func (*SQLService) DiffMetadata(_ context.Context, req *connect.Request[v1pb.Dif
if err := checkDatabaseMetadata(storepb.Engine(request.Engine), storeTargetMetadata); err != nil {
return nil, connect.NewError(connect.CodeInvalidArgument, errors.Wrap(err, "invalid target metadata"))
}
- sanitizeCommentForSchemaMetadata(storeTargetMetadata, model.NewDatabaseConfig(targetConfig), request.ClassificationFromConfig)
+ sanitizeCommentForSchemaMetadata(storeTargetMetadata, model.NewDatabaseMetadata(storeTargetMetadata, nil, targetConfig, storepb.Engine(request.Engine), true /* isObjectCaseSensitive */), request.ClassificationFromConfig)
- // Convert metadata to model.DatabaseSchema for diffing
+ // Convert metadata to model.DatabaseMetadata for diffing
isObjectCaseSensitive := true
- sourceDBSchema := model.NewDatabaseSchema(storeSourceMetadata, nil, nil, storepb.Engine(request.Engine), isObjectCaseSensitive)
- targetDBSchema := model.NewDatabaseSchema(storeTargetMetadata, nil, nil, storepb.Engine(request.Engine), isObjectCaseSensitive)
+ sourceDBSchema := model.NewDatabaseMetadata(storeSourceMetadata, nil, nil, storepb.Engine(request.Engine), isObjectCaseSensitive)
+ targetDBSchema := model.NewDatabaseMetadata(storeTargetMetadata, nil, nil, storepb.Engine(request.Engine), isObjectCaseSensitive)
// Get the metadata diff between source and target
metadataDiff, err := schema.GetDatabaseSchemaDiff(storepb.Engine(request.Engine), sourceDBSchema, targetDBSchema)
@@ -1756,8 +1756,8 @@ func (*SQLService) DiffMetadata(_ context.Context, req *connect.Request[v1pb.Dif
}), nil
}
-func sanitizeCommentForSchemaMetadata(dbSchema *storepb.DatabaseSchemaMetadata, dbModelConfig *model.DatabaseConfig, classificationFromConfig bool) {
- for _, schema := range dbSchema.Schemas {
+func sanitizeCommentForSchemaMetadata(dbMetadata *storepb.DatabaseSchemaMetadata, dbModelConfig *model.DatabaseMetadata, classificationFromConfig bool) {
+ for _, schema := range dbMetadata.Schemas {
schemaConfig := dbModelConfig.GetSchemaConfig(schema.Name)
for _, table := range schema.Tables {
tableConfig := schemaConfig.GetTableConfig(table.Name)
diff --git a/backend/component/export/resources.go b/backend/component/export/resources.go
index 8323600f9b..85b5376a64 100644
--- a/backend/component/export/resources.go
+++ b/backend/component/export/resources.go
@@ -95,7 +95,7 @@ func getResourcesForMySQL(
return nil, nil
}
- dbSchema, err := storeInstance.GetDBSchema(ctx, &store.FindDBSchemaMessage{
+ dbMetadata, err := storeInstance.GetDBSchema(ctx, &store.FindDBSchemaMessage{
InstanceID: database.InstanceID,
DatabaseName: database.DatabaseName,
})
@@ -112,7 +112,7 @@ func getResourcesForMySQL(
Table: sourceColumn.Table,
LinkedServer: sourceColumn.Server,
}
- if sourceColumn.Database != dbSchema.GetMetadata().Name {
+ if sourceColumn.Database != dbMetadata.GetMetadata().Name {
resourceDB, err := storeInstance.GetDatabaseV2(ctx, &store.FindDatabaseMessage{
InstanceID: &instance.ResourceID,
DatabaseName: &sourceColumn.Database,
@@ -137,7 +137,7 @@ func getResourcesForMySQL(
result = append(result, sr)
continue
}
- if !resourceExists(dbSchema, sr) {
+ if !resourceExists(dbMetadata, sr) {
continue
}
result = append(result, sr)
@@ -180,7 +180,7 @@ func getResourcesForPostgres(
return nil, nil
}
- dbSchema, err := storeInstance.GetDBSchema(ctx, &store.FindDBSchemaMessage{
+ dbMetadata, err := storeInstance.GetDBSchema(ctx, &store.FindDBSchemaMessage{
InstanceID: database.InstanceID,
DatabaseName: database.DatabaseName,
})
@@ -198,11 +198,11 @@ func getResourcesForPostgres(
LinkedServer: sourceColumn.Server,
}
- if sourceColumn.Database != dbSchema.GetMetadata().Name {
+ if sourceColumn.Database != dbMetadata.GetMetadata().Name {
continue
}
- if !resourceExists(dbSchema, sr) {
+ if !resourceExists(dbMetadata, sr) {
continue
}
@@ -271,8 +271,8 @@ func getResourcesForMSSQL(
return getResourcesForPostgres(ctx, storeInstance, engine, databaseName, statement, instance, "dbo", getDatabaseMetadataFunc, listDatabaseNamesFunc, getLinkedDatabaseMetadataFunc)
}
-func resourceExists(dbSchema *model.DatabaseSchema, resource base.SchemaResource) bool {
- schema := dbSchema.GetDatabaseMetadata().GetSchema(resource.Schema)
+func resourceExists(dbMetadata *model.DatabaseMetadata, resource base.SchemaResource) bool {
+ schema := dbMetadata.GetSchemaMetadata(resource.Schema)
if schema == nil {
return false
}
diff --git a/backend/plugin/advisor/mssql/rule_index_not_redundant.go b/backend/plugin/advisor/mssql/rule_index_not_redundant.go
index 87b73372fe..2f5a9a2cf9 100644
--- a/backend/plugin/advisor/mssql/rule_index_not_redundant.go
+++ b/backend/plugin/advisor/mssql/rule_index_not_redundant.go
@@ -60,14 +60,14 @@ type IndexNotRedundantRule struct {
}
// NewIndexNotRedundantRule creates a new IndexNotRedundantRule.
-func NewIndexNotRedundantRule(level storepb.Advice_Status, title string, currentDB string, dbSchema *storepb.DatabaseSchemaMetadata) *IndexNotRedundantRule {
+func NewIndexNotRedundantRule(level storepb.Advice_Status, title string, currentDB string, dbMetadata *storepb.DatabaseSchemaMetadata) *IndexNotRedundantRule {
return &IndexNotRedundantRule{
BaseRule: BaseRule{
level: level,
title: title,
},
curDB: currentDB,
- indexMap: getIndexMapFromMetadata(dbSchema),
+ indexMap: getIndexMapFromMetadata(dbMetadata),
}
}
diff --git a/backend/plugin/advisor/mysql/rule_column_disallow_changing_type.go b/backend/plugin/advisor/mysql/rule_column_disallow_changing_type.go
index 3b3fbdf24f..5362f1baf6 100644
--- a/backend/plugin/advisor/mysql/rule_column_disallow_changing_type.go
+++ b/backend/plugin/advisor/mysql/rule_column_disallow_changing_type.go
@@ -170,7 +170,7 @@ func normalizeColumnType(tp string) string {
func (r *ColumnDisallowChangingTypeRule) changeColumnType(tableName, columnName string, dataType mysql.IDataTypeContext) {
tp := dataType.GetParser().GetTokenStream().GetTextFromRuleContext(dataType)
- column := r.originalMetadata.GetSchema("").GetTable(tableName).GetColumn(columnName)
+ column := r.originalMetadata.GetSchemaMetadata("").GetTable(tableName).GetColumn(columnName)
if column == nil {
return
}
diff --git a/backend/plugin/advisor/mysql/rule_column_disallow_drop_in_index.go b/backend/plugin/advisor/mysql/rule_column_disallow_drop_in_index.go
index 80e4a73da7..5998caaa78 100644
--- a/backend/plugin/advisor/mysql/rule_column_disallow_drop_in_index.go
+++ b/backend/plugin/advisor/mysql/rule_column_disallow_drop_in_index.go
@@ -158,7 +158,7 @@ func (r *ColumnDisallowDropInIndexRule) checkAlterTable(ctx *mysql.AlterTableCon
continue
}
- table := r.originalMetadata.GetSchema("").GetTable(tableName)
+ table := r.originalMetadata.GetSchemaMetadata("").GetTable(tableName)
if table != nil {
if r.tables[tableName] == nil {
r.tables[tableName] = make(columnSet)
diff --git a/backend/plugin/advisor/mysql/rule_column_no_null.go b/backend/plugin/advisor/mysql/rule_column_no_null.go
index f8b9b4be35..53a091d3e8 100644
--- a/backend/plugin/advisor/mysql/rule_column_no_null.go
+++ b/backend/plugin/advisor/mysql/rule_column_no_null.go
@@ -135,7 +135,7 @@ func (r *ColumnNoNullRule) generateAdvice() {
})
for _, column := range columnList {
- schema := r.finalMetadata.GetSchema("")
+ schema := r.finalMetadata.GetSchemaMetadata("")
if schema == nil {
continue
}
diff --git a/backend/plugin/advisor/mysql/rule_index_pk_type.go b/backend/plugin/advisor/mysql/rule_index_pk_type.go
index 3391e947aa..2aba4132a5 100644
--- a/backend/plugin/advisor/mysql/rule_index_pk_type.go
+++ b/backend/plugin/advisor/mysql/rule_index_pk_type.go
@@ -238,7 +238,7 @@ func (r *IndexPkTypeRule) getPKColumnType(tableName string, columnName string) (
if columnType, ok := r.tablesNewColumns.get(tableName, columnName); ok {
return columnType, nil
}
- column := r.originalMetadata.GetSchema("").GetTable(tableName).GetColumn(columnName)
+ column := r.originalMetadata.GetSchemaMetadata("").GetTable(tableName).GetColumn(columnName)
if column != nil {
return column.Type, nil
}
diff --git a/backend/plugin/advisor/mysql/rule_index_primary_key_type_allowlist.go b/backend/plugin/advisor/mysql/rule_index_primary_key_type_allowlist.go
index 0f8e7a5df8..3cdca5e648 100644
--- a/backend/plugin/advisor/mysql/rule_index_primary_key_type_allowlist.go
+++ b/backend/plugin/advisor/mysql/rule_index_primary_key_type_allowlist.go
@@ -252,7 +252,7 @@ func (r *IndexPrimaryKeyTypeAllowlistRule) getPKColumnType(tableName string, col
if columnType, ok := r.tablesNewColumns.get(tableName, columnName); ok {
return columnType, nil
}
- column := r.originalMetadata.GetSchema("").GetTable(tableName).GetColumn(columnName)
+ column := r.originalMetadata.GetSchemaMetadata("").GetTable(tableName).GetColumn(columnName)
if column != nil {
return column.Type, nil
}
diff --git a/backend/plugin/advisor/mysql/rule_index_total_number_limit.go b/backend/plugin/advisor/mysql/rule_index_total_number_limit.go
index c98524fa84..ec2e2ddb28 100644
--- a/backend/plugin/advisor/mysql/rule_index_total_number_limit.go
+++ b/backend/plugin/advisor/mysql/rule_index_total_number_limit.go
@@ -132,7 +132,7 @@ func (r *IndexTotalNumberLimitRule) generateAdvice() []*storepb.Advice {
})
for _, table := range tableList {
- schema := r.finalMetadata.GetSchema("")
+ schema := r.finalMetadata.GetSchemaMetadata("")
if schema == nil {
continue
}
diff --git a/backend/plugin/advisor/mysql/rule_index_type_no_blob.go b/backend/plugin/advisor/mysql/rule_index_type_no_blob.go
index da4671daf0..dc87ce71b0 100644
--- a/backend/plugin/advisor/mysql/rule_index_type_no_blob.go
+++ b/backend/plugin/advisor/mysql/rule_index_type_no_blob.go
@@ -295,7 +295,7 @@ func (r *IndexTypeNoBlobRule) getColumnType(tableName string, columnName string)
if columnType, ok := r.tablesNewColumns.get(tableName, columnName); ok {
return columnType, nil
}
- column := r.originalMetadata.GetSchema("").GetTable(tableName).GetColumn(columnName)
+ column := r.originalMetadata.GetSchemaMetadata("").GetTable(tableName).GetColumn(columnName)
if column != nil {
return column.Type, nil
}
diff --git a/backend/plugin/advisor/mysql/rule_naming_index_convention.go b/backend/plugin/advisor/mysql/rule_naming_index_convention.go
index dc921e922b..9f8cd92989 100644
--- a/backend/plugin/advisor/mysql/rule_naming_index_convention.go
+++ b/backend/plugin/advisor/mysql/rule_naming_index_convention.go
@@ -187,7 +187,7 @@ func (r *NamingIndexConventionRule) checkAlterTable(ctx *mysql.AlterTableContext
case alterListItem.RENAME_SYMBOL() != nil && alterListItem.KeyOrIndex() != nil && alterListItem.IndexRef() != nil && alterListItem.IndexName() != nil:
_, _, oldIndexName := mysqlparser.NormalizeIndexRef(alterListItem.IndexRef())
newIndexName := mysqlparser.NormalizeIndexName(alterListItem.IndexName())
- indexState := r.originalMetadata.GetSchema("").GetTable(tableName).GetIndex(oldIndexName)
+ indexState := r.originalMetadata.GetSchemaMetadata("").GetTable(tableName).GetIndex(oldIndexName)
if indexState == nil {
continue
}
diff --git a/backend/plugin/advisor/mysql/rule_naming_unique_key_convention.go b/backend/plugin/advisor/mysql/rule_naming_unique_key_convention.go
index 6534a2842a..d592d2fa23 100644
--- a/backend/plugin/advisor/mysql/rule_naming_unique_key_convention.go
+++ b/backend/plugin/advisor/mysql/rule_naming_unique_key_convention.go
@@ -188,7 +188,7 @@ func (r *NamingUKConventionRule) checkAlterTable(ctx *mysql.AlterTableContext) {
case alterListItem.RENAME_SYMBOL() != nil && alterListItem.KeyOrIndex() != nil && alterListItem.IndexRef() != nil && alterListItem.IndexName() != nil:
_, _, oldIndexName := mysqlparser.NormalizeIndexRef(alterListItem.IndexRef())
newIndexName := mysqlparser.NormalizeIndexName(alterListItem.IndexName())
- indexState := r.originalMetadata.GetSchema("").GetTable(tableName).GetIndex(oldIndexName)
+ indexState := r.originalMetadata.GetSchemaMetadata("").GetTable(tableName).GetIndex(oldIndexName)
if indexState == nil {
continue
}
diff --git a/backend/plugin/advisor/mysql/rule_online_migration.go b/backend/plugin/advisor/mysql/rule_online_migration.go
index dbcbb8ac67..df7f7fb0aa 100644
--- a/backend/plugin/advisor/mysql/rule_online_migration.go
+++ b/backend/plugin/advisor/mysql/rule_online_migration.go
@@ -50,7 +50,7 @@ func (*OnlineMigrationAdvisor) Check(ctx context.Context, checkCtx advisor.Conte
if err != nil {
return nil, err
}
- dbSchema := model.NewDatabaseSchema(checkCtx.DBSchema, nil, nil, storepb.Engine_MYSQL, checkCtx.IsObjectCaseSensitive)
+ dbMetadata := model.NewDatabaseMetadata(checkCtx.DBSchema, nil, nil, storepb.Engine_MYSQL, checkCtx.IsObjectCaseSensitive)
title := string(checkCtx.Rule.Type)
// Check gh-ost database existence first if the change type is gh-ost.
@@ -70,7 +70,7 @@ func (*OnlineMigrationAdvisor) Check(ctx context.Context, checkCtx advisor.Conte
}
// Create the rule
- rule := NewOnlineMigrationRule(level, title, minRows, dbSchema, checkCtx)
+ rule := NewOnlineMigrationRule(level, title, minRows, dbMetadata, checkCtx)
// Create the generic checker with the rule
checker := NewGenericChecker([]Rule{rule})
@@ -128,7 +128,7 @@ func (*OnlineMigrationAdvisor) Check(ctx context.Context, checkCtx advisor.Conte
type OnlineMigrationRule struct {
BaseRule
minRows int64
- dbSchema *model.DatabaseSchema
+ dbMetadata *model.DatabaseMetadata
checkCtx advisor.Context
currentDatabase string
changedResources map[string]parserbase.SchemaResource
@@ -138,14 +138,14 @@ type OnlineMigrationRule struct {
}
// NewOnlineMigrationRule creates a new OnlineMigrationRule.
-func NewOnlineMigrationRule(level storepb.Advice_Status, title string, minRows int64, dbSchema *model.DatabaseSchema, checkCtx advisor.Context) *OnlineMigrationRule {
+func NewOnlineMigrationRule(level storepb.Advice_Status, title string, minRows int64, dbMetadata *model.DatabaseMetadata, checkCtx advisor.Context) *OnlineMigrationRule {
return &OnlineMigrationRule{
BaseRule: BaseRule{
level: level,
title: title,
},
minRows: minRows,
- dbSchema: dbSchema,
+ dbMetadata: dbMetadata,
checkCtx: checkCtx,
currentDatabase: checkCtx.CurrentDatabase,
changedResources: make(map[string]parserbase.SchemaResource),
@@ -204,7 +204,7 @@ func (r *OnlineMigrationRule) exitAlterStatement(ctx *mysql.AlterStatementContex
for _, resource := range r.changedResources {
var tableRows int64
- for _, table := range r.dbSchema.GetMetadata().GetSchemas()[0].GetTables() {
+ for _, table := range r.dbMetadata.GetMetadata().GetSchemas()[0].GetTables() {
if table.GetName() == resource.Table {
tableRows = table.GetRowCount()
break
diff --git a/backend/plugin/advisor/mysql/rule_statement_join_strict_column_attrs.go b/backend/plugin/advisor/mysql/rule_statement_join_strict_column_attrs.go
index f919dc7627..748dc09eaa 100644
--- a/backend/plugin/advisor/mysql/rule_statement_join_strict_column_attrs.go
+++ b/backend/plugin/advisor/mysql/rule_statement_join_strict_column_attrs.go
@@ -42,8 +42,8 @@ func (*StatementJoinStrictColumnAttrsAdvisor) Check(_ context.Context, checkCtx
// Create the rule
rule := NewStatementJoinStrictColumnAttrsRule(level, string(checkCtx.Rule.Type))
if checkCtx.DBSchema != nil {
- dbSchema := model.NewDatabaseSchema(checkCtx.DBSchema, nil, nil, storepb.Engine_MYSQL, checkCtx.IsObjectCaseSensitive)
- rule.dbSchema = dbSchema
+ dbMetadata := model.NewDatabaseMetadata(checkCtx.DBSchema, nil, nil, storepb.Engine_MYSQL, checkCtx.IsObjectCaseSensitive)
+ rule.dbMetadata = dbMetadata
}
// Create the generic checker with the rule
@@ -77,7 +77,7 @@ type ColumnAttr struct {
type StatementJoinStrictColumnAttrsRule struct {
BaseRule
text string
- dbSchema *model.DatabaseSchema
+ dbMetadata *model.DatabaseMetadata
isSelect bool
isInFromClause bool
sourceTables []SourceTable
@@ -242,10 +242,10 @@ func (r *StatementJoinStrictColumnAttrsRule) checkColumnAttrs(leftColumnAttr *Co
}
func (r *StatementJoinStrictColumnAttrsRule) findTable(tableName string) *model.TableMetadata {
- if r.dbSchema == nil {
+ if r.dbMetadata == nil {
return nil
}
- return r.dbSchema.GetDatabaseMetadata().GetSchema("").GetTable(tableName)
+ return r.dbMetadata.GetSchemaMetadata("").GetTable(tableName)
}
func extractJoinInfoFromText(text string) *ColumnAttr {
diff --git a/backend/plugin/advisor/mysql/rule_table_limit_size.go b/backend/plugin/advisor/mysql/rule_table_limit_size.go
index 4f47a7e433..643f867906 100644
--- a/backend/plugin/advisor/mysql/rule_table_limit_size.go
+++ b/backend/plugin/advisor/mysql/rule_table_limit_size.go
@@ -79,19 +79,19 @@ type TableLimitSizeRule struct {
BaseRule
affectedTabNames []string
maxRows int
- dbSchema *storepb.DatabaseSchemaMetadata
+ dbMetadata *storepb.DatabaseSchemaMetadata
statementBaseLine int
}
// NewTableLimitSizeRule creates a new TableLimitSizeRule.
-func NewTableLimitSizeRule(level storepb.Advice_Status, title string, maxRows int, dbSchema *storepb.DatabaseSchemaMetadata) *TableLimitSizeRule {
+func NewTableLimitSizeRule(level storepb.Advice_Status, title string, maxRows int, dbMetadata *storepb.DatabaseSchemaMetadata) *TableLimitSizeRule {
return &TableLimitSizeRule{
BaseRule: BaseRule{
level: level,
title: title,
},
- maxRows: maxRows,
- dbSchema: dbSchema,
+ maxRows: maxRows,
+ dbMetadata: dbMetadata,
}
}
@@ -140,10 +140,10 @@ func (r *TableLimitSizeRule) checkDropTable(ctx *mysql.DropTableContext) {
}
func (r *TableLimitSizeRule) generateAdvice() {
- if r.dbSchema != nil && len(r.dbSchema.Schemas) != 0 {
+ if r.dbMetadata != nil && len(r.dbMetadata.Schemas) != 0 {
// Check all table size.
for _, tabName := range r.affectedTabNames {
- tableRows := getTabRowsByName(tabName, r.dbSchema.Schemas[0].Tables)
+ tableRows := getTabRowsByName(tabName, r.dbMetadata.Schemas[0].Tables)
if tableRows >= int64(r.maxRows) {
r.AddAdvice(&storepb.Advice{
Status: r.level,
diff --git a/backend/plugin/advisor/mysql/rule_table_require_pk.go b/backend/plugin/advisor/mysql/rule_table_require_pk.go
index 4203ab9809..42130ce2d3 100644
--- a/backend/plugin/advisor/mysql/rule_table_require_pk.go
+++ b/backend/plugin/advisor/mysql/rule_table_require_pk.go
@@ -251,7 +251,7 @@ func (r *TableRequirePKRule) changeColumn(tableName string, oldColumn string, ne
func (r *TableRequirePKRule) dropColumn(tableName string, columnName string) bool {
if _, ok := r.tables[tableName]; !ok {
- pk := r.originalMetadata.GetSchema("").GetTable(tableName).GetIndex(primaryKeyName)
+ pk := r.originalMetadata.GetSchemaMetadata("").GetTable(tableName).GetIndex(primaryKeyName)
if pk == nil {
return false
}
diff --git a/backend/plugin/advisor/mysql/rule_table_text_fields_total_length.go b/backend/plugin/advisor/mysql/rule_table_text_fields_total_length.go
index 93d6c36fd9..9130d7e9bc 100644
--- a/backend/plugin/advisor/mysql/rule_table_text_fields_total_length.go
+++ b/backend/plugin/advisor/mysql/rule_table_text_fields_total_length.go
@@ -116,7 +116,7 @@ func (r *TableTextFieldsTotalLengthRule) checkCreateTable(ctx *mysql.CreateTable
if tableName == "" {
return
}
- schema := r.finalMetadata.GetSchema("")
+ schema := r.finalMetadata.GetSchemaMetadata("")
if schema == nil {
return
}
@@ -154,7 +154,7 @@ func (r *TableTextFieldsTotalLengthRule) checkAlterTable(ctx *mysql.AlterTableCo
if tableName == "" {
return
}
- schema := r.finalMetadata.GetSchema("")
+ schema := r.finalMetadata.GetSchemaMetadata("")
if schema == nil {
return
}
diff --git a/backend/plugin/advisor/pg/advisor_builtin_prior_backup_check.go b/backend/plugin/advisor/pg/advisor_builtin_prior_backup_check.go
index 0edccd86f2..c936d5b36e 100644
--- a/backend/plugin/advisor/pg/advisor_builtin_prior_backup_check.go
+++ b/backend/plugin/advisor/pg/advisor_builtin_prior_backup_check.go
@@ -67,7 +67,7 @@ func (*BuiltinPriorBackupCheckAdvisor) Check(_ context.Context, checkCtx advisor
// Check if backup schema exists
schemaName := common.BackupDatabaseNameOfEngine(storepb.Engine_POSTGRES)
- if checkCtx.OriginalMetadata.GetSchema(schemaName) == nil {
+ if checkCtx.OriginalMetadata.GetSchemaMetadata(schemaName) == nil {
adviceList = append(adviceList, &storepb.Advice{
Status: level,
Title: title,
diff --git a/backend/plugin/advisor/pg/advisor_column_no_null.go b/backend/plugin/advisor/pg/advisor_column_no_null.go
index 81472330f3..503d7a3fd1 100644
--- a/backend/plugin/advisor/pg/advisor_column_no_null.go
+++ b/backend/plugin/advisor/pg/advisor_column_no_null.go
@@ -308,10 +308,10 @@ func (r *columnNoNullRule) removeColumnByTableConstraint(schema, table string, c
indexName := pg.NormalizePostgreSQLName(existingIndex.Name())
// Try to find index in catalog
if r.originalMetadata != nil {
- dbSchema := r.originalMetadata.GetSchema(schema)
+ schemaMetadata := r.originalMetadata.GetSchemaMetadata(schema)
var index *model.IndexMetadata
- if dbSchema != nil {
- dbTable := dbSchema.GetTable(table)
+ if schemaMetadata != nil {
+ dbTable := schemaMetadata.GetTable(table)
if dbTable != nil {
index = dbTable.GetIndex(indexName)
}
diff --git a/backend/plugin/advisor/pg/advisor_index_total_number_limit.go b/backend/plugin/advisor/pg/advisor_index_total_number_limit.go
index 243d649aa9..922f267fb9 100644
--- a/backend/plugin/advisor/pg/advisor_index_total_number_limit.go
+++ b/backend/plugin/advisor/pg/advisor_index_total_number_limit.go
@@ -122,7 +122,7 @@ func (r *indexTotalNumberLimitRule) generateAdvice() {
})
for _, table := range tableList {
- schema := r.finalMetadata.GetSchema(table.schema)
+ schema := r.finalMetadata.GetSchemaMetadata(table.schema)
if schema == nil {
continue
}
diff --git a/backend/plugin/advisor/pg/advisor_naming_fully_qualified.go b/backend/plugin/advisor/pg/advisor_naming_fully_qualified.go
index aba2735a50..28bd8230d6 100644
--- a/backend/plugin/advisor/pg/advisor_naming_fully_qualified.go
+++ b/backend/plugin/advisor/pg/advisor_naming_fully_qualified.go
@@ -45,7 +45,7 @@ func (*FullyQualifiedObjectNameAdvisor) Check(_ context.Context, checkCtx adviso
level: level,
title: string(checkCtx.Rule.Type),
},
- dbSchema: checkCtx.DBSchema,
+ dbMetadata: checkCtx.DBSchema,
statementsText: checkCtx.Statements,
}
@@ -58,7 +58,7 @@ func (*FullyQualifiedObjectNameAdvisor) Check(_ context.Context, checkCtx adviso
type fullyQualifiedObjectNameRule struct {
BaseRule
- dbSchema *storepb.DatabaseSchemaMetadata
+ dbMetadata *storepb.DatabaseSchemaMetadata
statementsText string
}
@@ -248,7 +248,7 @@ func (r *fullyQualifiedObjectNameRule) handleSelectstmt(ctx *parser.SelectstmtCo
// For SELECT statements, we need to extract tables from the query
// and check them against the database schema
- if r.dbSchema == nil {
+ if r.dbMetadata == nil {
return
}
@@ -357,12 +357,12 @@ func (r *fullyQualifiedObjectNameRule) findAllTablesInSelect(statement string) [
// getSchemaNameMapFromPublic creates a map of table names from the database schema
func (r *fullyQualifiedObjectNameRule) getSchemaNameMapFromPublic() map[string]bool {
- if r.dbSchema == nil || r.dbSchema.Schemas == nil {
+ if r.dbMetadata == nil || r.dbMetadata.Schemas == nil {
return nil
}
filterMap := map[string]bool{}
- for _, schema := range r.dbSchema.Schemas {
+ for _, schema := range r.dbMetadata.Schemas {
// Tables
for _, tbl := range schema.Tables {
filterMap[tbl.Name] = true
diff --git a/backend/plugin/advisor/pg/advisor_naming_index_convention.go b/backend/plugin/advisor/pg/advisor_naming_index_convention.go
index 20769694a8..b3d2614a3c 100644
--- a/backend/plugin/advisor/pg/advisor_naming_index_convention.go
+++ b/backend/plugin/advisor/pg/advisor_naming_index_convention.go
@@ -237,7 +237,7 @@ func (r *namingIndexConventionRule) findIndex(schemaName string, tableName strin
if r.originalMetadata == nil {
return "", nil
}
- schema := r.originalMetadata.GetSchema(normalizeSchemaName(schemaName))
+ schema := r.originalMetadata.GetSchemaMetadata(normalizeSchemaName(schemaName))
if schema == nil {
return "", nil
}
diff --git a/backend/plugin/advisor/pg/advisor_naming_primary_key_convention.go b/backend/plugin/advisor/pg/advisor_naming_primary_key_convention.go
index 7e63e943e9..f45f840729 100644
--- a/backend/plugin/advisor/pg/advisor_naming_primary_key_convention.go
+++ b/backend/plugin/advisor/pg/advisor_naming_primary_key_convention.go
@@ -196,7 +196,7 @@ func (r *namingPKConventionRule) handleRenamestmt(ctx *parser.RenamestmtContext)
if normalizedSchema == "" {
normalizedSchema = "public"
}
- index := r.originalMetadata.GetSchema(normalizedSchema).GetTable(tableName).GetIndex(oldName)
+ index := r.originalMetadata.GetSchemaMetadata(normalizedSchema).GetTable(tableName).GetIndex(oldName)
if index != nil && index.Primary() {
metaData := map[string]string{
advisor.ColumnListTemplateToken: strings.Join(index.ExpressionList(), "_"),
@@ -241,7 +241,7 @@ func (r *namingPKConventionRule) handleRenamestmt(ctx *parser.RenamestmtContext)
}
// "ALTER INDEX name RENAME TO new_name" doesn't specify table name
// Empty table name for ALTER INDEX
- schema := r.originalMetadata.GetSchema(normalizedSchema)
+ schema := r.originalMetadata.GetSchemaMetadata(normalizedSchema)
var tableName string
var index *model.IndexMetadata
if schema != nil {
@@ -320,7 +320,7 @@ func (r *namingPKConventionRule) getPKMetaDataFromTableConstraint(constraint par
if normalizedSchema == "" {
normalizedSchema = "public"
}
- schema := r.originalMetadata.GetSchema(normalizedSchema)
+ schema := r.originalMetadata.GetSchemaMetadata(normalizedSchema)
var index *model.IndexMetadata
if schema != nil {
table := schema.GetTable(tableName)
diff --git a/backend/plugin/advisor/pg/advisor_naming_unique_key_convention.go b/backend/plugin/advisor/pg/advisor_naming_unique_key_convention.go
index 732ab247c4..34fa240fa8 100644
--- a/backend/plugin/advisor/pg/advisor_naming_unique_key_convention.go
+++ b/backend/plugin/advisor/pg/advisor_naming_unique_key_convention.go
@@ -300,7 +300,7 @@ func (r *namingUKConventionRule) checkTableConstraint(constraint parser.ITableco
} else if elem.Existingindex() != nil && elem.Existingindex().Name() != nil {
// Handle UNIQUE USING INDEX - the column list is in the existing index
indexName := pgparser.NormalizePostgreSQLName(elem.Existingindex().Name())
- schema := r.originalMetadata.GetSchema(normalizeSchemaName(""))
+ schema := r.originalMetadata.GetSchemaMetadata(normalizeSchemaName(""))
var index *model.IndexMetadata
if schema != nil {
table := schema.GetTable(tableName)
@@ -417,7 +417,7 @@ func (r *namingUKConventionRule) findIndex(schemaName string, tableName string,
if r.originalMetadata == nil {
return "", nil
}
- schema := r.originalMetadata.GetSchema(normalizeSchemaName(schemaName))
+ schema := r.originalMetadata.GetSchemaMetadata(normalizeSchemaName(schemaName))
if schema == nil {
return "", nil
}
diff --git a/backend/plugin/advisor/pg/advisor_statement_object_owner_check.go b/backend/plugin/advisor/pg/advisor_statement_object_owner_check.go
index 24a07173c1..272c426097 100644
--- a/backend/plugin/advisor/pg/advisor_statement_object_owner_check.go
+++ b/backend/plugin/advisor/pg/advisor_statement_object_owner_check.go
@@ -43,7 +43,7 @@ func (*StatementObjectOwnerCheckAdvisor) Check(ctx context.Context, checkCtx adv
return nil, err
}
- dbMetadata := model.NewDatabaseMetadata(checkCtx.DBSchema, storepb.Engine_POSTGRES, checkCtx.IsObjectCaseSensitive)
+ dbMetadata := model.NewDatabaseMetadata(checkCtx.DBSchema, nil, nil, storepb.Engine_POSTGRES, checkCtx.IsObjectCaseSensitive)
currentRole := checkCtx.DBSchema.Owner
if !checkCtx.UsePostgresDatabaseOwner {
currentRole, err = getCurrentUser(ctx, checkCtx.Driver)
@@ -142,7 +142,7 @@ func (r *statementObjectOwnerCheckRule) checkSchemaOwnership(schemaName string,
schemaName = defaultSchema
}
- schemaMeta := r.dbMetadata.GetSchema(schemaName)
+ schemaMeta := r.dbMetadata.GetSchemaMetadata(schemaName)
if schemaMeta == nil {
return
}
@@ -170,7 +170,7 @@ func (r *statementObjectOwnerCheckRule) checkTableOwnership(schemaName, tableNam
schemaName = defaultSchema
}
- schemaMeta := r.dbMetadata.GetSchema(schemaName)
+ schemaMeta := r.dbMetadata.GetSchemaMetadata(schemaName)
if schemaMeta == nil {
return
}
diff --git a/backend/plugin/advisor/pg/advisor_table_require_pk.go b/backend/plugin/advisor/pg/advisor_table_require_pk.go
index c87054f1c7..0e07736a85 100644
--- a/backend/plugin/advisor/pg/advisor_table_require_pk.go
+++ b/backend/plugin/advisor/pg/advisor_table_require_pk.go
@@ -180,7 +180,7 @@ func (r *tableRequirePKRule) validateFinalState() {
schemaName, tableName := parseTableKey(tableKey)
// Check catalog.Final for PRIMARY KEY
- schema := r.finalMetadata.GetSchema(schemaName)
+ schema := r.finalMetadata.GetSchemaMetadata(schemaName)
var hasPK bool
if schema != nil {
table := schema.GetTable(tableName)
diff --git a/backend/plugin/advisor/pg/test_helper.go b/backend/plugin/advisor/pg/test_helper.go
index 47c7dada17..08b9214ab8 100644
--- a/backend/plugin/advisor/pg/test_helper.go
+++ b/backend/plugin/advisor/pg/test_helper.go
@@ -64,14 +64,14 @@ func RunANTLRAdvisorRuleTest(t *testing.T, rule advisor.SQLReviewRuleType, dbTyp
// Clone to avoid mutations affecting future test cases
originalCatalogClone, ok := proto.Clone(schemaMetadata).(*storepb.DatabaseSchemaMetadata)
require.True(t, ok, "failed to clone schema metadata")
- originalSchema := model.NewDatabaseSchema(originalCatalogClone, nil, nil, dbType, true /* isCaseSensitive for PostgreSQL */)
- originalMetadata := originalSchema.GetDatabaseMetadata()
+ originalSchema := model.NewDatabaseMetadata(originalCatalogClone, nil, nil, dbType, true /* isCaseSensitive for PostgreSQL */)
+ originalMetadata := originalSchema
// Create FinalMetadata as DatabaseMetadata (mutable for walk-through)
// Clone to avoid mutations affecting future test cases
finalCatalogClone, ok := proto.Clone(schemaMetadata).(*storepb.DatabaseSchemaMetadata)
require.True(t, ok, "failed to clone schema metadata")
- finalMetadata := model.NewDatabaseMetadata(finalCatalogClone, storepb.Engine_POSTGRES, true /* isCaseSensitive for PostgreSQL */)
+ finalMetadata := model.NewDatabaseMetadata(finalCatalogClone, nil, nil, storepb.Engine_POSTGRES, true /* isCaseSensitive for PostgreSQL */)
// Get default payload, or use empty string for test-only rules
payload, err := advisor.SetDefaultSQLReviewRulePayload(rule, dbType)
diff --git a/backend/plugin/advisor/tidb/advisor_builtin_prior_backup_check.go b/backend/plugin/advisor/tidb/advisor_builtin_prior_backup_check.go
index f1690ba121..08e120986d 100644
--- a/backend/plugin/advisor/tidb/advisor_builtin_prior_backup_check.go
+++ b/backend/plugin/advisor/tidb/advisor_builtin_prior_backup_check.go
@@ -103,7 +103,7 @@ func (*StatementPriorBackupCheckAdvisor) Check(ctx context.Context, checkCtx adv
return adviceList, nil
}
-func updateForOneTableWithUnique(dbSchema *storepb.DatabaseSchemaMetadata, updates []*ast.UpdateStmt, deletes []*ast.DeleteStmt) bool {
+func updateForOneTableWithUnique(dbMetadata *storepb.DatabaseSchemaMetadata, updates []*ast.UpdateStmt, deletes []*ast.DeleteStmt) bool {
if len(deletes) > 0 {
return false
}
@@ -123,7 +123,7 @@ func updateForOneTableWithUnique(dbSchema *storepb.DatabaseSchemaMetadata, updat
} else if !equalTable(table, &tables[0]) {
return false
}
- if !hasUniqueInWhereClause(dbSchema, update, table) {
+ if !hasUniqueInWhereClause(dbMetadata, update, table) {
return false
}
}
@@ -131,7 +131,7 @@ func updateForOneTableWithUnique(dbSchema *storepb.DatabaseSchemaMetadata, updat
return true
}
-func hasUniqueInWhereClause(dbSchema *storepb.DatabaseSchemaMetadata, update *ast.UpdateStmt, table *table) bool {
+func hasUniqueInWhereClause(dbMetadata *storepb.DatabaseSchemaMetadata, update *ast.UpdateStmt, table *table) bool {
if update.Where == nil {
return false
}
@@ -141,8 +141,8 @@ func hasUniqueInWhereClause(dbSchema *storepb.DatabaseSchemaMetadata, update *as
columnMap[strings.ToLower(column)] = true
}
- if dbSchema != nil {
- for _, schema := range dbSchema.Schemas {
+ if dbMetadata != nil {
+ for _, schema := range dbMetadata.Schemas {
for _, tableSchema := range schema.Tables {
if strings.EqualFold(tableSchema.Name, table.table) {
for _, index := range tableSchema.Indexes {
diff --git a/backend/plugin/advisor/tidb/advisor_column_disallow_changing_type.go b/backend/plugin/advisor/tidb/advisor_column_disallow_changing_type.go
index 4a46fd214f..3f55f7d99b 100644
--- a/backend/plugin/advisor/tidb/advisor_column_disallow_changing_type.go
+++ b/backend/plugin/advisor/tidb/advisor_column_disallow_changing_type.go
@@ -131,7 +131,7 @@ func normalizeColumnType(tp string) string {
}
func (checker *columnDisallowChangingTypeChecker) changeColumnType(tableName string, columName string, newType string) bool {
- column := checker.originalMetadata.GetSchema("").GetTable(tableName).GetColumn(columName)
+ column := checker.originalMetadata.GetSchemaMetadata("").GetTable(tableName).GetColumn(columName)
if column == nil {
return false
}
diff --git a/backend/plugin/advisor/tidb/advisor_column_disallow_drop_in_index.go b/backend/plugin/advisor/tidb/advisor_column_disallow_drop_in_index.go
index 7f1c3979d2..e24ea1d93d 100644
--- a/backend/plugin/advisor/tidb/advisor_column_disallow_drop_in_index.go
+++ b/backend/plugin/advisor/tidb/advisor_column_disallow_drop_in_index.go
@@ -88,7 +88,7 @@ func (checker *columnDisallowDropInIndexChecker) dropColumn(in ast.Node) (ast.No
if spec.Tp == ast.AlterTableDropColumn {
table := node.Table.Name.O
- tableMetadata := checker.originalMetadata.GetSchema("").GetTable(table)
+ tableMetadata := checker.originalMetadata.GetSchemaMetadata("").GetTable(table)
if tableMetadata != nil {
if checker.tables[table] == nil {
checker.tables[table] = make(columnSet)
diff --git a/backend/plugin/advisor/tidb/advisor_column_no_null.go b/backend/plugin/advisor/tidb/advisor_column_no_null.go
index 39eea0392c..93ba08f8b4 100644
--- a/backend/plugin/advisor/tidb/advisor_column_no_null.go
+++ b/backend/plugin/advisor/tidb/advisor_column_no_null.go
@@ -83,7 +83,7 @@ func (checker *columnNoNullChecker) generateAdvice() []*storepb.Advice {
})
for _, column := range columnList {
- schema := checker.finalMetadata.GetSchema("")
+ schema := checker.finalMetadata.GetSchemaMetadata("")
if schema == nil {
continue
}
diff --git a/backend/plugin/advisor/tidb/advisor_index_pk_type.go b/backend/plugin/advisor/tidb/advisor_index_pk_type.go
index 4957e4d324..aaa9f16a14 100644
--- a/backend/plugin/advisor/tidb/advisor_index_pk_type.go
+++ b/backend/plugin/advisor/tidb/advisor_index_pk_type.go
@@ -220,7 +220,7 @@ func (v *indexPkTypeChecker) getPKColumnType(tableName string, columnName string
if colDef, ok := v.tablesNewColumns.get(tableName, columnName); ok {
return v.getIntOrBigIntStr(colDef.Tp), nil
}
- column := v.originalMetadata.GetSchema("").GetTable(tableName).GetColumn(columnName)
+ column := v.originalMetadata.GetSchemaMetadata("").GetTable(tableName).GetColumn(columnName)
if column != nil {
return column.Type, nil
}
diff --git a/backend/plugin/advisor/tidb/advisor_index_primary_key_type_allowlist.go b/backend/plugin/advisor/tidb/advisor_index_primary_key_type_allowlist.go
index c444ca817e..3f29b39555 100644
--- a/backend/plugin/advisor/tidb/advisor_index_primary_key_type_allowlist.go
+++ b/backend/plugin/advisor/tidb/advisor_index_primary_key_type_allowlist.go
@@ -201,7 +201,7 @@ func (v *indexPrimaryKeyTypeAllowlistChecker) getPKColumnType(tableName string,
if colDef, ok := v.tablesNewColumns.get(tableName, columnName); ok {
return tidbparser.TypeString(colDef.Tp.GetType()), nil
}
- column := v.originalMetadata.GetSchema("").GetTable(tableName).GetColumn(columnName)
+ column := v.originalMetadata.GetSchemaMetadata("").GetTable(tableName).GetColumn(columnName)
if column != nil {
return column.Type, nil
}
diff --git a/backend/plugin/advisor/tidb/advisor_index_total_number_limit.go b/backend/plugin/advisor/tidb/advisor_index_total_number_limit.go
index dd653b1f40..6d6214bc48 100644
--- a/backend/plugin/advisor/tidb/advisor_index_total_number_limit.go
+++ b/backend/plugin/advisor/tidb/advisor_index_total_number_limit.go
@@ -98,7 +98,7 @@ func (checker *indexTotalNumberLimitChecker) generateAdvice() []*storepb.Advice
})
for _, table := range tableList {
- schema := checker.finalMetadata.GetSchema("")
+ schema := checker.finalMetadata.GetSchemaMetadata("")
if schema == nil {
continue
}
diff --git a/backend/plugin/advisor/tidb/advisor_index_type_no_blob.go b/backend/plugin/advisor/tidb/advisor_index_type_no_blob.go
index c710bf728d..71654055d1 100644
--- a/backend/plugin/advisor/tidb/advisor_index_type_no_blob.go
+++ b/backend/plugin/advisor/tidb/advisor_index_type_no_blob.go
@@ -223,7 +223,7 @@ func (v *indexTypeNoBlobChecker) getColumnType(tableName string, columnName stri
if colDef, ok := v.tablesNewColumns.get(tableName, columnName); ok {
return v.getBlobStr(colDef.Tp), nil
}
- column := v.originalMetadata.GetSchema("").GetTable(tableName).GetColumn(columnName)
+ column := v.originalMetadata.GetSchemaMetadata("").GetTable(tableName).GetColumn(columnName)
if column != nil {
return column.Type, nil
}
diff --git a/backend/plugin/advisor/tidb/advisor_naming_index_convention.go b/backend/plugin/advisor/tidb/advisor_naming_index_convention.go
index 4ce7dad920..de73c50123 100644
--- a/backend/plugin/advisor/tidb/advisor_naming_index_convention.go
+++ b/backend/plugin/advisor/tidb/advisor_naming_index_convention.go
@@ -151,7 +151,7 @@ func (checker *namingIndexConventionChecker) getMetaDataList(in ast.Node) []*ind
for _, spec := range node.Specs {
switch spec.Tp {
case ast.AlterTableRenameIndex:
- schema := checker.originalMetadata.GetSchema("")
+ schema := checker.originalMetadata.GetSchemaMetadata("")
var index *model.IndexMetadata
if schema != nil {
index = schema.GetIndex(spec.FromKey.String())
diff --git a/backend/plugin/advisor/tidb/advisor_naming_unique_key_convention.go b/backend/plugin/advisor/tidb/advisor_naming_unique_key_convention.go
index 5a09231fbe..d2339b7e67 100644
--- a/backend/plugin/advisor/tidb/advisor_naming_unique_key_convention.go
+++ b/backend/plugin/advisor/tidb/advisor_naming_unique_key_convention.go
@@ -142,7 +142,7 @@ func (checker *namingUKConventionChecker) getMetaDataList(in ast.Node) []*indexM
for _, spec := range node.Specs {
switch spec.Tp {
case ast.AlterTableRenameIndex:
- schema := checker.originalMetadata.GetSchema("")
+ schema := checker.originalMetadata.GetSchemaMetadata("")
var index *model.IndexMetadata
if schema != nil {
index = schema.GetIndex(spec.FromKey.String())
diff --git a/backend/plugin/advisor/tidb/advisor_table_require_pk.go b/backend/plugin/advisor/tidb/advisor_table_require_pk.go
index 1d2f9a8be5..b1df3c4085 100644
--- a/backend/plugin/advisor/tidb/advisor_table_require_pk.go
+++ b/backend/plugin/advisor/tidb/advisor_table_require_pk.go
@@ -182,7 +182,7 @@ func (v *tableRequirePKChecker) createTableLike(node *ast.CreateTableStmt) {
}
v.tables[table] = newColumnSet(columns)
} else {
- schema := v.originalMetadata.GetSchema("")
+ schema := v.originalMetadata.GetSchemaMetadata("")
if schema != nil {
referTableMetadata := schema.GetTable(referTableName)
if referTableMetadata != nil {
@@ -197,7 +197,7 @@ func (v *tableRequirePKChecker) createTableLike(node *ast.CreateTableStmt) {
func (v *tableRequirePKChecker) dropColumn(table string, column string) bool {
if _, ok := v.tables[table]; !ok {
- pk := v.originalMetadata.GetSchema("").GetTable(table).GetIndex(primaryKeyName)
+ pk := v.originalMetadata.GetSchemaMetadata("").GetTable(table).GetIndex(primaryKeyName)
if pk == nil {
return false
}
diff --git a/backend/plugin/advisor/utils_for_tests.go b/backend/plugin/advisor/utils_for_tests.go
index b590002d5f..65b0d01de2 100644
--- a/backend/plugin/advisor/utils_for_tests.go
+++ b/backend/plugin/advisor/utils_for_tests.go
@@ -216,14 +216,13 @@ func RunSQLReviewRuleTest(t *testing.T, rule SQLReviewRuleType, dbType storepb.E
// Clone to avoid mutations affecting future test cases
originalCatalogClone, ok := proto.Clone(catalogMetadata).(*storepb.DatabaseSchemaMetadata)
require.True(t, ok, "failed to clone catalog metadata")
- originalSchema := model.NewDatabaseSchema(originalCatalogClone, nil, nil, dbType, isCaseSensitive)
- originalMetadata := originalSchema.GetDatabaseMetadata()
+ originalMetadata := model.NewDatabaseMetadata(originalCatalogClone, nil, nil, dbType, isCaseSensitive)
// Create FinalMetadata as DatabaseMetadata (mutable for walk-through)
// Clone to avoid mutations affecting future test cases
finalCatalogClone, ok := proto.Clone(catalogMetadata).(*storepb.DatabaseSchemaMetadata)
require.True(t, ok, "failed to clone catalog metadata")
- finalMetadata := model.NewDatabaseMetadata(finalCatalogClone, dbType, isCaseSensitive)
+ finalMetadata := model.NewDatabaseMetadata(finalCatalogClone, nil, nil, dbType, isCaseSensitive)
payload, err := SetDefaultSQLReviewRulePayload(rule, dbType)
require.NoError(t, err)
diff --git a/backend/plugin/db/databricks/sync.go b/backend/plugin/db/databricks/sync.go
index 3ab0fa8496..cac3d107bd 100644
--- a/backend/plugin/db/databricks/sync.go
+++ b/backend/plugin/db/databricks/sync.go
@@ -37,17 +37,17 @@ func (d *Driver) SyncDBSchema(ctx context.Context) (*storepb.DatabaseSchemaMetad
return nil, err
}
- dbSchemaMeta := storepb.DatabaseSchemaMetadata{}
+ dbMetadataMeta := storepb.DatabaseSchemaMetadata{}
schemaMap, ok := (catalogMap)[d.curCatalog]
if !ok {
return nil, errors.Errorf("cannot find metadata for catalog '%s'", d.curCatalog)
}
- dbSchemaMeta.Name = d.curCatalog
+ dbMetadataMeta.Name = d.curCatalog
schemas := convertToStorepbSchemas(schemaMap)
- dbSchemaMeta.Schemas = schemas
+ dbMetadataMeta.Schemas = schemas
- return &dbSchemaMeta, nil
+ return &dbMetadataMeta, nil
}
func (d *Driver) SyncInstance(ctx context.Context) (*db.InstanceMetadata, error) {
@@ -74,11 +74,11 @@ func (d *Driver) SyncInstance(ctx context.Context) (*db.InstanceMetadata, error)
}
for catalogName, schemaMap := range catalogMap {
- dbSchemaMeta := storepb.DatabaseSchemaMetadata{}
+ dbMetadataMeta := storepb.DatabaseSchemaMetadata{}
schemas := convertToStorepbSchemas(schemaMap)
- dbSchemaMeta.Name = catalogName
- dbSchemaMeta.Schemas = schemas
- instanceMetadata.Databases = append(instanceMetadata.Databases, &dbSchemaMeta)
+ dbMetadataMeta.Name = catalogName
+ dbMetadataMeta.Schemas = schemas
+ instanceMetadata.Databases = append(instanceMetadata.Databases, &dbMetadataMeta)
}
// fetch workspace users.
diff --git a/backend/plugin/db/driver.go b/backend/plugin/db/driver.go
index 532ab784d9..c6bf39ffd2 100644
--- a/backend/plugin/db/driver.go
+++ b/backend/plugin/db/driver.go
@@ -150,7 +150,7 @@ type Driver interface {
SyncDBSchema(ctx context.Context) (*storepb.DatabaseSchemaMetadata, error)
// Dump dumps the schema of database.
- Dump(ctx context.Context, out io.Writer, dbSchema *storepb.DatabaseSchemaMetadata) error
+ Dump(ctx context.Context, out io.Writer, dbMetadata *storepb.DatabaseSchemaMetadata) error
}
// Register makes a database driver available by the provided type.
diff --git a/backend/plugin/db/elasticsearch/sync.go b/backend/plugin/db/elasticsearch/sync.go
index 6f119d7bb7..097d5d1f5e 100644
--- a/backend/plugin/db/elasticsearch/sync.go
+++ b/backend/plugin/db/elasticsearch/sync.go
@@ -44,7 +44,7 @@ func (d *Driver) SyncInstance(ctx context.Context) (*db.InstanceMetadata, error)
// SyncDBSchema implements db.Driver.
func (d *Driver) SyncDBSchema(_ context.Context) (*storepb.DatabaseSchemaMetadata, error) {
- var dbSchemaMetadata storepb.DatabaseSchemaMetadata
+ var dbMetadataProto storepb.DatabaseSchemaMetadata
// indices.
indices, err := d.getIndices()
@@ -53,10 +53,10 @@ func (d *Driver) SyncDBSchema(_ context.Context) (*storepb.DatabaseSchemaMetadat
}
// TODO(tommy): database name?
- dbSchemaMetadata.Name = "node"
- dbSchemaMetadata.Schemas = append(dbSchemaMetadata.Schemas, &storepb.SchemaMetadata{Tables: indices})
+ dbMetadataProto.Name = "node"
+ dbMetadataProto.Schemas = append(dbMetadataProto.Schemas, &storepb.SchemaMetadata{Tables: indices})
- return &dbSchemaMetadata, nil
+ return &dbMetadataProto, nil
}
// struct for getVersion().
diff --git a/backend/plugin/db/mysql/dump.go b/backend/plugin/db/mysql/dump.go
index 6c919d937f..302a622c5b 100644
--- a/backend/plugin/db/mysql/dump.go
+++ b/backend/plugin/db/mysql/dump.go
@@ -11,10 +11,10 @@ import (
)
// Dump dumps the database.
-func (*Driver) Dump(_ context.Context, out io.Writer, dbSchema *storepb.DatabaseSchemaMetadata) error {
+func (*Driver) Dump(_ context.Context, out io.Writer, dbMetadata *storepb.DatabaseSchemaMetadata) error {
text, err := schema.GetDatabaseDefinition(storepb.Engine_MYSQL, schema.GetDefinitionContext{
PrintHeader: true,
- }, dbSchema)
+ }, dbMetadata)
if err != nil {
return errors.Wrapf(err, "failed to get database definition")
}
diff --git a/backend/plugin/db/tidb/dump.go b/backend/plugin/db/tidb/dump.go
index 776f68dc81..30b72743ec 100644
--- a/backend/plugin/db/tidb/dump.go
+++ b/backend/plugin/db/tidb/dump.go
@@ -11,10 +11,10 @@ import (
)
// Dump dumps the database.
-func (*Driver) Dump(_ context.Context, out io.Writer, dbSchema *storepb.DatabaseSchemaMetadata) error {
+func (*Driver) Dump(_ context.Context, out io.Writer, dbMetadata *storepb.DatabaseSchemaMetadata) error {
text, err := schema.GetDatabaseDefinition(storepb.Engine_TIDB, schema.GetDefinitionContext{
PrintHeader: true,
- }, dbSchema)
+ }, dbMetadata)
if err != nil {
return errors.Wrapf(err, "failed to get database definition")
}
diff --git a/backend/plugin/db/trino/dump.go b/backend/plugin/db/trino/dump.go
index 28cc290457..a5c91c2167 100644
--- a/backend/plugin/db/trino/dump.go
+++ b/backend/plugin/db/trino/dump.go
@@ -11,8 +11,8 @@ import (
)
// Dump dumps the database schema as SQL statements.
-func (*Driver) Dump(_ context.Context, out io.Writer, dbSchema *storepb.DatabaseSchemaMetadata) error {
- text, err := schema.GetDatabaseDefinition(storepb.Engine_TRINO, schema.GetDefinitionContext{}, dbSchema)
+func (*Driver) Dump(_ context.Context, out io.Writer, dbMetadata *storepb.DatabaseSchemaMetadata) error {
+ text, err := schema.GetDatabaseDefinition(storepb.Engine_TRINO, schema.GetDefinitionContext{}, dbMetadata)
if err != nil {
return errors.Wrapf(err, "failed to get database definition")
}
diff --git a/backend/plugin/parser/base/interface.go b/backend/plugin/parser/base/interface.go
index 6fc64da060..71129d80f7 100644
--- a/backend/plugin/parser/base/interface.go
+++ b/backend/plugin/parser/base/interface.go
@@ -32,7 +32,7 @@ var (
)
type ValidateSQLForEditorFunc func(string) (bool, bool, error)
-type ExtractChangedResourcesFunc func(string, string, *model.DatabaseSchema, any, string) (*ChangeSummary, error)
+type ExtractChangedResourcesFunc func(string, string, *model.DatabaseMetadata, any, string) (*ChangeSummary, error)
type SplitMultiSQLFunc func(string) ([]SingleSQL, error)
type CompletionFunc func(ctx context.Context, cCtx CompletionContext, statement string, caretLine int, caretOffset int) ([]Candidate, error)
type DiagnoseFunc func(ctx context.Context, dCtx DiagnoseContext, statement string) ([]Diagnostic, error)
@@ -84,12 +84,12 @@ func RegisterExtractChangedResourcesFunc(engine storepb.Engine, f ExtractChanged
}
// ExtractChangedResources extracts the changed resources from the SQL.
-func ExtractChangedResources(engine storepb.Engine, currentDatabase string, currentSchema string, dbSchema *model.DatabaseSchema, ast any, statement string) (*ChangeSummary, error) {
+func ExtractChangedResources(engine storepb.Engine, currentDatabase string, currentSchema string, dbMetadata *model.DatabaseMetadata, ast any, statement string) (*ChangeSummary, error) {
f, ok := changedResourcesGetters[engine]
if !ok {
return nil, errors.Errorf("engine %s is not supported", engine)
}
- return f(currentDatabase, currentSchema, dbSchema, ast, statement)
+ return f(currentDatabase, currentSchema, dbMetadata, ast, statement)
}
func RegisterSplitterFunc(engine storepb.Engine, f SplitMultiSQLFunc) {
diff --git a/backend/plugin/parser/bigquery/query_span_extractor.go b/backend/plugin/parser/bigquery/query_span_extractor.go
index b641b30d01..7236e57da4 100644
--- a/backend/plugin/parser/bigquery/query_span_extractor.go
+++ b/backend/plugin/parser/bigquery/query_span_extractor.go
@@ -1123,7 +1123,7 @@ func (q *querySpanExtractor) findTableSchema(datasetName string, tableName strin
return nil, errors.Errorf("dataset %q not found", datasetName)
}
- schema := databaseMetadata.GetSchema("")
+ schema := databaseMetadata.GetSchemaMetadata("")
if schema == nil {
return nil, errors.Errorf("table %q not found", tableName)
}
diff --git a/backend/plugin/parser/bigquery/query_span_test.go b/backend/plugin/parser/bigquery/query_span_test.go
index bce21cc4f6..dabfe872be 100644
--- a/backend/plugin/parser/bigquery/query_span_test.go
+++ b/backend/plugin/parser/bigquery/query_span_test.go
@@ -81,7 +81,7 @@ func buildMockDatabaseMetadataGetter(databaseMetadata []*storepb.DatabaseSchemaM
return func(_ context.Context, _, databaseName string) (string, *model.DatabaseMetadata, error) {
m := make(map[string]*model.DatabaseMetadata)
for _, metadata := range databaseMetadata {
- m[metadata.Name] = model.NewDatabaseMetadata(metadata, storepb.Engine_BIGQUERY, true /* isObjectCaseSensitive */)
+ m[metadata.Name] = model.NewDatabaseMetadata(metadata, nil, nil, storepb.Engine_BIGQUERY, true /* isObjectCaseSensitive */)
}
if databaseMetadata, ok := m[databaseName]; ok {
diff --git a/backend/plugin/parser/cassandra/query_span_extractor.go b/backend/plugin/parser/cassandra/query_span_extractor.go
index d1a151e45b..ef90c7d452 100644
--- a/backend/plugin/parser/cassandra/query_span_extractor.go
+++ b/backend/plugin/parser/cassandra/query_span_extractor.go
@@ -196,7 +196,7 @@ func (e *querySpanExtractor) expandSelectAsterisk(keyspace, table string) []base
var results []base.QuerySpanResult
schemaNames := metadata.ListSchemaNames()
for _, schemaName := range schemaNames {
- schema := metadata.GetSchema(schemaName)
+ schema := metadata.GetSchemaMetadata(schemaName)
if schema == nil {
continue
}
diff --git a/backend/plugin/parser/doris/query_span_extractor_system_table_test.go b/backend/plugin/parser/doris/query_span_extractor_system_table_test.go
index 9d348b624f..fc77259844 100644
--- a/backend/plugin/parser/doris/query_span_extractor_system_table_test.go
+++ b/backend/plugin/parser/doris/query_span_extractor_system_table_test.go
@@ -77,7 +77,7 @@ func buildMockDatabaseMetadataGetter(databaseMetadata []*storepb.DatabaseSchemaM
m := make(map[string]*model.DatabaseMetadata)
for _, metadata := range databaseMetadata {
// Doris is case-insensitive for most objects
- m[metadata.Name] = model.NewDatabaseMetadata(metadata, storepb.Engine_MYSQL, false /* isObjectCaseSensitive */)
+ m[metadata.Name] = model.NewDatabaseMetadata(metadata, nil, nil, storepb.Engine_MYSQL, false /* isObjectCaseSensitive */)
}
if databaseMetadata, ok := m[databaseName]; ok {
diff --git a/backend/plugin/parser/mysql/backup.go b/backend/plugin/parser/mysql/backup.go
index 5f24d6dfbf..3e60c50b34 100644
--- a/backend/plugin/parser/mysql/backup.go
+++ b/backend/plugin/parser/mysql/backup.go
@@ -273,7 +273,7 @@ func classifyColumns(ctx context.Context, getDatabaseMetadataFunc base.GetDataba
return nil, nil, errors.New("GetDatabaseMetadataFunc is not set")
}
- var dbSchema *model.DatabaseMetadata
+ var dbMetadata *model.DatabaseMetadata
allDatabaseNames, err := listDatabaseNamesFunc(ctx, instanceID)
if err != nil {
return nil, nil, errors.Wrap(err, "failed to list databases names")
@@ -281,7 +281,7 @@ func classifyColumns(ctx context.Context, getDatabaseMetadataFunc base.GetDataba
if !isCaseSensitive {
for _, db := range allDatabaseNames {
if strings.EqualFold(db, table.Database) {
- _, dbSchema, err = getDatabaseMetadataFunc(ctx, instanceID, db)
+ _, dbMetadata, err = getDatabaseMetadataFunc(ctx, instanceID, db)
if err != nil {
return nil, nil, errors.Wrapf(err, "failed to get database metadata for database %q", db)
}
@@ -291,7 +291,7 @@ func classifyColumns(ctx context.Context, getDatabaseMetadataFunc base.GetDataba
} else {
for _, db := range allDatabaseNames {
if db == table.Database {
- _, dbSchema, err = getDatabaseMetadataFunc(ctx, instanceID, db)
+ _, dbMetadata, err = getDatabaseMetadataFunc(ctx, instanceID, db)
if err != nil {
return nil, nil, errors.Wrapf(err, "failed to get database metadata for database %q", db)
}
@@ -299,13 +299,13 @@ func classifyColumns(ctx context.Context, getDatabaseMetadataFunc base.GetDataba
}
}
}
- if dbSchema == nil {
+ if dbMetadata == nil {
slog.Debug("failed to get database metadata", slog.String("instanceID", instanceID), slog.String("database", table.Database))
return nil, nil, errors.Errorf("failed to get database metadata for InstanceID %q, Database %q", instanceID, table.Database)
}
emptySchema := ""
- schema := dbSchema.GetSchema(emptySchema)
+ schema := dbMetadata.GetSchemaMetadata(emptySchema)
if schema == nil {
return nil, nil, errors.New("failed to get schema metadata")
}
diff --git a/backend/plugin/parser/mysql/backup_test.go b/backend/plugin/parser/mysql/backup_test.go
index 7dd6203367..6d4091f246 100644
--- a/backend/plugin/parser/mysql/backup_test.go
+++ b/backend/plugin/parser/mysql/backup_test.go
@@ -196,7 +196,7 @@ func buildFixedMockDatabaseMetadataGetterAndLister() (base.GetDatabaseMetadataFu
return database, model.NewDatabaseMetadata(&store.DatabaseSchemaMetadata{
Name: database,
Schemas: schemaMetadata,
- }, store.Engine_MYSQL, true /* isObjectCaseSensitive */), nil
+ }, nil, nil, store.Engine_MYSQL, true /* isObjectCaseSensitive */), nil
}, func(_ context.Context, _ string) ([]string, error) {
return []string{"db", "db1", "db2"}, nil
}
diff --git a/backend/plugin/parser/mysql/completion.go b/backend/plugin/parser/mysql/completion.go
index f21a82becf..3e3d638dcd 100644
--- a/backend/plugin/parser/mysql/completion.go
+++ b/backend/plugin/parser/mysql/completion.go
@@ -1413,7 +1413,7 @@ func (m CompletionMap) insertColumns(c *Completer, databases, tables map[string]
}
for table := range tables {
- tableMeta := c.metadataCache[database].GetSchema("").GetTable(table)
+ tableMeta := c.metadataCache[database].GetSchemaMetadata("").GetTable(table)
if tableMeta == nil {
continue
}
@@ -1445,7 +1445,7 @@ func (m CompletionMap) insertAllColumns(c *Completer) {
metadata := c.metadataCache[c.defaultDatabase]
for _, schema := range metadata.ListSchemaNames() {
- schemaMeta := metadata.GetSchema(schema)
+ schemaMeta := metadata.GetSchemaMetadata(schema)
if schemaMeta == nil {
continue
}
@@ -1495,7 +1495,7 @@ func (c *Completer) listTables(database string) []string {
c.metadataCache[database] = metadata
}
- return c.metadataCache[database].GetSchema("").ListTableNames()
+ return c.metadataCache[database].GetSchemaMetadata("").ListTableNames()
}
func (c *Completer) listViews(database string) []string {
@@ -1507,7 +1507,7 @@ func (c *Completer) listViews(database string) []string {
c.metadataCache[database] = metadata
}
- return c.metadataCache[database].GetSchema("").ListViewNames()
+ return c.metadataCache[database].GetSchemaMetadata("").ListViewNames()
}
func (c *Completer) quotedIdentifierIfNeeded(s string) string {
diff --git a/backend/plugin/parser/mysql/completion_test.go b/backend/plugin/parser/mysql/completion_test.go
index c99f4a09ff..6c21b51d80 100644
--- a/backend/plugin/parser/mysql/completion_test.go
+++ b/backend/plugin/parser/mysql/completion_test.go
@@ -139,7 +139,7 @@ func getMetadataForTest(_ context.Context, _, databaseName string) (string, *mod
},
},
},
- }, storepb.Engine_MYSQL, true /* isObjectCaseSensitive */), nil
+ }, nil, nil, storepb.Engine_MYSQL, true /* isObjectCaseSensitive */), nil
}
func catchCaret(s string) (string, int) {
diff --git a/backend/plugin/parser/mysql/query_span_extractor.go b/backend/plugin/parser/mysql/query_span_extractor.go
index 2b24172c99..bcbe6c789c 100644
--- a/backend/plugin/parser/mysql/query_span_extractor.go
+++ b/backend/plugin/parser/mysql/query_span_extractor.go
@@ -1319,7 +1319,7 @@ func (q *querySpanExtractor) findTableSchema(databaseName, tableName string) (ba
databaseName = q.filterClusterName(databaseName)
- var dbSchema *model.DatabaseMetadata
+ var dbMetadata *model.DatabaseMetadata
allDatabaseNames, err := q.gCtx.ListDatabaseNamesFunc(q.ctx, q.gCtx.InstanceID)
if err != nil {
return nil, errors.Wrap(err, "failed to list databases")
@@ -1327,7 +1327,7 @@ func (q *querySpanExtractor) findTableSchema(databaseName, tableName string) (ba
if q.ignoreCaseSensitive {
for _, db := range allDatabaseNames {
if strings.EqualFold(db, databaseName) {
- _, dbSchema, err = q.gCtx.GetDatabaseMetadataFunc(q.ctx, q.gCtx.InstanceID, db)
+ _, dbMetadata, err = q.gCtx.GetDatabaseMetadataFunc(q.ctx, q.gCtx.InstanceID, db)
if err != nil {
return nil, errors.Wrapf(err, "failed to get database metadata for database %q", db)
}
@@ -1337,7 +1337,7 @@ func (q *querySpanExtractor) findTableSchema(databaseName, tableName string) (ba
} else {
for _, db := range allDatabaseNames {
if db == databaseName {
- _, dbSchema, err = q.gCtx.GetDatabaseMetadataFunc(q.ctx, q.gCtx.InstanceID, db)
+ _, dbMetadata, err = q.gCtx.GetDatabaseMetadataFunc(q.ctx, q.gCtx.InstanceID, db)
if err != nil {
return nil, errors.Wrapf(err, "failed to get database metadata for database %q", db)
}
@@ -1345,14 +1345,14 @@ func (q *querySpanExtractor) findTableSchema(databaseName, tableName string) (ba
}
}
}
- if dbSchema == nil {
+ if dbMetadata == nil {
return nil, &parsererror.ResourceNotFoundError{
Database: &databaseName,
}
}
emptySchema := ""
- schema := dbSchema.GetSchema(emptySchema)
+ schema := dbMetadata.GetSchemaMetadata(emptySchema)
if schema == nil {
return nil, &parsererror.ResourceNotFoundError{
Database: &databaseName,
@@ -1379,7 +1379,7 @@ func (q *querySpanExtractor) findTableSchema(databaseName, tableName string) (ba
return &base.PhysicalTable{
Name: tableSchema.GetProto().Name,
Schema: emptySchema,
- Database: dbSchema.GetName(),
+ Database: dbMetadata.GetName(),
Server: "",
Columns: columnNames,
}, nil
@@ -1404,7 +1404,7 @@ func (q *querySpanExtractor) findTableSchema(databaseName, tableName string) (ba
return &base.PhysicalView{
Name: viewSchema.GetProto().Name,
Schema: emptySchema,
- Database: dbSchema.GetName(),
+ Database: dbMetadata.GetName(),
Server: "",
Columns: columns,
}, nil
diff --git a/backend/plugin/parser/mysql/query_span_test.go b/backend/plugin/parser/mysql/query_span_test.go
index fca2cec88a..893c5f7b10 100644
--- a/backend/plugin/parser/mysql/query_span_test.go
+++ b/backend/plugin/parser/mysql/query_span_test.go
@@ -89,7 +89,7 @@ func buildMockDatabaseMetadataGetter(databaseMetadata []*storepb.DatabaseSchemaM
return func(_ context.Context, _, databaseName string) (string, *model.DatabaseMetadata, error) {
m := make(map[string]*model.DatabaseMetadata)
for _, metadata := range databaseMetadata {
- m[metadata.Name] = model.NewDatabaseMetadata(metadata, storepb.Engine_MYSQL, true /* isObjectCaseSensitive */)
+ m[metadata.Name] = model.NewDatabaseMetadata(metadata, nil, nil, storepb.Engine_MYSQL, true /* isObjectCaseSensitive */)
}
if databaseMetadata, ok := m[databaseName]; ok {
diff --git a/backend/plugin/parser/mysql/resource_change.go b/backend/plugin/parser/mysql/resource_change.go
index 8164734263..7f1f5bd743 100644
--- a/backend/plugin/parser/mysql/resource_change.go
+++ b/backend/plugin/parser/mysql/resource_change.go
@@ -19,12 +19,12 @@ func init() {
base.RegisterExtractChangedResourcesFunc(storepb.Engine_DORIS, extractChangedResources)
}
-func extractChangedResources(currentDatabase string, _ string, dbSchema *model.DatabaseSchema, asts any, statement string) (*base.ChangeSummary, error) {
+func extractChangedResources(currentDatabase string, _ string, dbMetadata *model.DatabaseMetadata, asts any, statement string) (*base.ChangeSummary, error) {
nodes, ok := asts.([]*ParseResult)
if !ok {
return nil, errors.Errorf("invalid ast type %T", asts)
}
- changedResources := model.NewChangedResources(dbSchema)
+ changedResources := model.NewChangedResources(dbMetadata)
l := &resourceChangedListener{
currentDatabase: currentDatabase,
statement: statement,
diff --git a/backend/plugin/parser/mysql/resource_change_test.go b/backend/plugin/parser/mysql/resource_change_test.go
index 37a40e4dcf..13f04e2d51 100644
--- a/backend/plugin/parser/mysql/resource_change_test.go
+++ b/backend/plugin/parser/mysql/resource_change_test.go
@@ -19,7 +19,7 @@ func TestExtractChangedResources(t *testing.T) {
UPDATE t1 SET c1 = 5;
CREATE PROCEDURE getUser(id INT) SELECT * FROM hello WHERE uid = id;
`
- changedResources := model.NewChangedResources(nil /* dbSchema */)
+ changedResources := model.NewChangedResources(nil /* dbMetadata */)
changedResources.AddTable(
"db",
"",
@@ -61,7 +61,7 @@ func TestExtractChangedResources(t *testing.T) {
}
asts, _ := ParseMySQL(statement)
- got, err := extractChangedResources("db", "", nil /* dbSchema */, asts, statement)
+ got, err := extractChangedResources("db", "", nil /* dbMetadata */, asts, statement)
require.NoError(t, err)
require.Equal(t, want, got)
}
diff --git a/backend/plugin/parser/mysql/restore.go b/backend/plugin/parser/mysql/restore.go
index 0517f12061..7cd7ae6bf5 100644
--- a/backend/plugin/parser/mysql/restore.go
+++ b/backend/plugin/parser/mysql/restore.go
@@ -218,7 +218,7 @@ func (g *generator) hasDisjointUniqueKey(updateColumns []string) (bool, error) {
return false, errors.Errorf("database metadata is nil for %s", g.originalDatabase)
}
- schema := metadata.GetSchema("")
+ schema := metadata.GetSchemaMetadata("")
if schema == nil {
return false, errors.Errorf("schema is nil for %s", g.originalDatabase)
}
diff --git a/backend/plugin/parser/partiql/completion.go b/backend/plugin/parser/partiql/completion.go
index 39c8704cf1..f3cd23e392 100644
--- a/backend/plugin/parser/partiql/completion.go
+++ b/backend/plugin/parser/partiql/completion.go
@@ -118,7 +118,7 @@ func (m CompletionMap) insertMetadataColumns(c *Completer) {
if databaseMetadata == nil {
return
}
- schema := databaseMetadata.GetSchema("")
+ schema := databaseMetadata.GetSchemaMetadata("")
if schema == nil {
return
}
@@ -159,7 +159,7 @@ func (m CompletionMap) insertMetadataTables(c *Completer) {
if databaseMetadata == nil {
return
}
- schema := databaseMetadata.GetSchema("")
+ schema := databaseMetadata.GetSchemaMetadata("")
if schema == nil {
return
}
diff --git a/backend/plugin/parser/partiql/completion_test.go b/backend/plugin/parser/partiql/completion_test.go
index af21efa9f0..52443ed33e 100644
--- a/backend/plugin/parser/partiql/completion_test.go
+++ b/backend/plugin/parser/partiql/completion_test.go
@@ -126,7 +126,7 @@ func buildMockDatabaseMetadataGetterLister() (base.GetDatabaseMetadataFunc, base
return func(_ context.Context, _, databaseName string) (string, *model.DatabaseMetadata, error) {
m := make(map[string]*model.DatabaseMetadata)
for _, metadata := range databaseMetadatas {
- m[metadata.Name] = model.NewDatabaseMetadata(metadata, storepb.Engine_DYNAMODB, true /* isObjectCaseSensitive */)
+ m[metadata.Name] = model.NewDatabaseMetadata(metadata, nil, nil, storepb.Engine_DYNAMODB, true /* isObjectCaseSensitive */)
}
if databaseMetadata, ok := m[databaseName]; ok {
diff --git a/backend/plugin/parser/pg/completion.go b/backend/plugin/parser/pg/completion.go
index 0cac7a16af..246cf65cde 100644
--- a/backend/plugin/parser/pg/completion.go
+++ b/backend/plugin/parser/pg/completion.go
@@ -400,7 +400,7 @@ func (m CompletionMap) insertColumns(c *Completer, schemas, tables map[string]bo
}
continue
}
- schemaMeta := c.metadataCache[c.defaultDatabase].GetSchema(schema)
+ schemaMeta := c.metadataCache[c.defaultDatabase].GetSchemaMetadata(schema)
if schemaMeta == nil {
continue
}
@@ -437,7 +437,7 @@ func (m CompletionMap) insertAllColumns(c *Completer) {
metadata := c.metadataCache[c.defaultDatabase]
for _, schema := range metadata.ListSchemaNames() {
- schemaMeta := metadata.GetSchema(schema)
+ schemaMeta := metadata.GetSchemaMetadata(schema)
if schemaMeta == nil {
continue
}
@@ -1343,7 +1343,7 @@ func (c *Completer) listTables(schema string) []string {
c.metadataCache[c.defaultDatabase] = metadata
}
- schemaMeta := c.metadataCache[c.defaultDatabase].GetSchema(schema)
+ schemaMeta := c.metadataCache[c.defaultDatabase].GetSchemaMetadata(schema)
if schemaMeta == nil {
return nil
}
@@ -1359,7 +1359,7 @@ func (c *Completer) listForeignTables(schema string) []string {
c.metadataCache[c.defaultDatabase] = metadata
}
- schemaMeta := c.metadataCache[c.defaultDatabase].GetSchema(schema)
+ schemaMeta := c.metadataCache[c.defaultDatabase].GetSchemaMetadata(schema)
if schemaMeta == nil {
return nil
}
@@ -1375,7 +1375,7 @@ func (c *Completer) listMaterializedViews(schema string) []string {
c.metadataCache[c.defaultDatabase] = metadata
}
- schemaMeta := c.metadataCache[c.defaultDatabase].GetSchema(schema)
+ schemaMeta := c.metadataCache[c.defaultDatabase].GetSchemaMetadata(schema)
if schemaMeta == nil {
return nil
}
@@ -1391,7 +1391,7 @@ func (c *Completer) listViews(schema string) []string {
c.metadataCache[c.defaultDatabase] = metadata
}
- schemaMeta := c.metadataCache[c.defaultDatabase].GetSchema(schema)
+ schemaMeta := c.metadataCache[c.defaultDatabase].GetSchemaMetadata(schema)
if schemaMeta == nil {
return nil
}
diff --git a/backend/plugin/parser/pg/completion_test.go b/backend/plugin/parser/pg/completion_test.go
index 05403f818f..8b93aa273e 100644
--- a/backend/plugin/parser/pg/completion_test.go
+++ b/backend/plugin/parser/pg/completion_test.go
@@ -173,7 +173,7 @@ func getMetadataForTest(_ context.Context, _, databaseName string) (string, *mod
},
},
},
- }, storepb.Engine_POSTGRES, true /* isObjectCaseSensitive */), nil
+ }, nil, nil, storepb.Engine_POSTGRES, true /* isObjectCaseSensitive */), nil
}
func catchCaret(s string) (string, int) {
diff --git a/backend/plugin/parser/pg/query_span_extractor.go b/backend/plugin/parser/pg/query_span_extractor.go
index 5181b3c84d..89840ea050 100644
--- a/backend/plugin/parser/pg/query_span_extractor.go
+++ b/backend/plugin/parser/pg/query_span_extractor.go
@@ -239,11 +239,11 @@ type functionDefinition struct {
}
func (q *querySpanExtractor) findFunctionDefine(schemaName, funcName string, nArgs int) (base.TableSource, error) {
- dbSchema, err := q.getDatabaseMetadata(q.defaultDatabase)
+ dbMetadata, err := q.getDatabaseMetadata(q.defaultDatabase)
if err != nil {
return nil, errors.Wrapf(err, "failed to get database metadata for database: %s", q.defaultDatabase)
}
- if dbSchema == nil {
+ if dbMetadata == nil {
return nil, &parsererror.ResourceNotFoundError{
Database: &q.defaultDatabase,
}
@@ -253,7 +253,7 @@ func (q *querySpanExtractor) findFunctionDefine(schemaName, funcName string, nAr
if schemaName != "" {
searchPath = []string{schemaName}
}
- schemas, functions := dbSchema.SearchFunctions(searchPath, funcName)
+ schemas, functions := dbMetadata.SearchFunctions(searchPath, funcName)
for i, fun := range functions {
funcs = append(funcs, &functionDefinition{
schemaName: schemas[i],
@@ -1192,16 +1192,16 @@ func (q *querySpanExtractor) findTableSchema(schemaName string, tableName string
}
// FIXME: consider cross database query which is supported in Redshift.
- dbSchema, err := q.getDatabaseMetadata(q.defaultDatabase)
+ dbMetadata, err := q.getDatabaseMetadata(q.defaultDatabase)
if err != nil {
return nil, errors.Wrapf(err, "failed to get database metadata for database: %s", q.defaultDatabase)
}
- if dbSchema == nil {
+ if dbMetadata == nil {
return nil, &parsererror.ResourceNotFoundError{
Database: &q.defaultDatabase,
}
}
- searcher := dbSchema.NewSearcher(schemaName)
+ searcher := dbMetadata.NewSearcher(schemaName)
tableSchemaName, table := searcher.SearchTable(tableName)
viewSchemaName, view := searcher.SearchView(tableName)
materializedViewSchemaName, materializedView := searcher.SearchMaterializedView(tableName)
diff --git a/backend/plugin/parser/pg/query_span_test.go b/backend/plugin/parser/pg/query_span_test.go
index e78d5d4f80..e08047b629 100644
--- a/backend/plugin/parser/pg/query_span_test.go
+++ b/backend/plugin/parser/pg/query_span_test.go
@@ -76,7 +76,7 @@ func buildMockDatabaseMetadataGetter(databaseMetadata []*storepb.DatabaseSchemaM
return func(_ context.Context, _, databaseName string) (string, *model.DatabaseMetadata, error) {
m := make(map[string]*model.DatabaseMetadata)
for _, metadata := range databaseMetadata {
- m[metadata.Name] = model.NewDatabaseMetadata(metadata, storepb.Engine_POSTGRES, true /* isObjectCaseSensitive */)
+ m[metadata.Name] = model.NewDatabaseMetadata(metadata, nil, nil, storepb.Engine_POSTGRES, true /* isObjectCaseSensitive */)
}
if databaseMetadata, ok := m[databaseName]; ok {
diff --git a/backend/plugin/parser/pg/resource_change.go b/backend/plugin/parser/pg/resource_change.go
index d483be0c8f..ba951c3ff0 100644
--- a/backend/plugin/parser/pg/resource_change.go
+++ b/backend/plugin/parser/pg/resource_change.go
@@ -19,7 +19,7 @@ func init() {
base.RegisterExtractChangedResourcesFunc(storepb.Engine_COCKROACHDB, extractChangedResources)
}
-func extractChangedResources(database string, _ string, dbSchema *model.DatabaseSchema, asts any, statement string) (*base.ChangeSummary, error) {
+func extractChangedResources(database string, _ string, dbMetadata *model.DatabaseMetadata, asts any, statement string) (*base.ChangeSummary, error) {
parseResult, ok := asts.(*ParseResult)
if !ok {
return nil, errors.Errorf("invalid ast type %T, expected *ParseResult", asts)
@@ -29,8 +29,8 @@ func extractChangedResources(database string, _ string, dbSchema *model.Database
return nil, errors.New("parse result or tree is nil")
}
- changedResources := model.NewChangedResources(dbSchema)
- searchPath := dbSchema.GetDatabaseMetadata().GetSearchPath()
+ changedResources := model.NewChangedResources(dbMetadata)
+ searchPath := dbMetadata.GetSearchPath()
if len(searchPath) == 0 {
searchPath = []string{"public"} // default search path for PostgreSQL
}
@@ -39,7 +39,7 @@ func extractChangedResources(database string, _ string, dbSchema *model.Database
database: database,
searchPath: searchPath,
changedResources: changedResources,
- databaseMetadata: dbSchema.GetDatabaseMetadata(),
+ databaseMetadata: dbMetadata,
statement: statement,
tokenStream: parseResult.Tokens,
dmlCount: 0,
diff --git a/backend/plugin/parser/pg/resource_change_test.go b/backend/plugin/parser/pg/resource_change_test.go
index f3530c7b84..70703bccef 100644
--- a/backend/plugin/parser/pg/resource_change_test.go
+++ b/backend/plugin/parser/pg/resource_change_test.go
@@ -12,7 +12,7 @@ import (
)
func TestExtractChangedResources(t *testing.T) {
- dbSchema := model.NewDatabaseSchema(&storepb.DatabaseSchemaMetadata{}, []byte{}, &storepb.DatabaseConfig{}, storepb.Engine_POSTGRES, true /* caseSensitive */)
+ dbMetadata := model.NewDatabaseMetadata(&storepb.DatabaseSchemaMetadata{}, []byte{}, &storepb.DatabaseConfig{}, storepb.Engine_POSTGRES, true /* caseSensitive */)
statement :=
`CREATE TABLE t1 (c1 INT);
DROP TABLE t1;
@@ -22,7 +22,7 @@ func TestExtractChangedResources(t *testing.T) {
INSERT INTO t1 (c1) VALUES (1), (5);
UPDATE t1 SET c1 = 5;
`
- changedResources := model.NewChangedResources(dbSchema)
+ changedResources := model.NewChangedResources(dbMetadata)
changedResources.AddTable(
"db",
"public",
@@ -67,7 +67,7 @@ func TestExtractChangedResources(t *testing.T) {
parseResult, err := ParsePostgreSQL(statement)
require.NoError(t, err)
- got, err := extractChangedResources("db", "public", dbSchema, parseResult, statement)
+ got, err := extractChangedResources("db", "public", dbMetadata, parseResult, statement)
require.NoError(t, err)
require.Equal(t, want, got)
}
diff --git a/backend/plugin/parser/pg/restore.go b/backend/plugin/parser/pg/restore.go
index 2eff78f361..7c803e14b9 100644
--- a/backend/plugin/parser/pg/restore.go
+++ b/backend/plugin/parser/pg/restore.go
@@ -75,7 +75,7 @@ func doGenerate(ctx context.Context, rCtx base.RestoreContext, sqlForComment str
if schema == "" {
schema = "public"
}
- schemaMetadata := metadata.GetSchema(schema)
+ schemaMetadata := metadata.GetSchemaMetadata(schema)
if schemaMetadata == nil {
return "", errors.Errorf("schema metadata not found for %s", schema)
}
diff --git a/backend/plugin/parser/pg/restore_test.go b/backend/plugin/parser/pg/restore_test.go
index 263c377528..9415b43010 100644
--- a/backend/plugin/parser/pg/restore_test.go
+++ b/backend/plugin/parser/pg/restore_test.go
@@ -210,5 +210,5 @@ func fixedMockDatabaseMetadataGetter(_ context.Context, _ string, database strin
},
},
},
- }, store.Engine_POSTGRES, true /* isObjectCaseSensitive */), nil
+ }, nil, nil, store.Engine_POSTGRES, true /* isObjectCaseSensitive */), nil
}
diff --git a/backend/plugin/parser/plsql/completion.go b/backend/plugin/parser/plsql/completion.go
index 14245ea5bd..30520b3245 100644
--- a/backend/plugin/parser/plsql/completion.go
+++ b/backend/plugin/parser/plsql/completion.go
@@ -354,7 +354,7 @@ func (m CompletionMap) insertAllColumns(c *Completer) {
}
c.metadataCache[schema] = metadata
}
- schemaMeta := c.metadataCache[schema].GetSchema("")
+ schemaMeta := c.metadataCache[schema].GetSchemaMetadata("")
for _, table := range schemaMeta.ListTableNames() {
tableMeta := schemaMeta.GetTable(table)
if tableMeta == nil {
@@ -402,7 +402,7 @@ func (m CompletionMap) insertColumns(c *Completer, schemas, tables map[string]bo
}
for table := range tables {
- tableMeta := c.metadataCache[schema].GetSchema("").GetTable(table)
+ tableMeta := c.metadataCache[schema].GetSchemaMetadata("").GetTable(table)
if tableMeta == nil {
continue
}
@@ -449,7 +449,7 @@ func (c *Completer) listTables(schema string) []string {
c.metadataCache[schema] = metadata
}
- return c.metadataCache[schema].GetSchema("").ListTableNames()
+ return c.metadataCache[schema].GetSchemaMetadata("").ListTableNames()
}
func (c *Completer) listViews(schema string) []string {
@@ -461,7 +461,7 @@ func (c *Completer) listViews(schema string) []string {
c.metadataCache[schema] = metadata
}
- return c.metadataCache[schema].GetSchema("").ListViewNames()
+ return c.metadataCache[schema].GetSchemaMetadata("").ListViewNames()
}
func (c *Completer) convertCandidates(candidates *base.CandidatesCollection) ([]base.Candidate, error) {
diff --git a/backend/plugin/parser/plsql/completion_test.go b/backend/plugin/parser/plsql/completion_test.go
index dcde663c81..fb58b8f50d 100644
--- a/backend/plugin/parser/plsql/completion_test.go
+++ b/backend/plugin/parser/plsql/completion_test.go
@@ -141,7 +141,7 @@ func getMetadataForTest(_ context.Context, _, databaseName string) (string, *mod
},
},
},
- }, storepb.Engine_ORACLE, true /* isObjectCaseSensitive */), nil
+ }, nil, nil, storepb.Engine_ORACLE, true /* isObjectCaseSensitive */), nil
case "SCHEMA2":
return "SCHEMA2", model.NewDatabaseMetadata(&storepb.DatabaseSchemaMetadata{
Name: databaseName,
@@ -183,7 +183,7 @@ func getMetadataForTest(_ context.Context, _, databaseName string) (string, *mod
},
},
},
- }, storepb.Engine_ORACLE, true /* isObjectCaseSensitive */), nil
+ }, nil, nil, storepb.Engine_ORACLE, true /* isObjectCaseSensitive */), nil
case "SCHEMA3":
return "SCHEMA3", model.NewDatabaseMetadata(&storepb.DatabaseSchemaMetadata{
Name: databaseName,
@@ -225,7 +225,7 @@ func getMetadataForTest(_ context.Context, _, databaseName string) (string, *mod
},
},
},
- }, storepb.Engine_ORACLE, true /* isObjectCaseSensitive */), nil
+ }, nil, nil, storepb.Engine_ORACLE, true /* isObjectCaseSensitive */), nil
default:
return "", nil, nil
}
diff --git a/backend/plugin/parser/plsql/query_span_extractor.go b/backend/plugin/parser/plsql/query_span_extractor.go
index 6b4e3c2848..d950f52cf7 100644
--- a/backend/plugin/parser/plsql/query_span_extractor.go
+++ b/backend/plugin/parser/plsql/query_span_extractor.go
@@ -155,7 +155,7 @@ func (q *querySpanExtractor) existsTableMetadata(resource base.SchemaResource) b
if meta == nil {
return false
}
- schema := meta.GetSchema("")
+ schema := meta.GetSchemaMetadata("")
if schema == nil {
return false
}
@@ -1301,21 +1301,21 @@ func (q *querySpanExtractor) plsqlFindTableSchema(dbLink []string, schemaName, t
}
}
- dbSchema, err := q.getDatabaseMetadata(schemaName)
+ dbMetadata, err := q.getDatabaseMetadata(schemaName)
if err != nil {
return nil, errors.Wrapf(err, "failed to get database metadata for: %s", schemaName)
}
- if dbSchema == nil {
+ if dbMetadata == nil {
return nil, &parsererror.ResourceNotFoundError{
Database: &schemaName,
}
}
- return q.findTableSchemaInMetadata(q.gCtx.InstanceID, dbSchema, schemaName, tableName)
+ return q.findTableSchemaInMetadata(q.gCtx.InstanceID, dbMetadata, schemaName, tableName)
}
-func (q *querySpanExtractor) findTableSchemaInMetadata(instanceID string, dbSchema *model.DatabaseMetadata, databaseName, tableName string) (base.TableSource, error) {
- schema := dbSchema.GetSchema("")
+func (q *querySpanExtractor) findTableSchemaInMetadata(instanceID string, dbMetadata *model.DatabaseMetadata, databaseName, tableName string) (base.TableSource, error) {
+ schema := dbMetadata.GetSchemaMetadata("")
if schema == nil {
return nil, &parsererror.ResourceNotFoundError{
Database: &databaseName,
diff --git a/backend/plugin/parser/plsql/query_span_test.go b/backend/plugin/parser/plsql/query_span_test.go
index 588b4d85e6..3542ac464d 100644
--- a/backend/plugin/parser/plsql/query_span_test.go
+++ b/backend/plugin/parser/plsql/query_span_test.go
@@ -90,7 +90,7 @@ func buildMockDatabaseMetadataGetter(defaultMetadata []*storepb.DatabaseSchemaMe
}
m := make(map[string]*model.DatabaseMetadata)
for _, metadata := range databaseMetadata {
- m[metadata.Name] = model.NewDatabaseMetadata(metadata, storepb.Engine_ORACLE, true /* isObjectCaseSensitive */)
+ m[metadata.Name] = model.NewDatabaseMetadata(metadata, nil, nil, storepb.Engine_ORACLE, true /* isObjectCaseSensitive */)
}
if databaseMetadata, ok := m[databaseName]; ok {
@@ -128,7 +128,7 @@ func buildMockDatabaseMetadataGetter(defaultMetadata []*storepb.DatabaseSchemaMe
for _, metadata := range getLinkedDatabaseMetadata() {
if metadata.Name == linkedDBInfo.Username {
- return instanceIDB, metadata.Name, model.NewDatabaseMetadata(metadata, storepb.Engine_ORACLE, true /* isObjectCaseSensitive */), nil
+ return instanceIDB, metadata.Name, model.NewDatabaseMetadata(metadata, nil, nil, storepb.Engine_ORACLE, true /* isObjectCaseSensitive */), nil
}
}
diff --git a/backend/plugin/parser/plsql/resource_change.go b/backend/plugin/parser/plsql/resource_change.go
index 768894bf04..3040d8f446 100644
--- a/backend/plugin/parser/plsql/resource_change.go
+++ b/backend/plugin/parser/plsql/resource_change.go
@@ -15,17 +15,17 @@ func init() {
base.RegisterExtractChangedResourcesFunc(storepb.Engine_ORACLE, extractChangedResources)
}
-func extractChangedResources(currentDatabase string, _ string, dbSchema *model.DatabaseSchema, asts any, statement string) (*base.ChangeSummary, error) {
+func extractChangedResources(currentDatabase string, _ string, dbMetadata *model.DatabaseMetadata, asts any, statement string) (*base.ChangeSummary, error) {
// currentDatabase is the same as currentSchema for Oracle.
results, ok := asts.([]*ParseResult)
if !ok {
return nil, errors.Errorf("failed to convert ast to []*ParseResult, got %T", asts)
}
- changedResources := model.NewChangedResources(dbSchema)
+ changedResources := model.NewChangedResources(dbMetadata)
l := &plsqlChangedResourceExtractListener{
currentSchema: currentDatabase,
- dbSchema: dbSchema,
+ dbMetadata: dbMetadata,
changedResources: changedResources,
statement: statement,
}
@@ -46,7 +46,7 @@ type plsqlChangedResourceExtractListener struct {
*parser.BasePlSqlParserListener
currentSchema string
- dbSchema *model.DatabaseSchema
+ dbMetadata *model.DatabaseMetadata
changedResources *model.ChangedResources
statement string
sampleDMLs []string
@@ -198,7 +198,7 @@ func (l *plsqlChangedResourceExtractListener) EnterDrop_index(ctx *parser.Drop_i
if schema == "" {
schema = l.currentSchema
}
- foundSchema := l.dbSchema.GetDatabaseMetadata().GetSchema(schema)
+ foundSchema := l.dbMetadata.GetSchemaMetadata(schema)
if foundSchema == nil {
return
}
diff --git a/backend/plugin/parser/plsql/resource_change_test.go b/backend/plugin/parser/plsql/resource_change_test.go
index d15276fea1..56391898a4 100644
--- a/backend/plugin/parser/plsql/resource_change_test.go
+++ b/backend/plugin/parser/plsql/resource_change_test.go
@@ -15,7 +15,7 @@ func TestExtractChangedResources(t *testing.T) {
CREATE VIEW hello AS SELECT * FROM world;
INSERT INTO T1 (c1) VALUES (1);
`
- changedResources := model.NewChangedResources(nil /* dbSchema */)
+ changedResources := model.NewChangedResources(nil /* dbMetadata */)
changedResources.AddTable(
"DB",
"",
@@ -48,7 +48,7 @@ func TestExtractChangedResources(t *testing.T) {
require.NotEmpty(t, results)
// Pass the full results array to extractChangedResources
- got, err := extractChangedResources("DB", "", nil /* dbSchema */, results, statement)
+ got, err := extractChangedResources("DB", "", nil /* dbMetadata */, results, statement)
require.NoError(t, err)
require.Equal(t, want, got)
}
diff --git a/backend/plugin/parser/plsql/restore.go b/backend/plugin/parser/plsql/restore.go
index a1718c2101..9664a47e35 100644
--- a/backend/plugin/parser/plsql/restore.go
+++ b/backend/plugin/parser/plsql/restore.go
@@ -76,7 +76,7 @@ func doGenerate(ctx context.Context, rCtx base.RestoreContext, sqlForComment str
return "", errors.Wrapf(err, "failed to get database metadata for %s", sourceDatabase)
}
- schemaMetadata := metadata.GetSchema("")
+ schemaMetadata := metadata.GetSchemaMetadata("")
if schemaMetadata == nil {
return "", errors.Errorf("no schema metadata for %s", sourceDatabase)
}
diff --git a/backend/plugin/parser/plsql/restore_test.go b/backend/plugin/parser/plsql/restore_test.go
index 08eb8dffa7..a8019d5cad 100644
--- a/backend/plugin/parser/plsql/restore_test.go
+++ b/backend/plugin/parser/plsql/restore_test.go
@@ -178,5 +178,5 @@ func fixedMockDatabaseMetadataGetter(_ context.Context, _ string, database strin
},
},
},
- }, store.Engine_ORACLE, true /* isObjectCaseSensitive */), nil
+ }, nil, nil, store.Engine_ORACLE, true /* isObjectCaseSensitive */), nil
}
diff --git a/backend/plugin/parser/redshift/completion.go b/backend/plugin/parser/redshift/completion.go
index 13cf599458..8f2be64bb7 100644
--- a/backend/plugin/parser/redshift/completion.go
+++ b/backend/plugin/parser/redshift/completion.go
@@ -409,7 +409,7 @@ func (m CompletionMap) insertColumns(c *Completer, schemas, tables map[string]bo
}
continue
}
- schemaMeta := c.metadataCache[c.defaultDatabase].GetSchema(schema)
+ schemaMeta := c.metadataCache[c.defaultDatabase].GetSchemaMetadata(schema)
if schemaMeta == nil {
continue
}
@@ -446,7 +446,7 @@ func (m CompletionMap) insertAllColumns(c *Completer) {
metadata := c.metadataCache[c.defaultDatabase]
for _, schema := range metadata.ListSchemaNames() {
- schemaMeta := metadata.GetSchema(schema)
+ schemaMeta := metadata.GetSchemaMetadata(schema)
if schemaMeta == nil {
continue
}
@@ -1357,7 +1357,7 @@ func (c *Completer) listTables(schema string) []string {
c.metadataCache[c.defaultDatabase] = metadata
}
- schemaMeta := c.metadataCache[c.defaultDatabase].GetSchema(schema)
+ schemaMeta := c.metadataCache[c.defaultDatabase].GetSchemaMetadata(schema)
if schemaMeta == nil {
return nil
}
@@ -1373,7 +1373,7 @@ func (c *Completer) listForeignTables(schema string) []string {
c.metadataCache[c.defaultDatabase] = metadata
}
- schemaMeta := c.metadataCache[c.defaultDatabase].GetSchema(schema)
+ schemaMeta := c.metadataCache[c.defaultDatabase].GetSchemaMetadata(schema)
if schemaMeta == nil {
return nil
}
@@ -1389,7 +1389,7 @@ func (c *Completer) listMaterializedViews(schema string) []string {
c.metadataCache[c.defaultDatabase] = metadata
}
- schemaMeta := c.metadataCache[c.defaultDatabase].GetSchema(schema)
+ schemaMeta := c.metadataCache[c.defaultDatabase].GetSchemaMetadata(schema)
if schemaMeta == nil {
return nil
}
@@ -1405,7 +1405,7 @@ func (c *Completer) listViews(schema string) []string {
c.metadataCache[c.defaultDatabase] = metadata
}
- schemaMeta := c.metadataCache[c.defaultDatabase].GetSchema(schema)
+ schemaMeta := c.metadataCache[c.defaultDatabase].GetSchemaMetadata(schema)
if schemaMeta == nil {
return nil
}
diff --git a/backend/plugin/parser/redshift/resource_change.go b/backend/plugin/parser/redshift/resource_change.go
index 2d2a9547c0..f7399c3530 100644
--- a/backend/plugin/parser/redshift/resource_change.go
+++ b/backend/plugin/parser/redshift/resource_change.go
@@ -17,17 +17,17 @@ func init() {
base.RegisterExtractChangedResourcesFunc(storepb.Engine_REDSHIFT, extractChangedResources)
}
-func extractChangedResources(database string, _ string, dbSchema *model.DatabaseSchema, asts any, _ string) (*base.ChangeSummary, error) {
+func extractChangedResources(database string, _ string, dbMetadata *model.DatabaseMetadata, asts any, _ string) (*base.ChangeSummary, error) {
tree, ok := asts.(antlr.Tree)
if !ok {
return nil, errors.Errorf("invalid ast type %T, expected antlr.Tree", asts)
}
- changedResources := model.NewChangedResources(dbSchema)
+ changedResources := model.NewChangedResources(dbMetadata)
listener := &resourceChangeListener{
currentDatabase: database,
changedResources: changedResources,
- dbSchema: dbSchema,
+ dbMetadata: dbMetadata,
searchPath: []string{"public"}, // Default search path for Redshift
}
@@ -46,7 +46,7 @@ type resourceChangeListener struct {
currentDatabase string
changedResources *model.ChangedResources
- dbSchema *model.DatabaseSchema
+ dbMetadata *model.DatabaseMetadata
searchPath []string
sampleDMLs []string
dmlCount int
diff --git a/backend/plugin/parser/snowflake/query_span_extractor.go b/backend/plugin/parser/snowflake/query_span_extractor.go
index 4e9609e174..8c5ff19e1e 100644
--- a/backend/plugin/parser/snowflake/query_span_extractor.go
+++ b/backend/plugin/parser/snowflake/query_span_extractor.go
@@ -1105,7 +1105,7 @@ func (q *querySpanExtractor) findTableSchema(objectName parser.IObject_nameConte
if normalizedSchemaName != "" && normalizedSchemaName != schemaSchema {
continue
}
- schema := database.GetSchema(normalizedSchemaName)
+ schema := database.GetSchemaMetadata(normalizedSchemaName)
if schema == nil {
return "", nil, errors.Errorf(`schema %s.%s is not found`, normalizedDatabaseName, normalizedSchemaName)
}
diff --git a/backend/plugin/parser/snowflake/query_span_test.go b/backend/plugin/parser/snowflake/query_span_test.go
index ebe0d3c92c..a0279cee9a 100644
--- a/backend/plugin/parser/snowflake/query_span_test.go
+++ b/backend/plugin/parser/snowflake/query_span_test.go
@@ -82,7 +82,7 @@ func buildMockDatabaseMetadataGetter(databaseMetadata []*storepb.DatabaseSchemaM
return func(_ context.Context, _, databaseName string) (string, *model.DatabaseMetadata, error) {
m := make(map[string]*model.DatabaseMetadata)
for _, metadata := range databaseMetadata {
- m[metadata.Name] = model.NewDatabaseMetadata(metadata, storepb.Engine_SNOWFLAKE, true /* isObjectCaseSensitive */)
+ m[metadata.Name] = model.NewDatabaseMetadata(metadata, nil, nil, storepb.Engine_SNOWFLAKE, true /* isObjectCaseSensitive */)
}
if databaseMetadata, ok := m[databaseName]; ok {
diff --git a/backend/plugin/parser/spanner/query_span_extractor.go b/backend/plugin/parser/spanner/query_span_extractor.go
index 761c497205..5f5318cb3b 100644
--- a/backend/plugin/parser/spanner/query_span_extractor.go
+++ b/backend/plugin/parser/spanner/query_span_extractor.go
@@ -1106,7 +1106,7 @@ func (q *querySpanExtractor) findTableSchema(schemaName string, tableName string
return nil, errors.Errorf("database %q not found", q.defaultDatabase)
}
- schema := databaseMetadata.GetSchema(schemaName)
+ schema := databaseMetadata.GetSchemaMetadata(schemaName)
if schema == nil {
return nil, &parsererror.ResourceNotFoundError{
Database: &q.defaultDatabase,
diff --git a/backend/plugin/parser/spanner/query_span_test.go b/backend/plugin/parser/spanner/query_span_test.go
index 6446075bc5..ea5d23ef01 100644
--- a/backend/plugin/parser/spanner/query_span_test.go
+++ b/backend/plugin/parser/spanner/query_span_test.go
@@ -81,7 +81,7 @@ func buildMockDatabaseMetadataGetter(databaseMetadata []*storepb.DatabaseSchemaM
return func(_ context.Context, _, databaseName string) (string, *model.DatabaseMetadata, error) {
m := make(map[string]*model.DatabaseMetadata)
for _, metadata := range databaseMetadata {
- m[metadata.Name] = model.NewDatabaseMetadata(metadata, storepb.Engine_SPANNER, true /* isObjectCaseSensitive */)
+ m[metadata.Name] = model.NewDatabaseMetadata(metadata, nil, nil, storepb.Engine_SPANNER, true /* isObjectCaseSensitive */)
}
if databaseMetadata, ok := m[databaseName]; ok {
diff --git a/backend/plugin/parser/tidb/backup.go b/backend/plugin/parser/tidb/backup.go
index 4da2a79a9c..f0b22473d0 100644
--- a/backend/plugin/parser/tidb/backup.go
+++ b/backend/plugin/parser/tidb/backup.go
@@ -278,7 +278,7 @@ func classifyColumns(ctx context.Context, getDatabaseMetadataFunc base.GetDataba
return nil, nil, errors.New("GetDatabaseMetadataFunc is not set")
}
- var dbSchema *model.DatabaseMetadata
+ var dbMetadata *model.DatabaseMetadata
allDatabaseNames, err := listDatabaseNamesFunc(ctx, instanceID)
if err != nil {
return nil, nil, errors.Wrap(err, "failed to list databases names")
@@ -286,7 +286,7 @@ func classifyColumns(ctx context.Context, getDatabaseMetadataFunc base.GetDataba
if !isCaseSensitive {
for _, db := range allDatabaseNames {
if strings.EqualFold(db, table.Database) {
- _, dbSchema, err = getDatabaseMetadataFunc(ctx, instanceID, db)
+ _, dbMetadata, err = getDatabaseMetadataFunc(ctx, instanceID, db)
if err != nil {
return nil, nil, errors.Wrapf(err, "failed to get database metadata for database %q", db)
}
@@ -296,7 +296,7 @@ func classifyColumns(ctx context.Context, getDatabaseMetadataFunc base.GetDataba
} else {
for _, db := range allDatabaseNames {
if db == table.Database {
- _, dbSchema, err = getDatabaseMetadataFunc(ctx, instanceID, db)
+ _, dbMetadata, err = getDatabaseMetadataFunc(ctx, instanceID, db)
if err != nil {
return nil, nil, errors.Wrapf(err, "failed to get database metadata for database %q", db)
}
@@ -304,13 +304,13 @@ func classifyColumns(ctx context.Context, getDatabaseMetadataFunc base.GetDataba
}
}
}
- if dbSchema == nil {
+ if dbMetadata == nil {
slog.Debug("failed to get database metadata", slog.String("instanceID", instanceID), slog.String("database", table.Database))
return nil, nil, errors.Errorf("failed to get database metadata for InstanceID %q, Database %q", instanceID, table.Database)
}
emptySchema := ""
- schema := dbSchema.GetSchema(emptySchema)
+ schema := dbMetadata.GetSchemaMetadata(emptySchema)
if schema == nil {
return nil, nil, errors.New("failed to get schema metadata")
}
diff --git a/backend/plugin/parser/tidb/backup_test.go b/backend/plugin/parser/tidb/backup_test.go
index ad6897091f..762847347a 100644
--- a/backend/plugin/parser/tidb/backup_test.go
+++ b/backend/plugin/parser/tidb/backup_test.go
@@ -166,7 +166,7 @@ func buildFixedMockDatabaseMetadataGetterAndLister() (base.GetDatabaseMetadataFu
return database, model.NewDatabaseMetadata(&store.DatabaseSchemaMetadata{
Name: database,
Schemas: schemaMetadata,
- }, store.Engine_TIDB, false /* isObjectCaseSensitive */), nil
+ }, nil, nil, store.Engine_TIDB, false /* isObjectCaseSensitive */), nil
}, func(_ context.Context, _ string) ([]string, error) {
return []string{"db", "db1", "db2"}, nil
}
diff --git a/backend/plugin/parser/tidb/query_span_extractor.go b/backend/plugin/parser/tidb/query_span_extractor.go
index 2e6b07e159..4b31385d49 100644
--- a/backend/plugin/parser/tidb/query_span_extractor.go
+++ b/backend/plugin/parser/tidb/query_span_extractor.go
@@ -184,7 +184,7 @@ func (q *querySpanExtractor) existsTableMetadata(databaseName string, tableName
if databaseMetadata == nil {
return false
}
- schemaMetadata := databaseMetadata.GetSchema("")
+ schemaMetadata := databaseMetadata.GetSchemaMetadata("")
if schemaMetadata == nil {
return false
}
@@ -797,17 +797,17 @@ func (q *querySpanExtractor) findTableSchema(databaseName string, tableName stri
databaseName = q.defaultDatabase
}
- dbSchema, err := q.getDatabaseMetadata(databaseName)
+ dbMetadata, err := q.getDatabaseMetadata(databaseName)
if err != nil {
return nil, errors.Wrapf(err, "failed to get database metadata for %q", databaseName)
}
- if dbSchema == nil {
+ if dbMetadata == nil {
return nil, &parsererror.ResourceNotFoundError{
Database: &databaseName,
}
}
emptySchema := ""
- schema := dbSchema.GetSchema("")
+ schema := dbMetadata.GetSchemaMetadata("")
if schema == nil {
return nil, &parsererror.ResourceNotFoundError{
Database: &databaseName,
diff --git a/backend/plugin/parser/tidb/query_span_test.go b/backend/plugin/parser/tidb/query_span_test.go
index 089d1e2c13..356f98c52b 100644
--- a/backend/plugin/parser/tidb/query_span_test.go
+++ b/backend/plugin/parser/tidb/query_span_test.go
@@ -80,7 +80,7 @@ func buildMockDatabaseMetadataGetter(databaseMetadata []*storepb.DatabaseSchemaM
return func(_ context.Context, _, databaseName string) (string, *model.DatabaseMetadata, error) {
m := make(map[string]*model.DatabaseMetadata)
for _, metadata := range databaseMetadata {
- m[metadata.Name] = model.NewDatabaseMetadata(metadata, storepb.Engine_TIDB, false /* isObjectCaseSensitive */)
+ m[metadata.Name] = model.NewDatabaseMetadata(metadata, nil, nil, storepb.Engine_TIDB, false /* isObjectCaseSensitive */)
}
if databaseMetadata, ok := m[databaseName]; ok {
diff --git a/backend/plugin/parser/tidb/resource_change.go b/backend/plugin/parser/tidb/resource_change.go
index a6bf10504b..2ad9a8ca2e 100644
--- a/backend/plugin/parser/tidb/resource_change.go
+++ b/backend/plugin/parser/tidb/resource_change.go
@@ -18,13 +18,13 @@ func init() {
base.RegisterExtractChangedResourcesFunc(storepb.Engine_TIDB, extractChangedResources)
}
-func extractChangedResources(database string, _ string, dbSchema *model.DatabaseSchema, asts any, statement string) (*base.ChangeSummary, error) {
+func extractChangedResources(database string, _ string, dbMetadata *model.DatabaseMetadata, asts any, statement string) (*base.ChangeSummary, error) {
nodes, ok := asts.([]tidbast.StmtNode)
if !ok {
return nil, errors.Errorf("invalid ast type %T", asts)
}
- changedResources := model.NewChangedResources(dbSchema)
+ changedResources := model.NewChangedResources(dbMetadata)
dmlCount := 0
insertCount := 0
var sampleDMLs []string
diff --git a/backend/plugin/parser/tidb/resource_change_test.go b/backend/plugin/parser/tidb/resource_change_test.go
index c6f90860b8..a5060fdeba 100644
--- a/backend/plugin/parser/tidb/resource_change_test.go
+++ b/backend/plugin/parser/tidb/resource_change_test.go
@@ -18,7 +18,7 @@ func TestExtractChangedResources(t *testing.T) {
INSERT INTO t1 (c1) VALUES (1), (5);
UPDATE t1 SET c1 = 5;
`
- changedResources := model.NewChangedResources(nil /* dbSchema */)
+ changedResources := model.NewChangedResources(nil /* dbMetadata */)
changedResources.AddTable(
"db",
"",
@@ -54,7 +54,7 @@ func TestExtractChangedResources(t *testing.T) {
}
asts, _ := ParseTiDB(statement, "", "")
- got, err := extractChangedResources("db", "", nil /* dbSchema */, asts, statement)
+ got, err := extractChangedResources("db", "", nil /* dbMetadata */, asts, statement)
require.NoError(t, err)
require.Equal(t, want, got)
}
diff --git a/backend/plugin/parser/trino/completion.go b/backend/plugin/parser/trino/completion.go
index 3b2ab69245..3e70b041ec 100644
--- a/backend/plugin/parser/trino/completion.go
+++ b/backend/plugin/parser/trino/completion.go
@@ -204,7 +204,7 @@ func (m CompletionMap) insertMetadataTables(c *Completer, catalog string, schema
}
}
- schemaMetadata := catalogMetadata.GetSchema(schemaName)
+ schemaMetadata := catalogMetadata.GetSchemaMetadata(schemaName)
if schemaMetadata == nil {
return
}
@@ -224,7 +224,7 @@ func (m CompletionMap) insertAllColumns(c *Completer) {
return
}
for _, schema := range catalogMeta.ListSchemaNames() {
- schemaMeta := catalogMeta.GetSchema(schema)
+ schemaMeta := catalogMeta.GetSchemaMetadata(schema)
if schemaMeta == nil {
continue
}
@@ -308,7 +308,7 @@ func (m CompletionMap) insertMetadataColumns(c *Completer, catalog string, schem
break
}
}
- schemaMetadata := catalogMetadata.GetSchema(schemaName)
+ schemaMetadata := catalogMetadata.GetSchemaMetadata(schemaName)
if schemaMetadata == nil {
return
}
@@ -394,7 +394,7 @@ func (m CompletionMap) insertMetadataViews(c *Completer, catalog string, schema
return
}
- schemaMetadata := catalogMetadata.GetSchema(schemaName)
+ schemaMetadata := catalogMetadata.GetSchemaMetadata(schemaName)
if schemaMetadata == nil {
return
}
diff --git a/backend/plugin/parser/trino/completion_test.go b/backend/plugin/parser/trino/completion_test.go
index 5928427f64..9e3430bb7f 100644
--- a/backend/plugin/parser/trino/completion_test.go
+++ b/backend/plugin/parser/trino/completion_test.go
@@ -207,7 +207,7 @@ func buildMockDatabaseMetadataGetterLister() (base.GetDatabaseMetadataFunc, base
return func(_ context.Context, _, databaseName string) (string, *model.DatabaseMetadata, error) {
m := make(map[string]*model.DatabaseMetadata)
for _, metadata := range databaseMetadatas {
- m[metadata.Name] = model.NewDatabaseMetadata(metadata, storepb.Engine_MYSQL, false /* isObjectCaseSensitive */)
+ m[metadata.Name] = model.NewDatabaseMetadata(metadata, nil, nil, storepb.Engine_MYSQL, false /* isObjectCaseSensitive */)
}
if databaseMetadata, ok := m[databaseName]; ok {
diff --git a/backend/plugin/parser/trino/query_span_extractor.go b/backend/plugin/parser/trino/query_span_extractor.go
index 6f8263aa26..2958459318 100644
--- a/backend/plugin/parser/trino/query_span_extractor.go
+++ b/backend/plugin/parser/trino/query_span_extractor.go
@@ -288,7 +288,7 @@ func (q *querySpanExtractor) findTableSchema(db, schema, name string) (*model.Ta
}
// Get schema metadata
- schemaMeta := metadata.GetSchema(schema)
+ schemaMeta := metadata.GetSchemaMetadata(schema)
if schemaMeta == nil {
return nil, &parsererror.ResourceNotFoundError{
Database: &db,
diff --git a/backend/plugin/parser/trino/query_span_test.go b/backend/plugin/parser/trino/query_span_test.go
index bcdd2610e9..fe51e23ca4 100644
--- a/backend/plugin/parser/trino/query_span_test.go
+++ b/backend/plugin/parser/trino/query_span_test.go
@@ -212,7 +212,7 @@ func buildMockDatabaseMetadataGetter(databaseMetadata []*storepb.DatabaseSchemaM
return func(_ context.Context, _, databaseName string) (string, *model.DatabaseMetadata, error) {
m := make(map[string]*model.DatabaseMetadata)
for _, metadata := range databaseMetadata {
- m[metadata.Name] = model.NewDatabaseMetadata(metadata, storepb.Engine_POSTGRES, true /* isObjectCaseSensitive */)
+ m[metadata.Name] = model.NewDatabaseMetadata(metadata, nil, nil, storepb.Engine_POSTGRES, true /* isObjectCaseSensitive */)
}
if databaseMetadata, ok := m[databaseName]; ok {
diff --git a/backend/plugin/parser/tsql/completion.go b/backend/plugin/parser/tsql/completion.go
index aaf6a43ba9..50120ac15c 100644
--- a/backend/plugin/parser/tsql/completion.go
+++ b/backend/plugin/parser/tsql/completion.go
@@ -262,7 +262,7 @@ func (m CompletionMap) insertMetadataTables(c *Completer, linkedServer string, d
}
}
- schemaMetadata := databaseMetadata.GetSchema(schemaName)
+ schemaMetadata := databaseMetadata.GetSchemaMetadata(schemaName)
if schemaMetadata == nil {
return
}
@@ -282,7 +282,7 @@ func (m CompletionMap) insertAllColumns(c *Completer) {
return
}
for _, schema := range databaseMeta.ListSchemaNames() {
- schemaMeta := databaseMeta.GetSchema(schema)
+ schemaMeta := databaseMeta.GetSchemaMetadata(schema)
if schemaMeta == nil {
continue
}
@@ -369,7 +369,7 @@ func (m CompletionMap) insertMetadataColumns(c *Completer, linkedServer string,
break
}
}
- schemaMetadata := databaseMetadata.GetSchema(schemaName)
+ schemaMetadata := databaseMetadata.GetSchemaMetadata(schemaName)
if schemaMetadata == nil {
return
}
@@ -449,7 +449,7 @@ func (m CompletionMap) insertMetadataViews(c *Completer, linkedServer string, da
}
}
- schemaMetadata := databaseMetadata.GetSchema(schemaName)
+ schemaMetadata := databaseMetadata.GetSchemaMetadata(schemaName)
if schemaMetadata == nil {
return
}
diff --git a/backend/plugin/parser/tsql/completion_test.go b/backend/plugin/parser/tsql/completion_test.go
index 8495e40af4..5f227977cd 100644
--- a/backend/plugin/parser/tsql/completion_test.go
+++ b/backend/plugin/parser/tsql/completion_test.go
@@ -204,7 +204,7 @@ func buildMockDatabaseMetadataGetterLister() (base.GetDatabaseMetadataFunc, base
return func(_ context.Context, _, databaseName string) (string, *model.DatabaseMetadata, error) {
m := make(map[string]*model.DatabaseMetadata)
for _, metadata := range databaseMetadatas {
- m[metadata.Name] = model.NewDatabaseMetadata(metadata, storepb.Engine_MSSQL, false /* isObjectCaseSensitive */)
+ m[metadata.Name] = model.NewDatabaseMetadata(metadata, nil, nil, storepb.Engine_MSSQL, false /* isObjectCaseSensitive */)
}
if databaseMetadata, ok := m[databaseName]; ok {
diff --git a/backend/plugin/parser/tsql/query_span_extractor.go b/backend/plugin/parser/tsql/query_span_extractor.go
index 437fe65e35..432040a44c 100644
--- a/backend/plugin/parser/tsql/query_span_extractor.go
+++ b/backend/plugin/parser/tsql/query_span_extractor.go
@@ -695,7 +695,7 @@ func (q *querySpanExtractor) tsqlFindTableSchema(fullTableName parser.IFull_tabl
if normalizedSchemaName != "" && !q.isIdentifierEqual(normalizedSchemaName, schemaName) {
continue
}
- schemaSchema := database.GetSchema(schemaName)
+ schemaSchema := database.GetSchemaMetadata(schemaName)
allTableNames := schemaSchema.ListTableNames()
for _, tableName := range allTableNames {
if !q.isIdentifierEqual(normalizedTableName, tableName) {
diff --git a/backend/plugin/parser/tsql/query_span_test.go b/backend/plugin/parser/tsql/query_span_test.go
index efc6935700..df291ba8dc 100644
--- a/backend/plugin/parser/tsql/query_span_test.go
+++ b/backend/plugin/parser/tsql/query_span_test.go
@@ -86,7 +86,7 @@ func buildMockDatabaseMetadataGetter(databaseMetadata []*storepb.DatabaseSchemaM
return func(_ context.Context, _, databaseName string) (string, *model.DatabaseMetadata, error) {
m := make(map[string]*model.DatabaseMetadata)
for _, metadata := range databaseMetadata {
- m[metadata.Name] = model.NewDatabaseMetadata(metadata, storepb.Engine_MSSQL, false /* isObjectCaseSensitive */)
+ m[metadata.Name] = model.NewDatabaseMetadata(metadata, nil, nil, storepb.Engine_MSSQL, false /* isObjectCaseSensitive */)
}
if databaseMetadata, ok := m[databaseName]; ok {
diff --git a/backend/plugin/parser/tsql/resource_change.go b/backend/plugin/parser/tsql/resource_change.go
index e5924429ef..31b1e7291b 100644
--- a/backend/plugin/parser/tsql/resource_change.go
+++ b/backend/plugin/parser/tsql/resource_change.go
@@ -19,17 +19,17 @@ func init() {
base.RegisterExtractChangedResourcesFunc(storepb.Engine_MSSQL, extractChangedResources)
}
-func extractChangedResources(currentDatabase string, currentSchema string, dbSchema *model.DatabaseSchema, asts any, statement string) (*base.ChangeSummary, error) {
+func extractChangedResources(currentDatabase string, currentSchema string, dbMetadata *model.DatabaseMetadata, asts any, statement string) (*base.ChangeSummary, error) {
tree, ok := asts.(antlr.Tree)
if !ok {
return nil, errors.Errorf("failed to convert ast to antlr.Tree")
}
- changedResources := model.NewChangedResources(dbSchema)
+ changedResources := model.NewChangedResources(dbMetadata)
l := &tsqlChangedResourceExtractListener{
currentDatabase: currentDatabase,
currentSchema: currentSchema,
- dbSchema: dbSchema,
+ dbMetadata: dbMetadata,
changedResources: changedResources,
statement: statement,
}
@@ -49,7 +49,7 @@ type tsqlChangedResourceExtractListener struct {
currentDatabase string
currentSchema string
- dbSchema *model.DatabaseSchema
+ dbMetadata *model.DatabaseMetadata
changedResources *model.ChangedResources
statement string
sampleDMLs []string
diff --git a/backend/plugin/parser/tsql/resource_change_test.go b/backend/plugin/parser/tsql/resource_change_test.go
index f631e84e62..74657a172c 100644
--- a/backend/plugin/parser/tsql/resource_change_test.go
+++ b/backend/plugin/parser/tsql/resource_change_test.go
@@ -17,7 +17,7 @@ func TestExtractChangedResources(t *testing.T) {
INSERT INTO t1 (c1) VALUES (1), (5);
UPDATE t1 SET c1 = 5;
`
- changedResources := model.NewChangedResources(nil /* dbSchema */)
+ changedResources := model.NewChangedResources(nil /* dbMetadata */)
changedResources.AddTable(
"DB",
"dbo",
@@ -44,7 +44,7 @@ func TestExtractChangedResources(t *testing.T) {
asts, err := ParseTSQL(statement)
require.NoError(t, err)
- got, err := extractChangedResources("DB", "dbo", nil /* dbSchema */, asts.Tree, statement)
+ got, err := extractChangedResources("DB", "dbo", nil /* dbMetadata */, asts.Tree, statement)
require.NoError(t, err)
require.Equal(t, want, got)
}
diff --git a/backend/plugin/parser/tsql/restore.go b/backend/plugin/parser/tsql/restore.go
index 493995d520..4c7b198966 100644
--- a/backend/plugin/parser/tsql/restore.go
+++ b/backend/plugin/parser/tsql/restore.go
@@ -73,7 +73,7 @@ func doGenerate(ctx context.Context, rCtx base.RestoreContext, sqlForComment str
if schema == "" {
schema = "dbo"
}
- schemaMetadata := metadata.GetSchema(schema)
+ schemaMetadata := metadata.GetSchemaMetadata(schema)
if schemaMetadata == nil {
return "", errors.Errorf("schema metadata not found for %s", schema)
}
diff --git a/backend/plugin/parser/tsql/restore_test.go b/backend/plugin/parser/tsql/restore_test.go
index ade47b78c4..227879ea21 100644
--- a/backend/plugin/parser/tsql/restore_test.go
+++ b/backend/plugin/parser/tsql/restore_test.go
@@ -64,7 +64,7 @@ func TestRestoreIdentityHandling(t *testing.T) {
},
},
},
- }, store.Engine_MSSQL, false), nil
+ }, nil, nil, store.Engine_MSSQL, false), nil
}
// Test DELETE rollback with IDENTITY column
@@ -255,5 +255,5 @@ func fixedMockDatabaseMetadataGetter(_ context.Context, _ string, database strin
},
},
},
- }, store.Engine_MSSQL, false /* isObjectCaseSensitive */), nil
+ }, nil, nil, store.Engine_MSSQL, false /* isObjectCaseSensitive */), nil
}
diff --git a/backend/plugin/schema/differ.go b/backend/plugin/schema/differ.go
index d6726ae152..f0786688d5 100644
--- a/backend/plugin/schema/differ.go
+++ b/backend/plugin/schema/differ.go
@@ -306,8 +306,8 @@ type CommentDiff struct {
NewASTNode antlr.ParserRuleContext
}
-// GetDatabaseSchemaDiff compares two model.DatabaseSchema instances and returns the differences.
-func GetDatabaseSchemaDiff(engine storepb.Engine, oldSchema, newSchema *model.DatabaseSchema) (*MetadataDiff, error) {
+// GetDatabaseSchemaDiff compares two model.DatabaseMetadata instances and returns the differences.
+func GetDatabaseSchemaDiff(engine storepb.Engine, oldSchema, newSchema *model.DatabaseMetadata) (*MetadataDiff, error) {
if oldSchema == nil || newSchema == nil {
return nil, nil
}
@@ -323,12 +323,12 @@ func GetDatabaseSchemaDiff(engine storepb.Engine, oldSchema, newSchema *model.Da
}
// Use the internal DatabaseMetadata structures for efficient access
- oldMeta := oldSchema.GetDatabaseMetadata()
- newMeta := newSchema.GetDatabaseMetadata()
+ oldMeta := oldSchema
+ newMeta := newSchema
for _, schemaName := range oldMeta.ListSchemaNames() {
- if newMeta.GetSchema(schemaName) == nil {
- oldSchemaMeta := oldMeta.GetSchema(schemaName)
+ if newMeta.GetSchemaMetadata(schemaName) == nil {
+ oldSchemaMeta := oldMeta.GetSchemaMetadata(schemaName)
if oldSchemaMeta != nil {
diff.SchemaChanges = append(diff.SchemaChanges, &SchemaDiff{
Action: MetadataDiffActionDrop,
@@ -340,12 +340,12 @@ func GetDatabaseSchemaDiff(engine storepb.Engine, oldSchema, newSchema *model.Da
}
for _, schemaName := range newMeta.ListSchemaNames() {
- newSchemaMeta := newMeta.GetSchema(schemaName)
+ newSchemaMeta := newMeta.GetSchemaMetadata(schemaName)
if newSchemaMeta == nil {
continue
}
- if oldMeta.GetSchema(schemaName) == nil {
+ if oldMeta.GetSchemaMetadata(schemaName) == nil {
// New schema
diff.SchemaChanges = append(diff.SchemaChanges, &SchemaDiff{
Action: MetadataDiffActionCreate,
@@ -356,7 +356,7 @@ func GetDatabaseSchemaDiff(engine storepb.Engine, oldSchema, newSchema *model.Da
addNewSchemaObjects(diff, schemaName, newSchemaMeta)
} else {
// Compare schema objects
- oldSchemaMeta := oldMeta.GetSchema(schemaName)
+ oldSchemaMeta := oldMeta.GetSchemaMetadata(schemaName)
if oldSchemaMeta != nil {
compareSchemaObjects(engine, diff, schemaName, oldSchemaMeta, newSchemaMeta)
}
diff --git a/backend/plugin/schema/mssql/generate_migration.go b/backend/plugin/schema/mssql/generate_migration.go
index bce51e374c..bdebd12bac 100644
--- a/backend/plugin/schema/mssql/generate_migration.go
+++ b/backend/plugin/schema/mssql/generate_migration.go
@@ -1111,7 +1111,7 @@ func getViewDependencies(viewDef string, schemaName string) ([]string, error) {
},
},
}
- dbMetadata := model.NewDatabaseMetadata(metadata, storepb.Engine_MSSQL, false)
+ dbMetadata := model.NewDatabaseMetadata(metadata, nil, nil, storepb.Engine_MSSQL, false)
return databaseName, dbMetadata, nil
},
ListDatabaseNamesFunc: func(_ context.Context, _ string) ([]string, error) {
diff --git a/backend/plugin/schema/mssql/generate_migration_test.go b/backend/plugin/schema/mssql/generate_migration_test.go
index c77fdd8dac..99650d1516 100644
--- a/backend/plugin/schema/mssql/generate_migration_test.go
+++ b/backend/plugin/schema/mssql/generate_migration_test.go
@@ -48,11 +48,11 @@ func runMigrationTest(t *testing.T, file string) {
require.NoErrorf(t, err, "Failed to parse new schema for test case [%02d]: %s", i+1, test.Description)
// Convert to model.DatabaseSchema
- var oldDBSchema *model.DatabaseSchema
+ var oldDBSchema *model.DatabaseMetadata
if oldMetadata != nil {
- oldDBSchema = model.NewDatabaseSchema(oldMetadata, nil, nil, storepb.Engine_MSSQL, false)
+ oldDBSchema = model.NewDatabaseMetadata(oldMetadata, nil, nil, storepb.Engine_MSSQL, false)
}
- newDBSchema := model.NewDatabaseSchema(newMetadata, nil, nil, storepb.Engine_MSSQL, false)
+ newDBSchema := model.NewDatabaseMetadata(newMetadata, nil, nil, storepb.Engine_MSSQL, false)
// Get diff
var diff *schema.MetadataDiff
@@ -64,7 +64,7 @@ func runMigrationTest(t *testing.T, file string) {
Name: "",
Schemas: []*storepb.SchemaMetadata{},
}
- oldDBSchema = model.NewDatabaseSchema(emptyMetadata, nil, nil, storepb.Engine_MSSQL, false)
+ oldDBSchema = model.NewDatabaseMetadata(emptyMetadata, nil, nil, storepb.Engine_MSSQL, false)
}
// Handle case where new schema is empty (dropping everything)
@@ -79,7 +79,7 @@ func runMigrationTest(t *testing.T, file string) {
},
},
}
- newDBSchema = model.NewDatabaseSchema(emptyMetadata, nil, nil, storepb.Engine_MSSQL, false)
+ newDBSchema = model.NewDatabaseMetadata(emptyMetadata, nil, nil, storepb.Engine_MSSQL, false)
}
diff, err = schema.GetDatabaseSchemaDiff(storepb.Engine_MSSQL, oldDBSchema, newDBSchema)
diff --git a/backend/plugin/schema/mssql/generate_migration_testcontainer_test.go b/backend/plugin/schema/mssql/generate_migration_testcontainer_test.go
index 0581fc8776..8405802187 100644
--- a/backend/plugin/schema/mssql/generate_migration_testcontainer_test.go
+++ b/backend/plugin/schema/mssql/generate_migration_testcontainer_test.go
@@ -2493,11 +2493,11 @@ func executeFiveStepWorkflow(ctx context.Context, host string, port int, initial
// Step 3: Generate rollback DDL using generate_migration
// Convert to model schemas for diff
- dbSchemaA := model.NewDatabaseSchema(schemaA, nil, nil, storepb.Engine_MSSQL, false)
- dbSchemaB := model.NewDatabaseSchema(schemaB, nil, nil, storepb.Engine_MSSQL, false)
+ dbMetadataA := model.NewDatabaseMetadata(schemaA, nil, nil, storepb.Engine_MSSQL, false)
+ dbMetadataB := model.NewDatabaseMetadata(schemaB, nil, nil, storepb.Engine_MSSQL, false)
// Get diff from B to A (to generate rollback)
- diff, err := schema.GetDatabaseSchemaDiff(storepb.Engine_MSSQL, dbSchemaB, dbSchemaA)
+ diff, err := schema.GetDatabaseSchemaDiff(storepb.Engine_MSSQL, dbMetadataB, dbMetadataA)
if err != nil {
return errors.Wrap(err, "failed to generate diff")
}
diff --git a/backend/plugin/schema/mysql/generate_migration_testcontainer_test.go b/backend/plugin/schema/mysql/generate_migration_testcontainer_test.go
index 60e68c11b4..983e006bb2 100644
--- a/backend/plugin/schema/mysql/generate_migration_testcontainer_test.go
+++ b/backend/plugin/schema/mysql/generate_migration_testcontainer_test.go
@@ -1677,11 +1677,11 @@ CREATE TABLE some_table (
// Step 3: Call generate migration to get the rollback DDL
// Convert to model.DatabaseSchema
- dbSchemaA := model.NewDatabaseSchema(schemaA, nil, nil, storepb.Engine_MYSQL, false)
- dbSchemaB := model.NewDatabaseSchema(schemaB, nil, nil, storepb.Engine_MYSQL, false)
+ dbMetadataA := model.NewDatabaseMetadata(schemaA, nil, nil, storepb.Engine_MYSQL, false)
+ dbMetadataB := model.NewDatabaseMetadata(schemaB, nil, nil, storepb.Engine_MYSQL, false)
// Get diff from B to A (to generate rollback)
- diff, err := schema.GetDatabaseSchemaDiff(storepb.Engine_MYSQL, dbSchemaB, dbSchemaA)
+ diff, err := schema.GetDatabaseSchemaDiff(storepb.Engine_MYSQL, dbMetadataB, dbMetadataA)
require.NoError(t, err)
// Log the diff for debugging
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 683af1c128..7181546ed8 100644
--- a/backend/plugin/schema/mysql/get_database_metadata_testcontainer_test.go
+++ b/backend/plugin/schema/mysql/get_database_metadata_testcontainer_test.go
@@ -569,16 +569,16 @@ func compareMetadata(t *testing.T, dbMeta, parsedMeta *storepb.DatabaseSchemaMet
// For MySQL, we only have one schema
require.Equal(t, 1, len(parsedMeta.Schemas), "parsed metadata should have exactly one schema")
- dbSchema := dbMeta.Schemas[0]
+ dbMetadata := dbMeta.Schemas[0]
parsedSchema := parsedMeta.Schemas[0]
// Compare tables
- require.Equal(t, len(dbSchema.Tables), len(parsedSchema.Tables),
+ require.Equal(t, len(dbMetadata.Tables), len(parsedSchema.Tables),
"mismatch in number of tables for test %s", testName)
// Create a map for easier lookup
dbTableMap := make(map[string]*storepb.TableMetadata)
- for _, table := range dbSchema.Tables {
+ for _, table := range dbMetadata.Tables {
dbTableMap[table.Name] = table
}
@@ -603,13 +603,13 @@ func compareMetadata(t *testing.T, dbMeta, parsedMeta *storepb.DatabaseSchemaMet
}
// Compare views
- compareViews(t, dbSchema.Views, parsedSchema.Views)
+ compareViews(t, dbMetadata.Views, parsedSchema.Views)
// Compare functions
- compareFunctions(t, dbSchema.Functions, parsedSchema.Functions)
+ compareFunctions(t, dbMetadata.Functions, parsedSchema.Functions)
// Compare procedures
- compareProcedures(t, dbSchema.Procedures, parsedSchema.Procedures)
+ compareProcedures(t, dbMetadata.Procedures, parsedSchema.Procedures)
}
func compareColumns(t *testing.T, dbColumns, parsedColumns []*storepb.ColumnMetadata, tableName string) {
diff --git a/backend/plugin/schema/mysql/walk_through.go b/backend/plugin/schema/mysql/walk_through.go
index 99f6f205e3..59f43cd25c 100644
--- a/backend/plugin/schema/mysql/walk_through.go
+++ b/backend/plugin/schema/mysql/walk_through.go
@@ -39,7 +39,7 @@ func WalkThrough(d *model.DatabaseMetadata, ast any) *storepb.Advice {
// We define the Catalog as Database -> Schema -> Table. The Schema is only for PostgreSQL.
// So we use a Schema whose name is empty for other engines, such as MySQL.
// If there is no empty-string-name schema, create it to avoid corner cases.
- if d.GetSchema("") == nil {
+ if d.GetSchemaMetadata("") == nil {
d.CreateSchema("")
}
@@ -114,7 +114,7 @@ func (l *mysqlListener) EnterCreateTable(ctx *mysql.CreateTableContext) {
return
}
- schema := l.databaseMetadata.GetSchema("")
+ schema := l.databaseMetadata.GetSchemaMetadata("")
if schema == nil {
l.advice = &storepb.Advice{
Status: storepb.Advice_ERROR,
@@ -237,7 +237,7 @@ func (l *mysqlListener) EnterDropTable(ctx *mysql.DropTableContext) {
}
}
- schema := l.databaseMetadata.GetSchema("")
+ schema := l.databaseMetadata.GetSchemaMetadata("")
if schema == nil {
l.advice = &storepb.Advice{
Status: storepb.Advice_ERROR,
@@ -494,7 +494,7 @@ func (l *mysqlListener) EnterAlterTable(ctx *mysql.AlterTableContext) {
// rename table.
case item.RENAME_SYMBOL() != nil && item.TableName() != nil:
_, newTableName := mysqlparser.NormalizeMySQLTableName(item.TableName())
- schema := l.databaseMetadata.GetSchema("")
+ schema := l.databaseMetadata.GetSchemaMetadata("")
if schema == nil {
l.advice = &storepb.Advice{
Status: storepb.Advice_ERROR,
@@ -709,7 +709,7 @@ func (l *mysqlListener) EnterRenameTableStatement(ctx *mysql.RenameTableStatemen
return
}
for _, pair := range ctx.AllRenamePair() {
- schema := l.databaseMetadata.GetSchema("")
+ schema := l.databaseMetadata.GetSchemaMetadata("")
if schema == nil {
l.advice = &storepb.Advice{
Status: storepb.Advice_ERROR,
@@ -1124,7 +1124,7 @@ func mysqlCopyTable(d *model.DatabaseMetadata, databaseName, tableName, referTab
return advice
}
- schema := d.GetSchema("")
+ schema := d.GetSchemaMetadata("")
if schema == nil {
return &storepb.Advice{
Status: storepb.Advice_ERROR,
@@ -1214,7 +1214,7 @@ func mysqlFindTableState(d *model.DatabaseMetadata, databaseName, tableName stri
}
}
- schema := d.GetSchema("")
+ schema := d.GetSchemaMetadata("")
if schema == nil {
return nil, &storepb.Advice{
Status: storepb.Advice_ERROR,
diff --git a/backend/plugin/schema/mysql/walk_through_test.go b/backend/plugin/schema/mysql/walk_through_test.go
index 640cbf62f2..4e09d05760 100644
--- a/backend/plugin/schema/mysql/walk_through_test.go
+++ b/backend/plugin/schema/mysql/walk_through_test.go
@@ -49,7 +49,7 @@ func TestWalkThrough(t *testing.T) {
require.True(t, ok)
// Create DatabaseMetadata for walk-through
- state := model.NewDatabaseMetadata(protoData, storepb.Engine_MYSQL, !test.IgnoreCaseSensitive)
+ state := model.NewDatabaseMetadata(protoData, nil, nil, storepb.Engine_MYSQL, !test.IgnoreCaseSensitive)
asts, _ := sm.GetASTsForChecks(storepb.Engine_MYSQL, test.Statement)
advice := WalkThrough(state, asts)
diff --git a/backend/plugin/schema/oracle/generate_migration_testcontainer_test.go b/backend/plugin/schema/oracle/generate_migration_testcontainer_test.go
index 22f8e7c970..6fe450da91 100644
--- a/backend/plugin/schema/oracle/generate_migration_testcontainer_test.go
+++ b/backend/plugin/schema/oracle/generate_migration_testcontainer_test.go
@@ -1806,11 +1806,11 @@ COMMENT ON TABLE SPECIAL_DATA IS '';
// Step 3: Call generate migration to get the rollback DDL
// Convert to model.DatabaseSchema
- dbSchemaA := model.NewDatabaseSchema(schemaA, nil, nil, storepb.Engine_ORACLE, false)
- dbSchemaB := model.NewDatabaseSchema(schemaB, nil, nil, storepb.Engine_ORACLE, false)
+ dbMetadataA := model.NewDatabaseMetadata(schemaA, nil, nil, storepb.Engine_ORACLE, false)
+ dbMetadataB := model.NewDatabaseMetadata(schemaB, nil, nil, storepb.Engine_ORACLE, false)
// Get diff from B to A (to generate rollback)
- diff, err := schema.GetDatabaseSchemaDiff(storepb.Engine_ORACLE, dbSchemaB, dbSchemaA)
+ diff, err := schema.GetDatabaseSchemaDiff(storepb.Engine_ORACLE, dbMetadataB, dbMetadataA)
require.NoError(t, err)
// Generate rollback migration
diff --git a/backend/plugin/schema/oracle/get_database_metadata_test.go b/backend/plugin/schema/oracle/get_database_metadata_test.go
index 05f4edc60f..5a348f44db 100644
--- a/backend/plugin/schema/oracle/get_database_metadata_test.go
+++ b/backend/plugin/schema/oracle/get_database_metadata_test.go
@@ -843,38 +843,38 @@ func compareMetadata(t *testing.T, dbMeta, parsedMeta *storepb.DatabaseSchemaMet
// For Oracle, we have one schema per database
require.Equal(t, 1, len(parsedMeta.Schemas), "parsed metadata should have exactly one schema")
- dbSchema := dbMeta.Schemas[0]
+ dbMetadata := dbMeta.Schemas[0]
parsedSchema := parsedMeta.Schemas[0]
t.Logf("Test case %s - DB: %d tables, %d views, %d materialized views, %d sequences, %d functions, %d procedures | Parsed: %d tables, %d views, %d materialized views, %d sequences, %d functions, %d procedures",
testName,
- len(dbSchema.Tables), len(dbSchema.Views), len(dbSchema.MaterializedViews), len(dbSchema.Sequences), len(dbSchema.Functions), len(dbSchema.Procedures),
+ len(dbMetadata.Tables), len(dbMetadata.Views), len(dbMetadata.MaterializedViews), len(dbMetadata.Sequences), len(dbMetadata.Functions), len(dbMetadata.Procedures),
len(parsedSchema.Tables), len(parsedSchema.Views), len(parsedSchema.MaterializedViews), len(parsedSchema.Sequences), len(parsedSchema.Functions), len(parsedSchema.Procedures))
// Compare schema names (allow flexibility for Oracle default schema)
- if dbSchema.Name != "" && parsedSchema.Name != "" {
- require.Equal(t, dbSchema.Name, parsedSchema.Name, "schema names should match")
+ if dbMetadata.Name != "" && parsedSchema.Name != "" {
+ require.Equal(t, dbMetadata.Name, parsedSchema.Name, "schema names should match")
} else {
- t.Logf("Schema names: DB='%s', Parsed='%s' (allowing flexibility for Oracle default schema)", dbSchema.Name, parsedSchema.Name)
+ t.Logf("Schema names: DB='%s', Parsed='%s' (allowing flexibility for Oracle default schema)", dbMetadata.Name, parsedSchema.Name)
}
// Compare tables with deep content validation
- compareTables(t, dbSchema.Tables, parsedSchema.Tables, testName)
+ compareTables(t, dbMetadata.Tables, parsedSchema.Tables, testName)
// Compare views with content validation
- compareViews(t, dbSchema.Views, parsedSchema.Views, testName)
+ compareViews(t, dbMetadata.Views, parsedSchema.Views, testName)
// Compare materialized views
- compareMaterializedViews(t, dbSchema.MaterializedViews, parsedSchema.MaterializedViews, testName)
+ compareMaterializedViews(t, dbMetadata.MaterializedViews, parsedSchema.MaterializedViews, testName)
// Compare sequences with content validation
- compareSequences(t, dbSchema.Sequences, parsedSchema.Sequences, testName)
+ compareSequences(t, dbMetadata.Sequences, parsedSchema.Sequences, testName)
// Compare functions with content validation
- compareFunctions(t, dbSchema.Functions, parsedSchema.Functions, testName)
+ compareFunctions(t, dbMetadata.Functions, parsedSchema.Functions, testName)
// Compare procedures with content validation
- compareProcedures(t, dbSchema.Procedures, parsedSchema.Procedures, testName)
+ compareProcedures(t, dbMetadata.Procedures, parsedSchema.Procedures, testName)
}
// compareTables does deep comparison of table metadata
diff --git a/backend/plugin/schema/pg/comment_migration_test.go b/backend/plugin/schema/pg/comment_migration_test.go
index 0892165923..b2e4c1da73 100644
--- a/backend/plugin/schema/pg/comment_migration_test.go
+++ b/backend/plugin/schema/pg/comment_migration_test.go
@@ -600,7 +600,7 @@ COMMENT ON VIEW "public"."test_view" IS 'A view that combines test_table and tes
// Create mock schemas with view metadata
// Previous schema: no views
- previousSchema := model.NewDatabaseSchema(
+ previousSchema := model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "testdb",
Schemas: []*storepb.SchemaMetadata{
@@ -616,7 +616,7 @@ COMMENT ON VIEW "public"."test_view" IS 'A view that combines test_table and tes
)
// Current schema: includes view with comment
- currentSchema := model.NewDatabaseSchema(
+ currentSchema := model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "testdb",
Schemas: []*storepb.SchemaMetadata{
@@ -935,7 +935,7 @@ COMMENT ON INDEX "public"."idx_products_name" IS 'Index for product name lookup'
`
// Previous schema: table with columns but no indexes
- previousSchema := model.NewDatabaseSchema(
+ previousSchema := model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "testdb",
Schemas: []*storepb.SchemaMetadata{
@@ -971,7 +971,7 @@ COMMENT ON INDEX "public"."idx_products_name" IS 'Index for product name lookup'
)
// Current schema: includes index with comment
- currentSchema := model.NewDatabaseSchema(
+ currentSchema := model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "testdb",
Schemas: []*storepb.SchemaMetadata{
@@ -1052,7 +1052,7 @@ COMMENT ON SEQUENCE "public"."product_id_seq" IS 'Product ID sequence';
`
// Previous schema: table but no sequences
- previousSchema := model.NewDatabaseSchema(
+ previousSchema := model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "testdb",
Schemas: []*storepb.SchemaMetadata{
@@ -1084,7 +1084,7 @@ COMMENT ON SEQUENCE "public"."product_id_seq" IS 'Product ID sequence';
)
// Current schema: table and sequence with comment
- currentSchema := model.NewDatabaseSchema(
+ currentSchema := model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "testdb",
Schemas: []*storepb.SchemaMetadata{
diff --git a/backend/plugin/schema/pg/enum_type_test.go b/backend/plugin/schema/pg/enum_type_test.go
index 6734e71429..0adabb48be 100644
--- a/backend/plugin/schema/pg/enum_type_test.go
+++ b/backend/plugin/schema/pg/enum_type_test.go
@@ -138,8 +138,8 @@ func TestEnumTypeDependencyOrdering(t *testing.T) {
}
// Convert to model.DatabaseSchema
- oldSchema := model.NewDatabaseSchema(oldMetadata, nil, nil, storepb.Engine_POSTGRES, false)
- newSchema := model.NewDatabaseSchema(newMetadata, nil, nil, storepb.Engine_POSTGRES, false)
+ oldSchema := model.NewDatabaseMetadata(oldMetadata, nil, nil, storepb.Engine_POSTGRES, false)
+ newSchema := model.NewDatabaseMetadata(newMetadata, nil, nil, storepb.Engine_POSTGRES, false)
// Get diff
diff, err := schema.GetDatabaseSchemaDiff(storepb.Engine_POSTGRES, oldSchema, newSchema)
@@ -214,8 +214,8 @@ func TestEnumTypeDependencyOrdering(t *testing.T) {
}
// Convert to model.DatabaseSchema
- oldSchema := model.NewDatabaseSchema(oldMetadata, nil, nil, storepb.Engine_POSTGRES, false)
- newSchema := model.NewDatabaseSchema(newMetadata, nil, nil, storepb.Engine_POSTGRES, false)
+ oldSchema := model.NewDatabaseMetadata(oldMetadata, nil, nil, storepb.Engine_POSTGRES, false)
+ newSchema := model.NewDatabaseMetadata(newMetadata, nil, nil, storepb.Engine_POSTGRES, false)
// Get diff
diff, err := schema.GetDatabaseSchemaDiff(storepb.Engine_POSTGRES, oldSchema, newSchema)
diff --git a/backend/plugin/schema/pg/extension_test.go b/backend/plugin/schema/pg/extension_test.go
index cca64afa19..df71168bb7 100644
--- a/backend/plugin/schema/pg/extension_test.go
+++ b/backend/plugin/schema/pg/extension_test.go
@@ -141,8 +141,8 @@ func TestExtensionDependencyOrdering(t *testing.T) {
}
// Convert to model.DatabaseSchema
- oldSchema := model.NewDatabaseSchema(oldMetadata, nil, nil, storepb.Engine_POSTGRES, false)
- newSchema := model.NewDatabaseSchema(newMetadata, nil, nil, storepb.Engine_POSTGRES, false)
+ oldSchema := model.NewDatabaseMetadata(oldMetadata, nil, nil, storepb.Engine_POSTGRES, false)
+ newSchema := model.NewDatabaseMetadata(newMetadata, nil, nil, storepb.Engine_POSTGRES, false)
// Get diff
diff, err := schema.GetDatabaseSchemaDiff(storepb.Engine_POSTGRES, oldSchema, newSchema)
@@ -230,8 +230,8 @@ func TestExtensionDependencyOrdering(t *testing.T) {
}
// Convert to model.DatabaseSchema
- oldSchema := model.NewDatabaseSchema(oldMetadata, nil, nil, storepb.Engine_POSTGRES, false)
- newSchema := model.NewDatabaseSchema(newMetadata, nil, nil, storepb.Engine_POSTGRES, false)
+ oldSchema := model.NewDatabaseMetadata(oldMetadata, nil, nil, storepb.Engine_POSTGRES, false)
+ newSchema := model.NewDatabaseMetadata(newMetadata, nil, nil, storepb.Engine_POSTGRES, false)
// Get diff
diff, err := schema.GetDatabaseSchemaDiff(storepb.Engine_POSTGRES, oldSchema, newSchema)
@@ -621,7 +621,7 @@ func TestExtensionRoundtripNoDiff(t *testing.T) {
}
// Create current database schema from metadata (this is the actual database state)
- currentSchema := model.NewDatabaseSchema(metadata, nil, nil, storepb.Engine_POSTGRES, false)
+ currentSchema := model.NewDatabaseMetadata(metadata, nil, nil, storepb.Engine_POSTGRES, false)
// Dump SDL from metadata (this is what getSDLFormat does)
dumpedSDL, err := getSDLFormat(metadata)
@@ -667,7 +667,7 @@ func TestExtensionRoundtripNoDiff(t *testing.T) {
},
}
- currentSchema := model.NewDatabaseSchema(metadata, nil, nil, storepb.Engine_POSTGRES, false)
+ currentSchema := model.NewDatabaseMetadata(metadata, nil, nil, storepb.Engine_POSTGRES, false)
dumpedSDL, err := getSDLFormat(metadata)
require.NoError(t, err)
@@ -694,7 +694,7 @@ COMMENT ON EXTENSION "citext" IS 'Case-insensitive text type';`
},
}
- currentSchema := model.NewDatabaseSchema(metadata, nil, nil, storepb.Engine_POSTGRES, false)
+ currentSchema := model.NewDatabaseMetadata(metadata, nil, nil, storepb.Engine_POSTGRES, false)
dumpedSDL, err := getSDLFormat(metadata)
require.NoError(t, err)
diff --git a/backend/plugin/schema/pg/generate_migration_testcontainer_test.go b/backend/plugin/schema/pg/generate_migration_testcontainer_test.go
index 673a302552..c35988df3b 100644
--- a/backend/plugin/schema/pg/generate_migration_testcontainer_test.go
+++ b/backend/plugin/schema/pg/generate_migration_testcontainer_test.go
@@ -2176,11 +2176,11 @@ $$ LANGUAGE plpgsql;
// Step 3: Call generate migration to get the rollback DDL
// Convert to model.DatabaseSchema
- dbSchemaA := model.NewDatabaseSchema(schemaA, nil, nil, storepb.Engine_POSTGRES, false)
- dbSchemaB := model.NewDatabaseSchema(schemaB, nil, nil, storepb.Engine_POSTGRES, false)
+ dbMetadataA := model.NewDatabaseMetadata(schemaA, nil, nil, storepb.Engine_POSTGRES, false)
+ dbMetadataB := model.NewDatabaseMetadata(schemaB, nil, nil, storepb.Engine_POSTGRES, false)
// Get diff from B to A (to generate rollback)
- diff, err := schema.GetDatabaseSchemaDiff(storepb.Engine_POSTGRES, dbSchemaB, dbSchemaA)
+ diff, err := schema.GetDatabaseSchemaDiff(storepb.Engine_POSTGRES, dbMetadataB, dbMetadataA)
require.NoError(t, err)
// Log the diff for debugging
@@ -2473,10 +2473,10 @@ CREATE TABLE table2 (
// Get current schema (empty database)
currentSchema, err := getSyncMetadataForGenerateMigration(ctx, connConfig, connConfig.Database)
require.NoError(t, err)
- dbSchema := model.NewDatabaseSchema(currentSchema, nil, nil, storepb.Engine_POSTGRES, false)
+ dbMetadata := model.NewDatabaseMetadata(currentSchema, nil, nil, storepb.Engine_POSTGRES, false)
// Get SDL diff
- diff, err := GetSDLDiff(currentSDL, previousSDL, dbSchema, nil)
+ diff, err := GetSDLDiff(currentSDL, previousSDL, dbMetadata, nil)
require.NoError(t, err)
// Generate migration SQL with topological sorting
@@ -2572,10 +2572,10 @@ SELECT id, info, created_at, updated_at FROM table_base;
// Get current schema (empty database)
currentSchema, err := getSyncMetadataForGenerateMigration(ctx, connConfig, connConfig.Database)
require.NoError(t, err)
- dbSchema := model.NewDatabaseSchema(currentSchema, nil, nil, storepb.Engine_POSTGRES, false)
+ dbMetadata := model.NewDatabaseMetadata(currentSchema, nil, nil, storepb.Engine_POSTGRES, false)
// Get SDL diff
- diff, err := GetSDLDiff(currentSDL, previousSDL, dbSchema, nil)
+ diff, err := GetSDLDiff(currentSDL, previousSDL, dbMetadata, nil)
require.NoError(t, err)
// Generate migration SQL with topological sorting
diff --git a/backend/plugin/schema/pg/get_database_metadata.go b/backend/plugin/schema/pg/get_database_metadata.go
index 38eeda16a5..cdb93b567e 100644
--- a/backend/plugin/schema/pg/get_database_metadata.go
+++ b/backend/plugin/schema/pg/get_database_metadata.go
@@ -2873,7 +2873,7 @@ func getViewDependencies(viewDef string, schemaName string, fullSchemaMetadata *
base.GetQuerySpanContext{
GetDatabaseMetadataFunc: func(_ context.Context, _, databaseName string) (string, *model.DatabaseMetadata, error) {
// Return the full schema metadata so GetQuerySpan can resolve references
- dbMetadata := model.NewDatabaseMetadata(fullSchemaMetadata, storepb.Engine_POSTGRES, false)
+ dbMetadata := model.NewDatabaseMetadata(fullSchemaMetadata, nil, nil, storepb.Engine_POSTGRES, false)
return databaseName, dbMetadata, nil
},
ListDatabaseNamesFunc: func(_ context.Context, _ string) ([]string, error) {
diff --git a/backend/plugin/schema/pg/get_database_metadata_testcontainer_test.go b/backend/plugin/schema/pg/get_database_metadata_testcontainer_test.go
index 37e9745dff..bf068024d2 100644
--- a/backend/plugin/schema/pg/get_database_metadata_testcontainer_test.go
+++ b/backend/plugin/schema/pg/get_database_metadata_testcontainer_test.go
@@ -1670,9 +1670,9 @@ func compareAllSchemas(t *testing.T, syncSchemas, parseSchemas []*storepb.Schema
// validateWithSchemaDiffer validates that the schema differ returns no significant differences between sync and parse metadata
func validateWithSchemaDiffer(t *testing.T, testName string, syncMeta, parseMeta *storepb.DatabaseSchemaMetadata) {
- // Convert metadata to model.DatabaseSchema for differ
- syncSchema := model.NewDatabaseSchema(syncMeta, nil, nil, storepb.Engine_POSTGRES, false)
- parseSchema := model.NewDatabaseSchema(parseMeta, nil, nil, storepb.Engine_POSTGRES, false)
+ // Convert metadata to model.DatabaseMetadata for differ
+ syncSchema := model.NewDatabaseMetadata(syncMeta, nil, nil, storepb.Engine_POSTGRES, false)
+ parseSchema := model.NewDatabaseMetadata(parseMeta, nil, nil, storepb.Engine_POSTGRES, false)
// Get schema diff
diff, err := schema.GetDatabaseSchemaDiff(storepb.Engine_POSTGRES, syncSchema, parseSchema)
diff --git a/backend/plugin/schema/pg/get_sdl_diff.go b/backend/plugin/schema/pg/get_sdl_diff.go
index fd25368ea7..bac9146fb6 100644
--- a/backend/plugin/schema/pg/get_sdl_diff.go
+++ b/backend/plugin/schema/pg/get_sdl_diff.go
@@ -20,7 +20,7 @@ func init() {
schema.RegisterGetSDLDiff(storepb.Engine_COCKROACHDB, GetSDLDiff)
}
-func GetSDLDiff(currentSDLText, previousUserSDLText string, currentSchema, previousSchema *model.DatabaseSchema) (*schema.MetadataDiff, error) {
+func GetSDLDiff(currentSDLText, previousUserSDLText string, currentSchema, previousSchema *model.DatabaseMetadata) (*schema.MetadataDiff, error) {
generatedSDL, err := convertDatabaseSchemaToSDL(currentSchema)
if err != nil {
return nil, errors.Wrap(err, "failed to convert current schema to SDL format for initialization")
@@ -817,7 +817,7 @@ func (l *sdlChunkExtractor) EnterCommentstmt(ctx *parser.CommentstmtContext) {
// processTableChanges processes changes to tables by comparing SDL chunks
// nolint:unparam
-func processTableChanges(currentChunks, previousChunks *schema.SDLChunks, currentSchema, previousSchema *model.DatabaseSchema, currentDBSDLChunks *currentDatabaseSDLChunks, diff *schema.MetadataDiff) error {
+func processTableChanges(currentChunks, previousChunks *schema.SDLChunks, currentSchema, previousSchema *model.DatabaseMetadata, currentDBSDLChunks *currentDatabaseSDLChunks, diff *schema.MetadataDiff) error {
// Process current table chunks to find created and modified tables
for _, currentChunk := range currentChunks.Tables {
schemaName, tableName := parseIdentifier(currentChunk.Identifier)
@@ -974,7 +974,7 @@ func processTableChanges(currentChunks, previousChunks *schema.SDLChunks, curren
// processColumnChanges analyzes column changes between old and new table definitions
// Following the same pattern as processTableChanges: compare text first, then analyze differences
// If schemas are nil, operates in AST-only mode without metadata extraction
-func processColumnChanges(oldTable, newTable *parser.CreatestmtContext, currentSchema, previousSchema *model.DatabaseSchema, currentDBSDLChunks *currentDatabaseSDLChunks, tableIdentifier string) []*schema.ColumnDiff {
+func processColumnChanges(oldTable, newTable *parser.CreatestmtContext, currentSchema, previousSchema *model.DatabaseMetadata, currentDBSDLChunks *currentDatabaseSDLChunks, tableIdentifier string) []*schema.ColumnDiff {
if oldTable == nil || newTable == nil {
return []*schema.ColumnDiff{}
}
@@ -2709,7 +2709,7 @@ func processSequenceChanges(currentChunks, previousChunks *schema.SDLChunks, cur
// applyMinimalChangesToChunks applies minimal changes to the previous SDL chunks based on schema differences
// This implements the minimal change principle for drift scenarios by directly manipulating chunks
-func applyMinimalChangesToChunks(previousChunks *schema.SDLChunks, currentSchema, previousSchema *model.DatabaseSchema) error {
+func applyMinimalChangesToChunks(previousChunks *schema.SDLChunks, currentSchema, previousSchema *model.DatabaseMetadata) error {
if currentSchema == nil || previousSchema == nil || previousChunks == nil {
return nil
}
@@ -3471,7 +3471,7 @@ type currentDatabaseSDLChunks struct {
// buildCurrentDatabaseSDLChunks pre-computes SDL chunks from the current database schema
// for usability checks. This avoids repeated expensive calls to convertDatabaseSchemaToSDL
// and ChunkSDLText during diff processing by storing normalized SDL text from current database metadata.
-func buildCurrentDatabaseSDLChunks(currentSchema *model.DatabaseSchema) (*currentDatabaseSDLChunks, error) {
+func buildCurrentDatabaseSDLChunks(currentSchema *model.DatabaseMetadata) (*currentDatabaseSDLChunks, error) {
sdlChunks := &currentDatabaseSDLChunks{
chunks: make(map[string]string),
comments: make(map[string][]string),
@@ -3723,14 +3723,14 @@ func (sdlChunks *currentDatabaseSDLChunks) shouldSkipConstraintDiffForUsability(
return normalizedConstraintText == currentDatabaseConstraintSDL
}
-// convertDatabaseSchemaToSDL converts a model.DatabaseSchema to SDL format string
+// convertDatabaseSchemaToSDL converts a model.DatabaseMetadata to SDL format string
// This is used in initialization scenarios where previousUserSDLText is empty
-func convertDatabaseSchemaToSDL(dbSchema *model.DatabaseSchema) (string, error) {
- if dbSchema == nil {
+func convertDatabaseSchemaToSDL(dbMetadata *model.DatabaseMetadata) (string, error) {
+ if dbMetadata == nil {
return "", nil
}
- metadata := dbSchema.GetMetadata()
+ metadata := dbMetadata.GetMetadata()
if metadata == nil {
return "", nil
}
@@ -4236,7 +4236,7 @@ type extendedIndexMetadata struct {
// applyStandaloneIndexChangesToChunks applies minimal changes to standalone CREATE INDEX chunks
// This handles creation, modification, and deletion of independent index statements
-func applyStandaloneIndexChangesToChunks(previousChunks *schema.SDLChunks, currentSchema, previousSchema *model.DatabaseSchema) error {
+func applyStandaloneIndexChangesToChunks(previousChunks *schema.SDLChunks, currentSchema, previousSchema *model.DatabaseMetadata) error {
if currentSchema == nil || previousSchema == nil || previousChunks == nil {
return nil
}
@@ -4572,7 +4572,7 @@ func (e *indexExtractor) EnterIndexstmt(ctx *parser.IndexstmtContext) {
// applyFunctionChangesToChunks applies minimal changes to CREATE FUNCTION chunks
// This handles creation, modification, and deletion of function statements
-func applyFunctionChangesToChunks(previousChunks *schema.SDLChunks, currentSchema, previousSchema *model.DatabaseSchema) error {
+func applyFunctionChangesToChunks(previousChunks *schema.SDLChunks, currentSchema, previousSchema *model.DatabaseMetadata) error {
if currentSchema == nil || previousSchema == nil || previousChunks == nil {
return nil
}
@@ -4944,7 +4944,7 @@ func (e *functionExtractor) EnterCreatefunctionstmt(ctx *parser.Createfunctionst
// applySequenceChangesToChunks applies minimal changes to CREATE SEQUENCE chunks
// This handles creation, modification, and deletion of sequence statements
-func applySequenceChangesToChunks(previousChunks *schema.SDLChunks, currentSchema, previousSchema *model.DatabaseSchema) error {
+func applySequenceChangesToChunks(previousChunks *schema.SDLChunks, currentSchema, previousSchema *model.DatabaseMetadata) error {
if currentSchema == nil || previousSchema == nil || previousChunks == nil {
return nil
}
@@ -5738,7 +5738,7 @@ func getFirstCommentNode(nodes []antlr.ParserRuleContext) antlr.ParserRuleContex
// applyViewChangesToChunks applies minimal changes to CREATE VIEW chunks
// This handles creation, modification, and deletion of view statements
-func applyViewChangesToChunks(previousChunks *schema.SDLChunks, currentSchema, previousSchema *model.DatabaseSchema) error {
+func applyViewChangesToChunks(previousChunks *schema.SDLChunks, currentSchema, previousSchema *model.DatabaseMetadata) error {
if currentSchema == nil || previousSchema == nil || previousChunks == nil {
return nil
}
@@ -5990,7 +5990,7 @@ func (e *viewExtractor) EnterViewstmt(ctx *parser.ViewstmtContext) {
}
// applyMaterializedViewChangesToChunks applies minimal changes to materialized view chunks based on schema metadata
-func applyMaterializedViewChangesToChunks(previousChunks *schema.SDLChunks, currentSchema, previousSchema *model.DatabaseSchema) error {
+func applyMaterializedViewChangesToChunks(previousChunks *schema.SDLChunks, currentSchema, previousSchema *model.DatabaseMetadata) error {
if currentSchema == nil || previousSchema == nil || previousChunks == nil {
return nil
}
@@ -6220,7 +6220,7 @@ func generateCommentOnMaterializedViewSQL(schemaName, mvName, comment string) st
}
// applyEnumTypeChangesToChunks applies minimal changes to enum type chunks based on schema metadata
-func applyEnumTypeChangesToChunks(previousChunks *schema.SDLChunks, currentSchema, previousSchema *model.DatabaseSchema) error {
+func applyEnumTypeChangesToChunks(previousChunks *schema.SDLChunks, currentSchema, previousSchema *model.DatabaseMetadata) error {
if currentSchema == nil || previousSchema == nil || previousChunks == nil {
return nil
}
@@ -6482,7 +6482,7 @@ func (e *materializedViewExtractor) EnterCreatematviewstmt(ctx *parser.Createmat
// applyColumnCommentChanges applies minimal changes to column comments based on schema metadata
// This function only updates COMMENT ON COLUMN statements without modifying CREATE TABLE statements
-func applyColumnCommentChanges(previousChunks *schema.SDLChunks, currentSchema, previousSchema *model.DatabaseSchema) error {
+func applyColumnCommentChanges(previousChunks *schema.SDLChunks, currentSchema, previousSchema *model.DatabaseMetadata) error {
if currentSchema == nil || previousSchema == nil || previousChunks == nil {
return nil
}
@@ -6821,15 +6821,12 @@ func processExtensionChanges(currentChunks, previousChunks *schema.SDLChunks, cu
}
// processSchemaChanges processes explicit CREATE SCHEMA statements in the SDL
-func processSchemaChanges(currentChunks, previousChunks *schema.SDLChunks, currentSchema *model.DatabaseSchema, diff *schema.MetadataDiff) {
+func processSchemaChanges(currentChunks, previousChunks *schema.SDLChunks, currentMeta *model.DatabaseMetadata, diff *schema.MetadataDiff) {
// Build set of existing schemas in current database
existingSchemas := make(map[string]bool)
- if currentSchema != nil {
- currentMeta := currentSchema.GetDatabaseMetadata()
- if currentMeta != nil {
- for _, schemaName := range currentMeta.ListSchemaNames() {
- existingSchemas[schemaName] = true
- }
+ if currentMeta != nil {
+ for _, schemaName := range currentMeta.ListSchemaNames() {
+ existingSchemas[schemaName] = true
}
}
@@ -6870,8 +6867,8 @@ func processSchemaChanges(currentChunks, previousChunks *schema.SDLChunks, curre
// addImplicitSchemaCreation adds schema creation diffs for schemas that are referenced
// by new objects but don't exist in the current database and aren't explicitly created in the SDL.
// This handles the case where users write "CREATE TABLE new_schema.t(...)" without "CREATE SCHEMA new_schema".
-func addImplicitSchemaCreation(diff *schema.MetadataDiff, currentSchema *model.DatabaseSchema) {
- if currentSchema == nil {
+func addImplicitSchemaCreation(diff *schema.MetadataDiff, currentMeta *model.DatabaseMetadata) {
+ if currentMeta == nil {
return
}
@@ -6929,11 +6926,8 @@ func addImplicitSchemaCreation(diff *schema.MetadataDiff, currentSchema *model.D
// Get existing schemas from current database
existingSchemas := make(map[string]bool)
- currentMeta := currentSchema.GetDatabaseMetadata()
- if currentMeta != nil {
- for _, schemaName := range currentMeta.ListSchemaNames() {
- existingSchemas[schemaName] = true
- }
+ for _, schemaName := range currentMeta.ListSchemaNames() {
+ existingSchemas[schemaName] = true
}
// Check which schemas are already in SchemaChanges with CREATE action
@@ -6964,7 +6958,7 @@ func addImplicitSchemaCreation(diff *schema.MetadataDiff, currentSchema *model.D
// applyExtensionChangesToChunks applies minimal changes to extension chunks based on schema differences
// Extensions are database-level objects (not schema-scoped)
-func applyExtensionChangesToChunks(previousChunks *schema.SDLChunks, currentSchema, previousSchema *model.DatabaseSchema) error {
+func applyExtensionChangesToChunks(previousChunks *schema.SDLChunks, currentSchema, previousSchema *model.DatabaseMetadata) error {
if currentSchema == nil || previousSchema == nil || previousChunks == nil {
return nil
}
@@ -7251,7 +7245,7 @@ func extractTableNameFromTrigger(ctx *parser.CreatetrigstmtContext) string {
}
// applyTriggerChangesToChunks applies minimal changes to trigger chunks based on schema metadata
-func applyTriggerChangesToChunks(previousChunks *schema.SDLChunks, currentSchema, previousSchema *model.DatabaseSchema) error {
+func applyTriggerChangesToChunks(previousChunks *schema.SDLChunks, currentSchema, previousSchema *model.DatabaseMetadata) error {
if currentSchema == nil || previousSchema == nil || previousChunks == nil {
return nil
}
diff --git a/backend/plugin/schema/pg/get_sdl_diff_test.go b/backend/plugin/schema/pg/get_sdl_diff_test.go
index 78accd3eb1..55e765639e 100644
--- a/backend/plugin/schema/pg/get_sdl_diff_test.go
+++ b/backend/plugin/schema/pg/get_sdl_diff_test.go
@@ -20,8 +20,8 @@ func TestGetSDLDiff_InitializationScenario(t *testing.T) {
name string
currentSDLText string
previousUserSDLText string
- currentSchema *model.DatabaseSchema
- previousSchema *model.DatabaseSchema
+ currentSchema *model.DatabaseMetadata
+ previousSchema *model.DatabaseMetadata
expectedDiffEmpty bool
expectedTableChanges int
expectedViewChanges int
@@ -32,7 +32,7 @@ func TestGetSDLDiff_InitializationScenario(t *testing.T) {
name: "initialization_with_empty_previous_SDL",
currentSDLText: "CREATE TABLE users (id SERIAL PRIMARY KEY, name TEXT NOT NULL);",
previousUserSDLText: "", // Empty - initialization scenario
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -82,7 +82,7 @@ func TestGetSDLDiff_InitializationScenario(t *testing.T) {
name: "initialization_with_complex_schema",
currentSDLText: "CREATE TABLE users (id SERIAL PRIMARY KEY, name TEXT NOT NULL); CREATE VIEW user_view AS SELECT * FROM users;",
previousUserSDLText: "", // Empty - initialization scenario
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -169,19 +169,19 @@ func TestGetSDLDiff_InitializationScenario(t *testing.T) {
func TestConvertDatabaseSchemaToSDL(t *testing.T) {
tests := []struct {
name string
- dbSchema *model.DatabaseSchema
+ dbMetadata *model.DatabaseMetadata
expectedSDL string
expectedError bool
}{
{
name: "nil_schema",
- dbSchema: nil,
+ dbMetadata: nil,
expectedSDL: "",
expectedError: false,
},
{
name: "empty_metadata",
- dbSchema: model.NewDatabaseSchema(
+ dbMetadata: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{}, // empty but not nil metadata
nil,
nil,
@@ -193,7 +193,7 @@ func TestConvertDatabaseSchemaToSDL(t *testing.T) {
},
{
name: "simple_table_schema",
- dbSchema: model.NewDatabaseSchema(
+ dbMetadata: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -229,7 +229,7 @@ func TestConvertDatabaseSchemaToSDL(t *testing.T) {
},
{
name: "schema_with_materialized_view",
- dbSchema: model.NewDatabaseSchema(
+ dbMetadata: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -279,7 +279,7 @@ func TestConvertDatabaseSchemaToSDL(t *testing.T) {
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
- result, err := convertDatabaseSchemaToSDL(tt.dbSchema)
+ result, err := convertDatabaseSchemaToSDL(tt.dbMetadata)
if tt.expectedError {
require.Error(t, err)
@@ -313,7 +313,7 @@ func TestGetSDLDiff_MinimalChangesScenario(t *testing.T) {
name TEXT NOT NULL
);`
- currentSchema := model.NewDatabaseSchema(
+ currentSchema := model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -344,7 +344,7 @@ func TestGetSDLDiff_MinimalChangesScenario(t *testing.T) {
false,
)
- previousSchema := model.NewDatabaseSchema(
+ previousSchema := model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -385,8 +385,8 @@ func TestApplyMinimalChangesToChunks(t *testing.T) {
tests := []struct {
name string
previousUserSDLText string
- currentSchema *model.DatabaseSchema
- previousSchema *model.DatabaseSchema
+ currentSchema *model.DatabaseMetadata
+ previousSchema *model.DatabaseMetadata
expectedTables []string
shouldContainSerial bool
shouldContainIdentity bool
@@ -397,7 +397,7 @@ func TestApplyMinimalChangesToChunks(t *testing.T) {
id SERIAL PRIMARY KEY,
name TEXT NOT NULL
);`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -427,7 +427,7 @@ func TestApplyMinimalChangesToChunks(t *testing.T) {
storepb.Engine_POSTGRES,
false,
),
- previousSchema: model.NewDatabaseSchema(
+ previousSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -459,7 +459,7 @@ func TestApplyMinimalChangesToChunks(t *testing.T) {
id SERIAL PRIMARY KEY,
name TEXT NOT NULL
);`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -507,7 +507,7 @@ func TestApplyMinimalChangesToChunks(t *testing.T) {
storepb.Engine_POSTGRES,
false,
),
- previousSchema: model.NewDatabaseSchema(
+ previousSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -539,7 +539,7 @@ func TestApplyMinimalChangesToChunks(t *testing.T) {
id SERIAL PRIMARY KEY,
name TEXT NOT NULL
);`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -587,7 +587,7 @@ func TestApplyMinimalChangesToChunks(t *testing.T) {
storepb.Engine_POSTGRES,
false,
),
- previousSchema: model.NewDatabaseSchema(
+ previousSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -619,7 +619,7 @@ func TestApplyMinimalChangesToChunks(t *testing.T) {
id SERIAL PRIMARY KEY,
name TEXT NOT NULL
);`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -654,7 +654,7 @@ func TestApplyMinimalChangesToChunks(t *testing.T) {
storepb.Engine_POSTGRES,
false,
),
- previousSchema: model.NewDatabaseSchema(
+ previousSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -726,7 +726,7 @@ func TestGetSDLDiff_UsabilityHandling(t *testing.T) {
name string
currentSDLText string
previousUserSDLText string
- currentSchema *model.DatabaseSchema
+ currentSchema *model.DatabaseMetadata
expectedTableChanges int
expectedViewChanges int
expectedFunctionChanges int
@@ -744,7 +744,7 @@ func TestGetSDLDiff_UsabilityHandling(t *testing.T) {
id SERIAL PRIMARY KEY,
name TEXT NOT NULL
);`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -795,7 +795,7 @@ func TestGetSDLDiff_UsabilityHandling(t *testing.T) {
name: "view_format_difference_but_same_definition",
currentSDLText: `CREATE VIEW "public"."user_view" AS SELECT users.id, users.name FROM public.users;`,
previousUserSDLText: `CREATE VIEW user_view AS SELECT id, name FROM users;`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -833,7 +833,7 @@ func TestGetSDLDiff_UsabilityHandling(t *testing.T) {
id SERIAL PRIMARY KEY,
name TEXT NOT NULL
);`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -898,7 +898,7 @@ CREATE UNIQUE INDEX "users_email_key" ON ONLY "public"."users" (email);`,
);
CREATE UNIQUE INDEX "users_email_key" ON ONLY "public"."users" ("email");`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -969,7 +969,7 @@ CREATE UNIQUE INDEX "users_email_key" ON ONLY "public"."users" ("email");`,
"customer_name" text NOT NULL,
CONSTRAINT "orders_pkey" PRIMARY KEY ("order_id")
);`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -1028,7 +1028,7 @@ CREATE UNIQUE INDEX "users_email_key" ON ONLY "public"."users" ("email");`,
name TEXT NOT NULL,
price DECIMAL(10,2)
);`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -1083,7 +1083,7 @@ CREATE UNIQUE INDEX "users_email_key" ON ONLY "public"."users" ("email");`,
order_id BIGSERIAL PRIMARY KEY,
customer_name TEXT NOT NULL CHECK (length(customer_name) > 0)
);`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -1171,7 +1171,7 @@ CREATE UNIQUE INDEX "users_email_key" ON ONLY "public"."users" ("email");`,
// TestShouldSkipChunkDiffForUsability tests the core usability logic
func TestShouldSkipChunkDiffForUsability(t *testing.T) {
// Create a test schema
- testSchema := model.NewDatabaseSchema(
+ testSchema := model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -1217,7 +1217,7 @@ func TestShouldSkipChunkDiffForUsability(t *testing.T) {
name string
chunkText string
chunkID string
- currentSchema *model.DatabaseSchema
+ currentSchema *model.DatabaseMetadata
expectedSkip bool
description string
}{
@@ -1264,7 +1264,7 @@ func TestShouldSkipChunkDiffForUsability(t *testing.T) {
}
// Create a schema with table comment for testing comment-related scenarios
- testSchemaWithComment := model.NewDatabaseSchema(
+ testSchemaWithComment := model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -1311,7 +1311,7 @@ func TestShouldSkipChunkDiffForUsability(t *testing.T) {
name string
chunkText string
chunkID string
- currentSchema *model.DatabaseSchema
+ currentSchema *model.DatabaseMetadata
expectedSkip bool
description string
}{
@@ -1350,7 +1350,7 @@ func TestShouldSkipChunkDiffForUsability(t *testing.T) {
// TestCurrentDatabaseSDLChunksPerformance validates that the current database SDL chunks provide performance benefits
func TestCurrentDatabaseSDLChunksPerformance(t *testing.T) {
// Create a simple test schema
- testSchema := model.NewDatabaseSchema(
+ testSchema := model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -1477,7 +1477,7 @@ func TestApplyMinimalChangesToChunks_MultipleTableCorruption(t *testing.T) {
}
// Create mock schemas for applyMinimalChangesToChunks based on test case
- var currentSchema, previousSchema *model.DatabaseSchema
+ var currentSchema, previousSchema *model.DatabaseMetadata
switch tc.name {
case "simple_constraint_deletion_test":
@@ -1947,7 +1947,7 @@ func TestProcessUniqueConstraintChanges(t *testing.T) {
}
}
-func createMockDatabaseSchema() *model.DatabaseSchema {
+func createMockDatabaseSchema() *model.DatabaseMetadata {
metadata := &storepb.DatabaseSchemaMetadata{
Schemas: []*storepb.SchemaMetadata{
{
@@ -1966,10 +1966,10 @@ func createMockDatabaseSchema() *model.DatabaseSchema {
},
}
- return model.NewDatabaseSchema(metadata, nil, nil, storepb.Engine_POSTGRES, false)
+ return model.NewDatabaseMetadata(metadata, nil, nil, storepb.Engine_POSTGRES, false)
}
-func createMockDatabaseSchemaWithoutTestColumn() *model.DatabaseSchema {
+func createMockDatabaseSchemaWithoutTestColumn() *model.DatabaseMetadata {
metadata := &storepb.DatabaseSchemaMetadata{
Schemas: []*storepb.SchemaMetadata{
{
@@ -1996,10 +1996,10 @@ func createMockDatabaseSchemaWithoutTestColumn() *model.DatabaseSchema {
},
}
- return model.NewDatabaseSchema(metadata, nil, nil, storepb.Engine_POSTGRES, false)
+ return model.NewDatabaseMetadata(metadata, nil, nil, storepb.Engine_POSTGRES, false)
}
-func createMockDatabaseSchemaForColumnDeletion() *model.DatabaseSchema {
+func createMockDatabaseSchemaForColumnDeletion() *model.DatabaseMetadata {
// Create schema for column deletion test - only has id column (name column deleted)
metadata := &storepb.DatabaseSchemaMetadata{
Schemas: []*storepb.SchemaMetadata{
@@ -2022,7 +2022,7 @@ func createMockDatabaseSchemaForColumnDeletion() *model.DatabaseSchema {
},
}
- return model.NewDatabaseSchema(metadata, nil, nil, storepb.Engine_POSTGRES, false)
+ return model.NewDatabaseMetadata(metadata, nil, nil, storepb.Engine_POSTGRES, false)
}
// TestGetSDLDiff_SerialAndIdentityColumns tests serial and identity column handling in SDL diff
@@ -2031,7 +2031,7 @@ func TestGetSDLDiff_SerialAndIdentityColumns(t *testing.T) {
name string
currentSDLText string
previousUserSDLText string
- currentSchema *model.DatabaseSchema
+ currentSchema *model.DatabaseMetadata
expectedTableChanges int
description string
}{
@@ -2045,7 +2045,7 @@ func TestGetSDLDiff_SerialAndIdentityColumns(t *testing.T) {
id integer NOT NULL DEFAULT nextval('users_id_seq'::regclass),
name TEXT NOT NULL
);`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -2103,7 +2103,7 @@ func TestGetSDLDiff_SerialAndIdentityColumns(t *testing.T) {
order_id bigint NOT NULL DEFAULT nextval('orders_order_id_seq'::regclass),
customer_name TEXT NOT NULL
);`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -2161,7 +2161,7 @@ func TestGetSDLDiff_SerialAndIdentityColumns(t *testing.T) {
item_id smallint NOT NULL DEFAULT nextval('items_item_id_seq'::regclass),
item_name TEXT NOT NULL
);`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -2219,7 +2219,7 @@ func TestGetSDLDiff_SerialAndIdentityColumns(t *testing.T) {
id bigint NOT NULL,
name TEXT NOT NULL
);`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -2277,7 +2277,7 @@ func TestGetSDLDiff_SerialAndIdentityColumns(t *testing.T) {
id integer NOT NULL,
amount DECIMAL(10,2) NOT NULL
);`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -2356,7 +2356,7 @@ func TestGetSDLDiff_SerialAndIdentityColumns(t *testing.T) {
func TestConvertDatabaseSchemaToSDL_SerialAndIdentitySequences(t *testing.T) {
tests := []struct {
name string
- dbSchema *model.DatabaseSchema
+ dbMetadata *model.DatabaseMetadata
shouldContainSerial bool
shouldContainIdentity bool
shouldNotContainSequence []string
@@ -2365,7 +2365,7 @@ func TestConvertDatabaseSchemaToSDL_SerialAndIdentitySequences(t *testing.T) {
}{
{
name: "serial_column_should_not_generate_separate_sequence",
- dbSchema: model.NewDatabaseSchema(
+ dbMetadata: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -2417,7 +2417,7 @@ func TestConvertDatabaseSchemaToSDL_SerialAndIdentitySequences(t *testing.T) {
},
{
name: "identity_column_should_not_generate_separate_sequence",
- dbSchema: model.NewDatabaseSchema(
+ dbMetadata: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -2468,7 +2468,7 @@ func TestConvertDatabaseSchemaToSDL_SerialAndIdentitySequences(t *testing.T) {
},
{
name: "independent_sequence_should_still_be_generated",
- dbSchema: model.NewDatabaseSchema(
+ dbMetadata: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -2529,7 +2529,7 @@ func TestConvertDatabaseSchemaToSDL_SerialAndIdentitySequences(t *testing.T) {
t.Logf("Test description: %s", tt.description)
// Convert database schema to SDL
- result, err := convertDatabaseSchemaToSDL(tt.dbSchema)
+ result, err := convertDatabaseSchemaToSDL(tt.dbMetadata)
require.NoError(t, err)
require.NotEmpty(t, result)
@@ -2573,8 +2573,8 @@ func TestApplySequenceChangesToChunks_PreservesAlterAndComment(t *testing.T) {
tests := []struct {
name string
previousUserSDLText string
- currentSchema *model.DatabaseSchema
- previousSchema *model.DatabaseSchema
+ currentSchema *model.DatabaseMetadata
+ previousSchema *model.DatabaseMetadata
shouldPreserveAlter bool
shouldPreserveComment bool
expectedAlterCount int
@@ -2593,7 +2593,7 @@ func TestApplySequenceChangesToChunks_PreservesAlterAndComment(t *testing.T) {
ALTER SEQUENCE public.my_seq OWNED BY public.users.id;
COMMENT ON SEQUENCE public.my_seq IS 'User ID sequence';`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -2622,7 +2622,7 @@ COMMENT ON SEQUENCE public.my_seq IS 'User ID sequence';`,
storepb.Engine_POSTGRES,
false,
),
- previousSchema: model.NewDatabaseSchema(
+ previousSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -2669,7 +2669,7 @@ COMMENT ON SEQUENCE public.my_seq IS 'User ID sequence';`,
CACHE 1;
COMMENT ON SEQUENCE public.counter_seq IS 'Global counter';`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -2696,7 +2696,7 @@ COMMENT ON SEQUENCE public.counter_seq IS 'Global counter';`,
storepb.Engine_POSTGRES,
false,
),
- previousSchema: model.NewDatabaseSchema(
+ previousSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -2815,8 +2815,8 @@ func TestApplySequenceChangesToChunks_OwnerDrift(t *testing.T) {
tests := []struct {
name string
previousUserSDLText string
- currentSchema *model.DatabaseSchema
- previousSchema *model.DatabaseSchema
+ currentSchema *model.DatabaseMetadata
+ previousSchema *model.DatabaseMetadata
expectedAlterStatements int
expectedOwnerTable string
expectedOwnerColumn string
@@ -2831,7 +2831,7 @@ func TestApplySequenceChangesToChunks_OwnerDrift(t *testing.T) {
CACHE 1;
ALTER SEQUENCE public.my_seq OWNED BY public.users.id;`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -2859,7 +2859,7 @@ ALTER SEQUENCE public.my_seq OWNED BY public.users.id;`,
storepb.Engine_POSTGRES,
false,
),
- previousSchema: model.NewDatabaseSchema(
+ previousSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -2901,7 +2901,7 @@ ALTER SEQUENCE public.my_seq OWNED BY public.users.id;`,
CACHE 1;
ALTER SEQUENCE public.counter_seq OWNED BY public.users.id;`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -2929,7 +2929,7 @@ ALTER SEQUENCE public.counter_seq OWNED BY public.users.id;`,
storepb.Engine_POSTGRES,
false,
),
- previousSchema: model.NewDatabaseSchema(
+ previousSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -3032,8 +3032,8 @@ func TestApplySequenceChangesToChunks_CommentDrift(t *testing.T) {
tests := []struct {
name string
previousUserSDLText string
- currentSchema *model.DatabaseSchema
- previousSchema *model.DatabaseSchema
+ currentSchema *model.DatabaseMetadata
+ previousSchema *model.DatabaseMetadata
expectedCommentStatements int
expectedCommentText string
}{
@@ -3047,7 +3047,7 @@ func TestApplySequenceChangesToChunks_CommentDrift(t *testing.T) {
CACHE 1;
COMMENT ON SEQUENCE public.my_seq IS 'Old comment';`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -3074,7 +3074,7 @@ COMMENT ON SEQUENCE public.my_seq IS 'Old comment';`,
storepb.Engine_POSTGRES,
false,
),
- previousSchema: model.NewDatabaseSchema(
+ previousSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -3112,7 +3112,7 @@ COMMENT ON SEQUENCE public.my_seq IS 'Old comment';`,
NO MINVALUE
NO MAXVALUE
CACHE 1;`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -3139,7 +3139,7 @@ COMMENT ON SEQUENCE public.my_seq IS 'Old comment';`,
storepb.Engine_POSTGRES,
false,
),
- previousSchema: model.NewDatabaseSchema(
+ previousSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -3179,7 +3179,7 @@ COMMENT ON SEQUENCE public.my_seq IS 'Old comment';`,
CACHE 1;
COMMENT ON SEQUENCE public.counter_seq IS 'Some comment';`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -3206,7 +3206,7 @@ COMMENT ON SEQUENCE public.counter_seq IS 'Some comment';`,
storepb.Engine_POSTGRES,
false,
),
- previousSchema: model.NewDatabaseSchema(
+ previousSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -3246,7 +3246,7 @@ COMMENT ON SEQUENCE public.counter_seq IS 'Some comment';`,
CACHE 1;
COMMENT ON SEQUENCE public.preserve_seq IS 'Unchanged comment';`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -3273,7 +3273,7 @@ COMMENT ON SEQUENCE public.preserve_seq IS 'Unchanged comment';`,
storepb.Engine_POSTGRES,
false,
),
- previousSchema: model.NewDatabaseSchema(
+ previousSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -3370,8 +3370,8 @@ func TestApplySequenceChangesToChunks_OwnedSequenceNotInSDL(t *testing.T) {
tests := []struct {
name string
previousUserSDLText string
- currentSchema *model.DatabaseSchema
- previousSchema *model.DatabaseSchema
+ currentSchema *model.DatabaseMetadata
+ previousSchema *model.DatabaseMetadata
expectSequenceChunk bool
sequenceKey string
}{
@@ -3382,7 +3382,7 @@ func TestApplySequenceChangesToChunks_OwnedSequenceNotInSDL(t *testing.T) {
id SERIAL PRIMARY KEY,
name TEXT
);`,
- previousSchema: model.NewDatabaseSchema(
+ previousSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -3419,7 +3419,7 @@ func TestApplySequenceChangesToChunks_OwnedSequenceNotInSDL(t *testing.T) {
storepb.Engine_POSTGRES,
false,
),
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -3466,7 +3466,7 @@ func TestApplySequenceChangesToChunks_OwnedSequenceNotInSDL(t *testing.T) {
id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY,
name TEXT
);`,
- previousSchema: model.NewDatabaseSchema(
+ previousSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -3503,7 +3503,7 @@ func TestApplySequenceChangesToChunks_OwnedSequenceNotInSDL(t *testing.T) {
storepb.Engine_POSTGRES,
false,
),
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -3559,7 +3559,7 @@ CREATE TABLE public.orders (
);
ALTER SEQUENCE public.orders_id_seq OWNED BY public.orders.id;`,
- previousSchema: model.NewDatabaseSchema(
+ previousSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -3596,7 +3596,7 @@ ALTER SEQUENCE public.orders_id_seq OWNED BY public.orders.id;`,
storepb.Engine_POSTGRES,
false,
),
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -3663,8 +3663,8 @@ func TestApplyFunctionChangesToChunks_CommentDrift(t *testing.T) {
tests := []struct {
name string
previousUserSDLText string
- currentSchema *model.DatabaseSchema
- previousSchema *model.DatabaseSchema
+ currentSchema *model.DatabaseMetadata
+ previousSchema *model.DatabaseMetadata
expectedCommentStatements int
expectedCommentText string
}{
@@ -3676,7 +3676,7 @@ BEGIN
END;
$$ LANGUAGE plpgsql;
COMMENT ON FUNCTION public.calculate_total(INTEGER) IS 'Old comment';`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -3697,7 +3697,7 @@ COMMENT ON FUNCTION public.calculate_total(INTEGER) IS 'Old comment';`,
storepb.Engine_POSTGRES,
false,
),
- previousSchema: model.NewDatabaseSchema(
+ previousSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -3728,7 +3728,7 @@ BEGIN
RETURN a + b;
END;
$$ LANGUAGE plpgsql;`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -3749,7 +3749,7 @@ $$ LANGUAGE plpgsql;`,
storepb.Engine_POSTGRES,
false,
),
- previousSchema: model.NewDatabaseSchema(
+ previousSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -3781,7 +3781,7 @@ BEGIN
END;
$$ LANGUAGE plpgsql;
COMMENT ON FUNCTION public.process_data(TEXT) IS 'Old comment';`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -3802,7 +3802,7 @@ COMMENT ON FUNCTION public.process_data(TEXT) IS 'Old comment';`,
storepb.Engine_POSTGRES,
false,
),
- previousSchema: model.NewDatabaseSchema(
+ previousSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -3890,8 +3890,8 @@ func TestApplyIndexChangesToChunks_CommentDrift(t *testing.T) {
tests := []struct {
name string
previousUserSDLText string
- currentSchema *model.DatabaseSchema
- previousSchema *model.DatabaseSchema
+ currentSchema *model.DatabaseMetadata
+ previousSchema *model.DatabaseMetadata
expectedCommentStatements int
expectedCommentText string
}{
@@ -3905,7 +3905,7 @@ func TestApplyIndexChangesToChunks_CommentDrift(t *testing.T) {
CREATE INDEX idx_users_email ON public.users (email);
COMMENT ON INDEX public.idx_users_email IS 'Old comment';`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -3938,7 +3938,7 @@ COMMENT ON INDEX public.idx_users_email IS 'Old comment';`,
storepb.Engine_POSTGRES,
false,
),
- previousSchema: model.NewDatabaseSchema(
+ previousSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -3982,7 +3982,7 @@ COMMENT ON INDEX public.idx_users_email IS 'Old comment';`,
);
CREATE INDEX idx_products_name ON public.products (name);`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -4015,7 +4015,7 @@ CREATE INDEX idx_products_name ON public.products (name);`,
storepb.Engine_POSTGRES,
false,
),
- previousSchema: model.NewDatabaseSchema(
+ previousSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -4061,7 +4061,7 @@ CREATE INDEX idx_products_name ON public.products (name);`,
CREATE UNIQUE INDEX idx_posts_title ON public.posts (title);
COMMENT ON INDEX public.idx_posts_title IS 'Old comment';`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -4094,7 +4094,7 @@ COMMENT ON INDEX public.idx_posts_title IS 'Old comment';`,
storepb.Engine_POSTGRES,
false,
),
- previousSchema: model.NewDatabaseSchema(
+ previousSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -4194,8 +4194,8 @@ func TestApplyViewChangesToChunks_CommentDrift(t *testing.T) {
tests := []struct {
name string
previousUserSDLText string
- currentSchema *model.DatabaseSchema
- previousSchema *model.DatabaseSchema
+ currentSchema *model.DatabaseMetadata
+ previousSchema *model.DatabaseMetadata
expectedCommentStatements int
expectedCommentText string
}{
@@ -4205,7 +4205,7 @@ func TestApplyViewChangesToChunks_CommentDrift(t *testing.T) {
SELECT id, email FROM users;
COMMENT ON VIEW public.user_emails IS 'Old comment';`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -4226,7 +4226,7 @@ COMMENT ON VIEW public.user_emails IS 'Old comment';`,
storepb.Engine_POSTGRES,
false,
),
- previousSchema: model.NewDatabaseSchema(
+ previousSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -4254,7 +4254,7 @@ COMMENT ON VIEW public.user_emails IS 'Old comment';`,
name: "view_comment_added_when_previously_none",
previousUserSDLText: `CREATE VIEW public.admin_users AS
SELECT * FROM users WHERE role = 'admin';`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -4275,7 +4275,7 @@ SELECT * FROM users WHERE role = 'admin';`,
storepb.Engine_POSTGRES,
false,
),
- previousSchema: model.NewDatabaseSchema(
+ previousSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -4305,7 +4305,7 @@ SELECT * FROM users WHERE role = 'admin';`,
SELECT * FROM users WHERE active = true;
COMMENT ON VIEW public.active_users IS 'Old comment';`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -4326,7 +4326,7 @@ COMMENT ON VIEW public.active_users IS 'Old comment';`,
storepb.Engine_POSTGRES,
false,
),
- previousSchema: model.NewDatabaseSchema(
+ previousSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -4414,8 +4414,8 @@ func TestApplyMaterializedViewChangesToChunks_CommentDrift(t *testing.T) {
tests := []struct {
name string
previousUserSDLText string
- currentSchema *model.DatabaseSchema
- previousSchema *model.DatabaseSchema
+ currentSchema *model.DatabaseMetadata
+ previousSchema *model.DatabaseMetadata
expectedCommentStatements int
expectedCommentText string
}{
@@ -4430,7 +4430,7 @@ CREATE MATERIALIZED VIEW public.user_emails_mv AS
SELECT id, email FROM users;
COMMENT ON MATERIALIZED VIEW public.user_emails_mv IS 'Old comment';`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -4460,7 +4460,7 @@ COMMENT ON MATERIALIZED VIEW public.user_emails_mv IS 'Old comment';`,
storepb.Engine_POSTGRES,
false,
),
- previousSchema: model.NewDatabaseSchema(
+ previousSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -4502,7 +4502,7 @@ COMMENT ON MATERIALIZED VIEW public.user_emails_mv IS 'Old comment';`,
CREATE MATERIALIZED VIEW public.admin_users_mv AS
SELECT * FROM users WHERE role = 'admin';`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -4532,7 +4532,7 @@ SELECT * FROM users WHERE role = 'admin';`,
storepb.Engine_POSTGRES,
false,
),
- previousSchema: model.NewDatabaseSchema(
+ previousSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -4576,7 +4576,7 @@ CREATE MATERIALIZED VIEW public.active_users_mv AS
SELECT * FROM users WHERE active = true;
COMMENT ON MATERIALIZED VIEW public.active_users_mv IS 'Old comment';`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -4606,7 +4606,7 @@ COMMENT ON MATERIALIZED VIEW public.active_users_mv IS 'Old comment';`,
storepb.Engine_POSTGRES,
false,
),
- previousSchema: model.NewDatabaseSchema(
+ previousSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -4703,8 +4703,8 @@ func TestApplyTableChangesToChunk_CommentDrift(t *testing.T) {
tests := []struct {
name string
previousUserSDLText string
- currentSchema *model.DatabaseSchema
- previousSchema *model.DatabaseSchema
+ currentSchema *model.DatabaseMetadata
+ previousSchema *model.DatabaseMetadata
expectedCommentStatements int
expectedCommentText string
}{
@@ -4716,7 +4716,7 @@ func TestApplyTableChangesToChunk_CommentDrift(t *testing.T) {
);
COMMENT ON TABLE public.products IS 'Old comment';`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -4740,7 +4740,7 @@ COMMENT ON TABLE public.products IS 'Old comment';`,
storepb.Engine_POSTGRES,
false,
),
- previousSchema: model.NewDatabaseSchema(
+ previousSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -4773,7 +4773,7 @@ COMMENT ON TABLE public.products IS 'Old comment';`,
id INTEGER PRIMARY KEY,
email TEXT NOT NULL
);`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -4797,7 +4797,7 @@ COMMENT ON TABLE public.products IS 'Old comment';`,
storepb.Engine_POSTGRES,
false,
),
- previousSchema: model.NewDatabaseSchema(
+ previousSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -4832,7 +4832,7 @@ COMMENT ON TABLE public.products IS 'Old comment';`,
);
COMMENT ON TABLE public.orders IS 'Old comment';`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -4856,7 +4856,7 @@ COMMENT ON TABLE public.orders IS 'Old comment';`,
storepb.Engine_POSTGRES,
false,
),
- previousSchema: model.NewDatabaseSchema(
+ previousSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -4947,8 +4947,8 @@ func TestApplyColumnCommentChanges(t *testing.T) {
tests := []struct {
name string
previousUserSDLText string
- currentSchema *model.DatabaseSchema
- previousSchema *model.DatabaseSchema
+ currentSchema *model.DatabaseMetadata
+ previousSchema *model.DatabaseMetadata
expectedColumnComments map[string]map[string]string // tableKey -> columnName -> comment
shouldContainCommentOn []string // Expected COMMENT ON COLUMN statements
shouldNotContainCommentOn []string // Should not contain these
@@ -4961,7 +4961,7 @@ func TestApplyColumnCommentChanges(t *testing.T) {
);
COMMENT ON COLUMN public.products.name IS 'Old column comment';`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -4984,7 +4984,7 @@ COMMENT ON COLUMN public.products.name IS 'Old column comment';`,
storepb.Engine_POSTGRES,
false,
),
- previousSchema: model.NewDatabaseSchema(
+ previousSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -5022,7 +5022,7 @@ COMMENT ON COLUMN public.products.name IS 'Old column comment';`,
id INTEGER PRIMARY KEY,
quantity INTEGER NOT NULL
);`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -5045,7 +5045,7 @@ COMMENT ON COLUMN public.products.name IS 'Old column comment';`,
storepb.Engine_POSTGRES,
false,
),
- previousSchema: model.NewDatabaseSchema(
+ previousSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -5085,7 +5085,7 @@ COMMENT ON COLUMN public.products.name IS 'Old column comment';`,
);
COMMENT ON COLUMN public.orders.total IS 'Old column comment';`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -5108,7 +5108,7 @@ COMMENT ON COLUMN public.orders.total IS 'Old column comment';`,
storepb.Engine_POSTGRES,
false,
),
- previousSchema: model.NewDatabaseSchema(
+ previousSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -5147,7 +5147,7 @@ COMMENT ON COLUMN public.orders.total IS 'Old column comment';`,
COMMENT ON COLUMN public.users.username IS 'Old username comment';
COMMENT ON COLUMN public.users.email IS 'Old email comment';`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -5172,7 +5172,7 @@ COMMENT ON COLUMN public.users.email IS 'Old email comment';`,
storepb.Engine_POSTGRES,
false,
),
- previousSchema: model.NewDatabaseSchema(
+ previousSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
diff --git a/backend/plugin/schema/pg/materialized_view_index_test.go b/backend/plugin/schema/pg/materialized_view_index_test.go
index 5b1151fa32..1ace6e0523 100644
--- a/backend/plugin/schema/pg/materialized_view_index_test.go
+++ b/backend/plugin/schema/pg/materialized_view_index_test.go
@@ -154,8 +154,8 @@ func TestMaterializedViewIndexDependencyOrdering(t *testing.T) {
}
// Convert to model.DatabaseSchema
- oldSchema := model.NewDatabaseSchema(oldMetadata, nil, nil, storepb.Engine_POSTGRES, false)
- newSchema := model.NewDatabaseSchema(newMetadata, nil, nil, storepb.Engine_POSTGRES, false)
+ oldSchema := model.NewDatabaseMetadata(oldMetadata, nil, nil, storepb.Engine_POSTGRES, false)
+ newSchema := model.NewDatabaseMetadata(newMetadata, nil, nil, storepb.Engine_POSTGRES, false)
// Get diff
diff, err := schema.GetDatabaseSchemaDiff(storepb.Engine_POSTGRES, oldSchema, newSchema)
@@ -224,8 +224,8 @@ func TestMaterializedViewIndexDependencyOrdering(t *testing.T) {
}
// Convert to model.DatabaseSchema
- oldSchema := model.NewDatabaseSchema(oldMetadata, nil, nil, storepb.Engine_POSTGRES, false)
- newSchema := model.NewDatabaseSchema(newMetadata, nil, nil, storepb.Engine_POSTGRES, false)
+ oldSchema := model.NewDatabaseMetadata(oldMetadata, nil, nil, storepb.Engine_POSTGRES, false)
+ newSchema := model.NewDatabaseMetadata(newMetadata, nil, nil, storepb.Engine_POSTGRES, false)
// Get diff
diff, err := schema.GetDatabaseSchemaDiff(storepb.Engine_POSTGRES, oldSchema, newSchema)
diff --git a/backend/plugin/schema/pg/pg_alter_parsing_test.go b/backend/plugin/schema/pg/pg_alter_parsing_test.go
index 5954cd9043..5a8a94514f 100644
--- a/backend/plugin/schema/pg/pg_alter_parsing_test.go
+++ b/backend/plugin/schema/pg/pg_alter_parsing_test.go
@@ -98,8 +98,8 @@ func TestAlterColumnIdentityEquivalence(t *testing.T) {
}
// Compare schemas
- userDBSchema := model.NewDatabaseSchema(userMetadata, nil, nil, storepb.Engine_POSTGRES, false)
- dbDBSchema := model.NewDatabaseSchema(dbMetadata, nil, nil, storepb.Engine_POSTGRES, false)
+ userDBSchema := model.NewDatabaseMetadata(userMetadata, nil, nil, storepb.Engine_POSTGRES, false)
+ dbDBSchema := model.NewDatabaseMetadata(dbMetadata, nil, nil, storepb.Engine_POSTGRES, false)
diff, err := schema.GetDatabaseSchemaDiff(storepb.Engine_POSTGRES, dbDBSchema, userDBSchema)
require.NoError(t, err)
diff --git a/backend/plugin/schema/pg/pg_comment_parsing_test.go b/backend/plugin/schema/pg/pg_comment_parsing_test.go
index 65e2a54375..ff50afb3aa 100644
--- a/backend/plugin/schema/pg/pg_comment_parsing_test.go
+++ b/backend/plugin/schema/pg/pg_comment_parsing_test.go
@@ -50,8 +50,8 @@ func TestCommentOnTable(t *testing.T) {
require.Equal(t, "Invoice records", dbMetadata.Schemas[0].Tables[0].Comment)
// Compare schemas
- userDBSchema := model.NewDatabaseSchema(userMetadata, nil, nil, storepb.Engine_POSTGRES, false)
- dbDBSchema := model.NewDatabaseSchema(dbMetadata, nil, nil, storepb.Engine_POSTGRES, false)
+ userDBSchema := model.NewDatabaseMetadata(userMetadata, nil, nil, storepb.Engine_POSTGRES, false)
+ dbDBSchema := model.NewDatabaseMetadata(dbMetadata, nil, nil, storepb.Engine_POSTGRES, false)
diff, err := schema.GetDatabaseSchemaDiff(storepb.Engine_POSTGRES, dbDBSchema, userDBSchema)
require.NoError(t, err)
@@ -115,8 +115,8 @@ func TestCommentOnColumn(t *testing.T) {
require.Equal(t, "Current plan identifier", dbTable.Columns[2].Comment)
// Compare schemas
- userDBSchema := model.NewDatabaseSchema(userMetadata, nil, nil, storepb.Engine_POSTGRES, false)
- dbDBSchema := model.NewDatabaseSchema(dbMetadata, nil, nil, storepb.Engine_POSTGRES, false)
+ userDBSchema := model.NewDatabaseMetadata(userMetadata, nil, nil, storepb.Engine_POSTGRES, false)
+ dbDBSchema := model.NewDatabaseMetadata(dbMetadata, nil, nil, storepb.Engine_POSTGRES, false)
diff, err := schema.GetDatabaseSchemaDiff(storepb.Engine_POSTGRES, dbDBSchema, userDBSchema)
require.NoError(t, err)
@@ -170,8 +170,8 @@ func TestMultilineComment(t *testing.T) {
require.Equal(t, userCol.Comment, dbCol.Comment, "Comments should be identical")
// Compare schemas
- userDBSchema := model.NewDatabaseSchema(userMetadata, nil, nil, storepb.Engine_POSTGRES, false)
- dbDBSchema := model.NewDatabaseSchema(dbMetadata, nil, nil, storepb.Engine_POSTGRES, false)
+ userDBSchema := model.NewDatabaseMetadata(userMetadata, nil, nil, storepb.Engine_POSTGRES, false)
+ dbDBSchema := model.NewDatabaseMetadata(dbMetadata, nil, nil, storepb.Engine_POSTGRES, false)
diff, err := schema.GetDatabaseSchemaDiff(storepb.Engine_POSTGRES, dbDBSchema, userDBSchema)
require.NoError(t, err)
@@ -287,8 +287,8 @@ func TestCommentEquivalence(t *testing.T) {
targetMetadata, err := GetDatabaseMetadata(targetSchema)
require.NoError(t, err)
- sourceDBSchema := model.NewDatabaseSchema(sourceMetadata, nil, nil, storepb.Engine_POSTGRES, false)
- targetDBSchema := model.NewDatabaseSchema(targetMetadata, nil, nil, storepb.Engine_POSTGRES, false)
+ sourceDBSchema := model.NewDatabaseMetadata(sourceMetadata, nil, nil, storepb.Engine_POSTGRES, false)
+ targetDBSchema := model.NewDatabaseMetadata(targetMetadata, nil, nil, storepb.Engine_POSTGRES, false)
diff, err := schema.GetDatabaseSchemaDiff(storepb.Engine_POSTGRES, sourceDBSchema, targetDBSchema)
require.NoError(t, err)
diff --git a/backend/plugin/schema/pg/schema_implicit_creation_test.go b/backend/plugin/schema/pg/schema_implicit_creation_test.go
index 00c8008c6b..9e8ba82c86 100644
--- a/backend/plugin/schema/pg/schema_implicit_creation_test.go
+++ b/backend/plugin/schema/pg/schema_implicit_creation_test.go
@@ -18,7 +18,7 @@ func TestGetSDLDiff_ImplicitSchemaCreation(t *testing.T) {
name string
currentSDLText string
previousUserSDLText string
- currentSchema *model.DatabaseSchema
+ currentSchema *model.DatabaseMetadata
expectedSchemaChanges int
expectedTableChanges int
expectSchemaCreation bool
@@ -47,7 +47,7 @@ CREATE TABLE new_schema.t(
);
`,
// Current database state: only has public schema with existing_table
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -105,7 +105,7 @@ CREATE TABLE new_schema.orders(
user_id INT REFERENCES new_schema.users(id)
);
`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -159,7 +159,7 @@ CREATE TABLE new_schema.t(
value VARCHAR(50)
);
`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -210,7 +210,7 @@ CREATE TABLE public.existing_table(
CREATE SCHEMA new_schema;
`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -264,7 +264,7 @@ CREATE TABLE schema_b.table_b(
id INT PRIMARY KEY
);
`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
diff --git a/backend/plugin/schema/pg/sdl_validation_testcontainer_test.go b/backend/plugin/schema/pg/sdl_validation_testcontainer_test.go
index d94d1b0cd9..50699a6a69 100644
--- a/backend/plugin/schema/pg/sdl_validation_testcontainer_test.go
+++ b/backend/plugin/schema/pg/sdl_validation_testcontainer_test.go
@@ -1050,9 +1050,9 @@ func getSyncMetadataForSDL(ctx context.Context, connConfig *pgx.ConnConfig, dbNa
// generateMigrationDDLFromMetadata generates migration DDL from schema B to schema C using schema.differ
func generateMigrationDDLFromMetadata(schemaB, schemaC *storepb.DatabaseSchemaMetadata) (string, *schema.MetadataDiff, error) {
- // Create model.DatabaseSchema objects for comparison
- modelSchemaB := model.NewDatabaseSchema(schemaB, nil, nil, storepb.Engine_POSTGRES, true)
- modelSchemaC := model.NewDatabaseSchema(schemaC, nil, nil, storepb.Engine_POSTGRES, true)
+ // Create model.DatabaseMetadata objects for comparison
+ modelSchemaB := model.NewDatabaseMetadata(schemaB, nil, nil, storepb.Engine_POSTGRES, true)
+ modelSchemaC := model.NewDatabaseMetadata(schemaC, nil, nil, storepb.Engine_POSTGRES, true)
// Use the schema differ to compute differences
diff, err := schema.GetDatabaseSchemaDiff(storepb.Engine_POSTGRES, modelSchemaB, modelSchemaC)
@@ -1072,10 +1072,10 @@ func generateMigrationDDLFromMetadata(schemaB, schemaC *storepb.DatabaseSchemaMe
// validateSchemaConsistency compares two schema metadata objects to ensure they are equivalent
func validateSchemaConsistency(schemaD, schemaC *storepb.DatabaseSchemaMetadata) error {
- // Create model.DatabaseSchema objects for comparison
+ // Create model.DatabaseMetadata objects for comparison
// PostgreSQL is case-sensitive for object names but case-insensitive for details
- modelSchemaD := model.NewDatabaseSchema(schemaD, nil, nil, storepb.Engine_POSTGRES, true)
- modelSchemaC := model.NewDatabaseSchema(schemaC, nil, nil, storepb.Engine_POSTGRES, true)
+ modelSchemaD := model.NewDatabaseMetadata(schemaD, nil, nil, storepb.Engine_POSTGRES, true)
+ modelSchemaC := model.NewDatabaseMetadata(schemaC, nil, nil, storepb.Engine_POSTGRES, true)
// Use the schema differ to compare the two schemas
diff, err := schema.GetDatabaseSchemaDiff(storepb.Engine_POSTGRES, modelSchemaD, modelSchemaC)
diff --git a/backend/plugin/schema/pg/trigger_drift_test.go b/backend/plugin/schema/pg/trigger_drift_test.go
index 1779e1c68e..8def1f95cc 100644
--- a/backend/plugin/schema/pg/trigger_drift_test.go
+++ b/backend/plugin/schema/pg/trigger_drift_test.go
@@ -83,8 +83,8 @@ func TestTriggerDriftHandling(t *testing.T) {
},
}
- currentSchema := model.NewDatabaseSchema(currentDBMetadata, nil, nil, storepb.Engine_POSTGRES, false)
- previousSchema := model.NewDatabaseSchema(previousDBMetadata, nil, nil, storepb.Engine_POSTGRES, false)
+ currentSchema := model.NewDatabaseMetadata(currentDBMetadata, nil, nil, storepb.Engine_POSTGRES, false)
+ previousSchema := model.NewDatabaseMetadata(previousDBMetadata, nil, nil, storepb.Engine_POSTGRES, false)
diff, err := GetSDLDiff(userSDL, userSDL, currentSchema, previousSchema)
require.NoError(t, err)
@@ -140,8 +140,8 @@ func TestTriggerDriftHandling(t *testing.T) {
},
}
- currentSchema := model.NewDatabaseSchema(currentDBMetadata, nil, nil, storepb.Engine_POSTGRES, false)
- previousSchema := model.NewDatabaseSchema(previousDBMetadata, nil, nil, storepb.Engine_POSTGRES, false)
+ currentSchema := model.NewDatabaseMetadata(currentDBMetadata, nil, nil, storepb.Engine_POSTGRES, false)
+ previousSchema := model.NewDatabaseMetadata(previousDBMetadata, nil, nil, storepb.Engine_POSTGRES, false)
// Apply changes
err := applyTriggerChangesToChunks(chunks, currentSchema, previousSchema)
diff --git a/backend/plugin/schema/pg/usability_check_test.go b/backend/plugin/schema/pg/usability_check_test.go
index e7b8763ce4..ffee16a388 100644
--- a/backend/plugin/schema/pg/usability_check_test.go
+++ b/backend/plugin/schema/pg/usability_check_test.go
@@ -16,7 +16,7 @@ func TestUsabilityCheck_TableScenarios(t *testing.T) {
name string
currentSDL string
previousSDL string
- currentSchema *model.DatabaseSchema
+ currentSchema *model.DatabaseMetadata
expectTableDiff bool
expectCommentDiff bool
description string
@@ -39,7 +39,7 @@ CREATE TABLE "public"."users" (
COMMENT ON TABLE "public"."users" IS 'User table description';
`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -82,7 +82,7 @@ CREATE TABLE "public"."users" (
COMMENT ON TABLE "public"."users" IS 'Old user table description';
`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -126,7 +126,7 @@ CREATE TABLE "public"."users" (
COMMENT ON TABLE "public"."users" IS 'Old user table';
`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -170,7 +170,7 @@ CREATE TABLE "public"."users" (
COMMENT ON TABLE "public"."users" IS 'Old user table';
`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -211,7 +211,7 @@ CREATE TABLE "public"."users" (
"name" text
);
`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -252,7 +252,7 @@ CREATE TABLE "public"."users" (
COMMENT ON TABLE "public"."users" IS 'To be removed';
`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -328,7 +328,7 @@ func TestUsabilityCheck_ViewScenarios(t *testing.T) {
name string
currentSDL string
previousSDL string
- currentSchema *model.DatabaseSchema
+ currentSchema *model.DatabaseMetadata
expectViewDiff bool
expectCommentDiff bool
description string
@@ -355,7 +355,7 @@ CREATE VIEW "public"."active_users" AS SELECT * FROM users WHERE id < 0;
COMMENT ON VIEW "public"."active_users" IS 'View of all users';
`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -408,7 +408,7 @@ CREATE VIEW "public"."active_users" AS SELECT * FROM users;
COMMENT ON VIEW "public"."active_users" IS 'Old view comment';
`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -477,7 +477,7 @@ func TestUsabilityCheck_FunctionScenarios(t *testing.T) {
name string
currentSDL string
previousSDL string
- currentSchema *model.DatabaseSchema
+ currentSchema *model.DatabaseMetadata
expectFunctionDiff bool
expectCommentDiff bool
description string
@@ -506,7 +506,7 @@ $$;
COMMENT ON FUNCTION "public"."add_numbers"(a integer, b integer) IS 'Old comment';
`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
@@ -573,7 +573,7 @@ func TestUsabilityCheck_SequenceScenarios(t *testing.T) {
name string
currentSDL string
previousSDL string
- currentSchema *model.DatabaseSchema
+ currentSchema *model.DatabaseMetadata
expectSequenceDiff bool
expectCommentDiff bool
description string
@@ -590,7 +590,7 @@ CREATE SEQUENCE "public"."user_id_seq" START WITH 100 INCREMENT BY 2 NO CYCLE;
COMMENT ON SEQUENCE "public"."user_id_seq" IS 'Old sequence comment';
`,
- currentSchema: model.NewDatabaseSchema(
+ currentSchema: model.NewDatabaseMetadata(
&storepb.DatabaseSchemaMetadata{
Name: "test_db",
Schemas: []*storepb.SchemaMetadata{
diff --git a/backend/plugin/schema/pg/walk_through.go b/backend/plugin/schema/pg/walk_through.go
index e067c782d0..88163ac610 100644
--- a/backend/plugin/schema/pg/walk_through.go
+++ b/backend/plugin/schema/pg/walk_through.go
@@ -1376,7 +1376,7 @@ func (l *pgCatalogListener) dropIndex(anyName parser.IAny_nameContext, ifExists
}
func (l *pgCatalogListener) dropSchema(schemaNameCtx parser.INameContext, ifExists bool) *storepb.Advice {
schemaName := pgparser.NormalizePostgreSQLName(schemaNameCtx)
- schema := l.databaseState.GetSchema(schemaName)
+ schema := l.databaseState.GetSchemaMetadata(schemaName)
if schema == nil {
if ifExists {
return nil
@@ -1798,7 +1798,7 @@ func getOrCreatePublicSchema(d *model.DatabaseMetadata, schemaName string, line
if schemaName == "" {
schemaName = PublicSchemaName
}
- schema := d.GetSchema(schemaName)
+ schema := d.GetSchemaMetadata(schemaName)
if schema != nil {
return schema, nil
}
diff --git a/backend/plugin/schema/pg/walk_through_test.go b/backend/plugin/schema/pg/walk_through_test.go
index 712ff8a92d..e2aa4d34f4 100644
--- a/backend/plugin/schema/pg/walk_through_test.go
+++ b/backend/plugin/schema/pg/walk_through_test.go
@@ -92,7 +92,7 @@ func TestWalkThrough(t *testing.T) {
require.True(t, ok)
// Create DatabaseMetadata for walk-through
- state := model.NewDatabaseMetadata(protoData, storepb.Engine_POSTGRES, !test.IgnoreCaseSensitive)
+ state := model.NewDatabaseMetadata(protoData, nil, nil, storepb.Engine_POSTGRES, !test.IgnoreCaseSensitive)
asts, _ := sm.GetASTsForChecks(storepb.Engine_POSTGRES, test.Statement)
advice := WalkThrough(state, asts)
@@ -183,7 +183,7 @@ func TestWalkThroughANTLR(t *testing.T) {
require.True(t, ok)
// Create DatabaseMetadata for walk-through
- state := model.NewDatabaseMetadata(protoData, storepb.Engine_POSTGRES, !test.IgnoreCaseSensitive)
+ state := model.NewDatabaseMetadata(protoData, nil, nil, storepb.Engine_POSTGRES, !test.IgnoreCaseSensitive)
// Parse using ANTLR parser instead of legacy parser
parseResult, parseErr := pgparser.ParsePostgreSQL(test.Statement)
diff --git a/backend/plugin/schema/schema.go b/backend/plugin/schema/schema.go
index 6025945914..48f0b72a2c 100644
--- a/backend/plugin/schema/schema.go
+++ b/backend/plugin/schema/schema.go
@@ -38,7 +38,7 @@ type getProcedureDefinition func(string, *storepb.ProcedureMetadata) (string, er
type getSequenceDefinition func(string, *storepb.SequenceMetadata) (string, error)
type getDatabaseMetadata func(string) (*storepb.DatabaseSchemaMetadata, error)
type generateMigration func(*MetadataDiff) (string, error)
-type getSDLDiff func(currentSDLText, previousUserSDLText string, currentSchema, previousSchema *model.DatabaseSchema) (*MetadataDiff, error)
+type getSDLDiff func(currentSDLText, previousUserSDLText string, currentSchema, previousSchema *model.DatabaseMetadata) (*MetadataDiff, error)
type walkThrough func(*model.DatabaseMetadata, any) *storepb.Advice
type GetDefinitionContext struct {
@@ -243,7 +243,7 @@ func RegisterGetSDLDiff(engine storepb.Engine, f getSDLDiff) {
getSDLDiffs[engine] = f
}
-func GetSDLDiff(engine storepb.Engine, currentSDLText, previousUserSDLText string, currentSchema, previousSchema *model.DatabaseSchema) (*MetadataDiff, error) {
+func GetSDLDiff(engine storepb.Engine, currentSDLText, previousUserSDLText string, currentSchema, previousSchema *model.DatabaseMetadata) (*MetadataDiff, error) {
f, ok := getSDLDiffs[engine]
if !ok {
return nil, errors.Errorf("engine %s is not supported", engine)
diff --git a/backend/plugin/schema/tidb/generate_migration_testcontainer_test.go b/backend/plugin/schema/tidb/generate_migration_testcontainer_test.go
index e694c2ea7f..97c2fb5b26 100644
--- a/backend/plugin/schema/tidb/generate_migration_testcontainer_test.go
+++ b/backend/plugin/schema/tidb/generate_migration_testcontainer_test.go
@@ -1415,11 +1415,11 @@ ALTER TABLE test_table COMMENT = '';
// Step 3: Call generate migration to get the rollback DDL
// Convert to model.DatabaseSchema
- dbSchemaA := model.NewDatabaseSchema(schemaA, nil, nil, storepb.Engine_TIDB, false)
- dbSchemaB := model.NewDatabaseSchema(schemaB, nil, nil, storepb.Engine_TIDB, false)
+ dbMetadataA := model.NewDatabaseMetadata(schemaA, nil, nil, storepb.Engine_TIDB, false)
+ dbMetadataB := model.NewDatabaseMetadata(schemaB, nil, nil, storepb.Engine_TIDB, false)
// Get diff from B to A (to generate rollback)
- diff, err := schema.GetDatabaseSchemaDiff(storepb.Engine_TIDB, dbSchemaB, dbSchemaA)
+ diff, err := schema.GetDatabaseSchemaDiff(storepb.Engine_TIDB, dbMetadataB, dbMetadataA)
require.NoError(t, err)
// Log the diff for debugging
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 9c4a314ec1..643468a285 100644
--- a/backend/plugin/schema/tidb/get_database_metadata_testcontainer_test.go
+++ b/backend/plugin/schema/tidb/get_database_metadata_testcontainer_test.go
@@ -260,16 +260,16 @@ func compareMetadata(t *testing.T, dbMeta, parsedMeta *storepb.DatabaseSchemaMet
// For TiDB, we only have one schema
require.Equal(t, 1, len(parsedMeta.Schemas), "parsed metadata should have exactly one schema")
- dbSchema := dbMeta.Schemas[0]
+ dbMetadata := dbMeta.Schemas[0]
parsedSchema := parsedMeta.Schemas[0]
// Compare tables
- require.Equal(t, len(dbSchema.Tables), len(parsedSchema.Tables),
+ require.Equal(t, len(dbMetadata.Tables), len(parsedSchema.Tables),
"mismatch in number of tables for test %s", testName)
// Create a map for easier lookup
dbTableMap := make(map[string]*storepb.TableMetadata)
- for _, table := range dbSchema.Tables {
+ for _, table := range dbMetadata.Tables {
dbTableMap[table.Name] = table
}
@@ -292,7 +292,7 @@ func compareMetadata(t *testing.T, dbMeta, parsedMeta *storepb.DatabaseSchemaMet
}
// Compare views
- compareViews(t, dbSchema.Views, parsedSchema.Views)
+ compareViews(t, dbMetadata.Views, parsedSchema.Views)
}
func compareColumns(t *testing.T, dbColumns, parsedColumns []*storepb.ColumnMetadata, tableName string) {
diff --git a/backend/plugin/schema/tidb/walk_through.go b/backend/plugin/schema/tidb/walk_through.go
index d75d8e869d..134614cf52 100644
--- a/backend/plugin/schema/tidb/walk_through.go
+++ b/backend/plugin/schema/tidb/walk_through.go
@@ -43,7 +43,7 @@ func WalkThrough(d *model.DatabaseMetadata, ast any) *storepb.Advice {
// We define the Catalog as Database -> Schema -> Table. The Schema is only for PostgreSQL.
// So we use a Schema whose name is empty for other engines, such as MySQL.
// If there is no empty-string-name schema, create it to avoid corner cases.
- if d.GetSchema("") == nil {
+ if d.GetSchemaMetadata("") == nil {
d.CreateSchema("")
}
@@ -105,7 +105,7 @@ func changeStateTiDB(d *model.DatabaseMetadata, in tidbast.StmtNode) (err *store
func tidbRenameTable(d *model.DatabaseMetadata, node *tidbast.RenameTableStmt) *storepb.Advice {
for _, tableToTable := range node.TableToTables {
- schema := d.GetSchema("")
+ schema := d.GetSchemaMetadata("")
if schema == nil {
schema = d.CreateSchema("")
}
@@ -257,7 +257,7 @@ func tidbFindTableState(d *model.DatabaseMetadata, tableName *tidbast.TableName)
}
}
- schema := d.GetSchema("")
+ schema := d.GetSchemaMetadata("")
if schema == nil {
schema = d.CreateSchema("")
}
@@ -470,7 +470,7 @@ func tidbAlterTable(d *model.DatabaseMetadata, node *tidbast.AlterTableStmt) *st
}
}
case tidbast.AlterTableRenameTable:
- schema := d.GetSchema("")
+ schema := d.GetSchemaMetadata("")
if err := schema.RenameTable(table.GetProto().Name, spec.NewTable.Name.O); err != nil {
return &storepb.Advice{
Status: storepb.Advice_ERROR,
@@ -787,7 +787,7 @@ func tidbDropTable(d *model.DatabaseMetadata, node *tidbast.DropTableStmt) *stor
}
}
- schema := d.GetSchema("")
+ schema := d.GetSchemaMetadata("")
if schema == nil {
schema = d.CreateSchema("")
}
@@ -837,7 +837,7 @@ func tidbCopyTable(d *model.DatabaseMetadata, node *tidbast.CreateTableStmt) *st
return err
}
- schema := d.GetSchema("")
+ schema := d.GetSchemaMetadata("")
// Create new table
newTable, createErr := schema.CreateTable(node.Table.Name.O)
if createErr != nil {
@@ -909,7 +909,7 @@ func tidbCreateTable(d *model.DatabaseMetadata, node *tidbast.CreateTableStmt) *
}
}
- schema := d.GetSchema("")
+ schema := d.GetSchemaMetadata("")
if schema == nil {
schema = d.CreateSchema("")
}
diff --git a/backend/plugin/schema/tidb/walk_through_test.go b/backend/plugin/schema/tidb/walk_through_test.go
index 4e30683788..a0ca6691fa 100644
--- a/backend/plugin/schema/tidb/walk_through_test.go
+++ b/backend/plugin/schema/tidb/walk_through_test.go
@@ -49,7 +49,7 @@ func TestWalkThrough(t *testing.T) {
require.True(t, ok)
// Create DatabaseMetadata for walk-through
- state := model.NewDatabaseMetadata(protoData, storepb.Engine_TIDB, !test.IgnoreCaseSensitive)
+ state := model.NewDatabaseMetadata(protoData, nil, nil, storepb.Engine_TIDB, !test.IgnoreCaseSensitive)
asts, _ := sm.GetASTsForChecks(storepb.Engine_TIDB, test.Statement)
advice := WalkThrough(state, asts)
diff --git a/backend/runner/plancheck/statement_advise_executor.go b/backend/runner/plancheck/statement_advise_executor.go
index fbaccc3ec7..cfdf525332 100644
--- a/backend/runner/plancheck/statement_advise_executor.go
+++ b/backend/runner/plancheck/statement_advise_executor.go
@@ -126,17 +126,17 @@ func (e *StatementAdviseExecutor) runReview(
statement string,
enablePriorBackup bool,
) ([]*storepb.PlanCheckRunResult_Result, error) {
- dbSchema, err := e.store.GetDBSchema(ctx, &store.FindDBSchemaMessage{
+ dbMetadata, err := e.store.GetDBSchema(ctx, &store.FindDBSchemaMessage{
InstanceID: database.InstanceID,
DatabaseName: database.DatabaseName,
})
if err != nil {
return nil, err
}
- if dbSchema == nil {
+ if dbMetadata == nil {
return nil, errors.Errorf("database schema %s not found", database.String())
}
- if dbSchema.GetMetadata() == nil {
+ if dbMetadata.GetMetadata() == nil {
return nil, errors.Errorf("database schema metadata %s not found", database.String())
}
@@ -151,14 +151,14 @@ func (e *StatementAdviseExecutor) runReview(
}
// Create original metadata as read-only
- originMetadata := model.NewDatabaseMetadata(dbSchema.GetMetadata(), instance.Metadata.GetEngine(), store.IsObjectCaseSensitive(instance))
+ originMetadata := model.NewDatabaseMetadata(dbMetadata.GetMetadata(), nil, nil, instance.Metadata.GetEngine(), store.IsObjectCaseSensitive(instance))
// Clone metadata for final to avoid modifying the original
- clonedMetadata, ok := proto.Clone(dbSchema.GetMetadata()).(*storepb.DatabaseSchemaMetadata)
+ clonedMetadata, ok := proto.Clone(dbMetadata.GetMetadata()).(*storepb.DatabaseSchemaMetadata)
if !ok {
return nil, common.Wrapf(errors.New("failed to clone database schema metadata"), common.Internal, "failed to create a catalog")
}
- finalMetadata := model.NewDatabaseMetadata(clonedMetadata, instance.Metadata.GetEngine(), store.IsObjectCaseSensitive(instance))
+ finalMetadata := model.NewDatabaseMetadata(clonedMetadata, nil, nil, instance.Metadata.GetEngine(), store.IsObjectCaseSensitive(instance))
useDatabaseOwner, err := getUseDatabaseOwner(ctx, e.store, instance, database)
if err != nil {
@@ -177,9 +177,9 @@ func (e *StatementAdviseExecutor) runReview(
classificationConfig := getClassificationByProject(ctx, e.store, database.ProjectID)
adviceList, err := advisor.SQLReviewCheck(ctx, e.sheetManager, statement, reviewConfig.SqlReviewRules, advisor.SQLReviewCheckContext{
- Charset: dbSchema.GetMetadata().CharacterSet,
- Collation: dbSchema.GetMetadata().Collation,
- DBSchema: dbSchema.GetMetadata(),
+ Charset: dbMetadata.GetMetadata().CharacterSet,
+ Collation: dbMetadata.GetMetadata().Collation,
+ DBSchema: dbMetadata.GetMetadata(),
ChangeType: changeType,
DBType: instance.Metadata.GetEngine(),
OriginalMetadata: originMetadata,
diff --git a/backend/runner/schemasync/syncer.go b/backend/runner/schemasync/syncer.go
index 897e911674..f27d3dce23 100644
--- a/backend/runner/schemasync/syncer.go
+++ b/backend/runner/schemasync/syncer.go
@@ -379,7 +379,7 @@ func (s *Syncer) doSyncDatabaseSchema(ctx context.Context, database *store.Datab
}
rawDump := schemaBuf.Bytes()
- dbSchema, err := s.store.GetDBSchema(ctx, &store.FindDBSchemaMessage{
+ dbMetadata, err := s.store.GetDBSchema(ctx, &store.FindDBSchemaMessage{
InstanceID: database.InstanceID,
DatabaseName: database.DatabaseName,
})
@@ -387,11 +387,6 @@ func (s *Syncer) doSyncDatabaseSchema(ctx context.Context, database *store.Datab
return 0, errors.Wrapf(err, "failed to get database schema for database %q", database.DatabaseName)
}
- dbModelConfig := model.NewDatabaseConfig(nil)
- if dbSchema != nil {
- dbModelConfig = dbSchema.GetInternalConfig()
- }
-
project, err := s.store.GetProjectV2(ctx, &store.FindProjectMessage{
ResourceID: &database.ProjectID,
})
@@ -411,13 +406,13 @@ func (s *Syncer) doSyncDatabaseSchema(ctx context.Context, database *store.Datab
if classificationConfig.ClassificationFromConfig {
// Only set the user comment.
setUserCommentFromComment(databaseMetadata)
- dbConfig = dbModelConfig.BuildDatabaseConfig()
+ dbConfig = dbMetadata.BuildDatabaseConfig()
} else {
// Get classification from the comment.
if err := s.licenseService.IsFeatureEnabledForInstance(v1pb.PlanFeature_FEATURE_DATA_CLASSIFICATION, instance); err == nil {
- dbConfig = buildDatabaseConfigWithClassificationFromComment(databaseMetadata, dbModelConfig, classificationConfig)
+ dbConfig = buildDatabaseConfigWithClassificationFromComment(databaseMetadata, dbMetadata, classificationConfig)
} else {
- dbConfig = dbModelConfig.BuildDatabaseConfig()
+ dbConfig = dbMetadata.BuildDatabaseConfig()
}
}
@@ -523,16 +518,16 @@ func (s *Syncer) getSchemaDrifted(ctx context.Context, instance *store.InstanceM
return changelog.Schema != latestSchema, false, nil
}
-func (s *Syncer) databaseBackupAvailable(ctx context.Context, instance *store.InstanceMessage, dbSchema *storepb.DatabaseSchemaMetadata) bool {
+func (s *Syncer) databaseBackupAvailable(ctx context.Context, instance *store.InstanceMessage, dbMetadata *storepb.DatabaseSchemaMetadata) bool {
if !common.EngineSupportPriorBackup(instance.Metadata.GetEngine()) {
return false
}
switch instance.Metadata.GetEngine() {
case storepb.Engine_POSTGRES:
- if dbSchema == nil {
+ if dbMetadata == nil {
return false
}
- for _, schema := range dbSchema.Schemas {
+ for _, schema := range dbMetadata.Schemas {
if schema.GetName() == common.BackupDatabaseNameOfEngine(storepb.Engine_POSTGRES) {
return true
}
@@ -567,13 +562,13 @@ func (s *Syncer) databaseBackupAvailable(ctx context.Context, instance *store.In
return false
}
-func buildDatabaseConfigWithClassificationFromComment(dbSchema *storepb.DatabaseSchemaMetadata, databaseConfig *model.DatabaseConfig, classificationConfig *storepb.DataClassificationSetting_DataClassificationConfig) *storepb.DatabaseConfig {
+func buildDatabaseConfigWithClassificationFromComment(dbMetadata *storepb.DatabaseSchemaMetadata, databaseConfig *model.DatabaseMetadata, classificationConfig *storepb.DataClassificationSetting_DataClassificationConfig) *storepb.DatabaseConfig {
// Create a new DatabaseConfig to build from scratch
newConfig := &storepb.DatabaseConfig{
- Name: dbSchema.Name,
+ Name: dbMetadata.Name,
}
- for _, schema := range dbSchema.Schemas {
+ for _, schema := range dbMetadata.Schemas {
var tables []*storepb.TableCatalog
hasSchemaContent := false
@@ -605,7 +600,7 @@ func buildDatabaseConfigWithClassificationFromComment(dbSchema *storepb.Database
existingColumnConfig := tableConfig.GetColumnConfig(col.Name)
// Add column config if it has any meaningful data
- if colClassification != "" || existingColumnConfig.SemanticType != "" || len(existingColumnConfig.Labels) > 0 {
+ if colClassification != "" || existingColumnConfig.GetSemanticType() != "" || len(existingColumnConfig.GetLabels()) > 0 {
columns = append(columns, &storepb.ColumnCatalog{
Name: col.Name,
Classification: colClassification,
@@ -641,8 +636,8 @@ func buildDatabaseConfigWithClassificationFromComment(dbSchema *storepb.Database
return newConfig
}
-func setUserCommentFromComment(dbSchema *storepb.DatabaseSchemaMetadata) {
- for _, schema := range dbSchema.Schemas {
+func setUserCommentFromComment(dbMetadata *storepb.DatabaseSchemaMetadata) {
+ for _, schema := range dbMetadata.Schemas {
for _, table := range schema.Tables {
table.UserComment = table.Comment
for _, col := range table.Columns {
diff --git a/backend/runner/taskrun/database_migrate_executor.go b/backend/runner/taskrun/database_migrate_executor.go
index 84dbdd6ce4..13a81fdb75 100644
--- a/backend/runner/taskrun/database_migrate_executor.go
+++ b/backend/runner/taskrun/database_migrate_executor.go
@@ -504,7 +504,7 @@ func buildGetDatabaseMetadataFunc(storeInstance *store.Store) parserbase.GetData
if databaseMetadata == nil {
return "", nil, nil
}
- return databaseName, databaseMetadata.GetDatabaseMetadata(), nil
+ return databaseName, databaseMetadata, nil
}
}
diff --git a/backend/runner/taskrun/schema_update_sdl_executor.go b/backend/runner/taskrun/schema_update_sdl_executor.go
index 81bbab3301..6dccdb527e 100644
--- a/backend/runner/taskrun/schema_update_sdl_executor.go
+++ b/backend/runner/taskrun/schema_update_sdl_executor.go
@@ -83,14 +83,14 @@ func diff(ctx context.Context, s *store.Store, instance *store.InstanceMessage,
return "", errors.Wrapf(err, "failed to convert %q to parser engine", instance.Metadata.GetEngine())
}
- dbSchema, err := s.GetDBSchema(ctx, &store.FindDBSchemaMessage{
+ dbMetadata, err := s.GetDBSchema(ctx, &store.FindDBSchemaMessage{
InstanceID: database.InstanceID,
DatabaseName: database.DatabaseName,
})
if err != nil {
return "", errors.Wrapf(err, "failed to get database schema for database %q", database.DatabaseName)
}
- if dbSchema == nil {
+ if dbMetadata == nil {
return "", errors.Errorf("database schema %q not found", database.DatabaseName)
}
@@ -106,7 +106,7 @@ func diff(ctx context.Context, s *store.Store, instance *store.InstanceMessage,
// - previousUserSDLText: previous SDL text (empty triggers initialization scenario)
// - currentSchema: current database schema (used as baseline in initialization)
// - previousSchema: previous database schema from changelog
- schemaDiff, err := schema.GetSDLDiff(pengine, sheetContent, previousUserSDLText, dbSchema, previousSchema)
+ schemaDiff, err := schema.GetSDLDiff(pengine, sheetContent, previousUserSDLText, dbMetadata, previousSchema)
if err != nil {
return "", errors.Wrap(err, "failed to compute SDL schema diff")
}
@@ -128,7 +128,7 @@ func diff(ctx context.Context, s *store.Store, instance *store.InstanceMessage,
// successfully completed SDL changelog for the given database.
// Returns empty string if no previous successful SDL changelog is found.
// getPreviousSuccessfulSDLAndSchema gets both the SDL text and database schema from the most recent successful SDL changelog
-func getPreviousSuccessfulSDLAndSchema(ctx context.Context, s *store.Store, instanceID string, databaseName string) (string, *model.DatabaseSchema, error) {
+func getPreviousSuccessfulSDLAndSchema(ctx context.Context, s *store.Store, instanceID string, databaseName string) (string, *model.DatabaseMetadata, error) {
// Find the most recent successful SDL changelog for this database
// We only want MIGRATE_SDL type changelogs that are completed (DONE status)
doneStatus := store.ChangelogStatusDone
@@ -174,7 +174,7 @@ func getPreviousSuccessfulSDLAndSchema(ctx context.Context, s *store.Store, inst
// Get the previous schema from sync history
// Use SyncHistoryUID (after applying the SDL) instead of PrevSyncHistoryUID (before applying)
// This represents the database schema state after the previous SDL was successfully applied
- var previousSchema *model.DatabaseSchema
+ var previousSchema *model.DatabaseMetadata
if mostRecentChangelog.SyncHistoryUID != nil {
// Get the sync history record to obtain the schema metadata
syncHistory, err := s.GetSyncHistoryByUID(ctx, *mostRecentChangelog.SyncHistoryUID)
@@ -193,7 +193,7 @@ func getPreviousSuccessfulSDLAndSchema(ctx context.Context, s *store.Store, inst
}
// Create a DatabaseSchema wrapper using the metadata from sync history
- previousSchema = model.NewDatabaseSchema(
+ previousSchema = model.NewDatabaseMetadata(
syncHistory.Metadata,
[]byte(syncHistory.Schema), // Use the schema content from sync history
&storepb.DatabaseConfig{}, // Empty config
diff --git a/backend/store/db_schema.go b/backend/store/db_schema.go
index 3bdfbb7150..d8d488e86e 100644
--- a/backend/store/db_schema.go
+++ b/backend/store/db_schema.go
@@ -24,8 +24,8 @@ type FindDBSchemaMessage struct {
}
// GetDBSchema gets the schema for a database.
-func (s *Store) GetDBSchema(ctx context.Context, find *FindDBSchemaMessage) (*model.DatabaseSchema, error) {
- if v, ok := s.dbSchemaCache.Get(getDatabaseCacheKey(find.InstanceID, find.DatabaseName)); ok && s.enableCache {
+func (s *Store) GetDBSchema(ctx context.Context, find *FindDBSchemaMessage) (*model.DatabaseMetadata, error) {
+ if v, ok := s.dbMetadataCache.Get(getDatabaseCacheKey(find.InstanceID, find.DatabaseName)); ok && s.enableCache {
return v, nil
}
@@ -63,13 +63,13 @@ func (s *Store) GetDBSchema(ctx context.Context, find *FindDBSchemaMessage) (*mo
return nil, err
}
- dbSchema, err := s.convertMetadataAndConfig(ctx, metadata, schema, config, find.InstanceID)
+ dbMetadata, err := s.convertMetadataAndConfig(ctx, metadata, schema, config, find.InstanceID)
if err != nil {
return nil, err
}
- s.dbSchemaCache.Add(getDatabaseCacheKey(find.InstanceID, find.DatabaseName), dbSchema)
- return dbSchema, nil
+ s.dbMetadataCache.Add(getDatabaseCacheKey(find.InstanceID, find.DatabaseName), dbMetadata)
+ return dbMetadata, nil
}
// UpsertDBSchema upserts a database schema.
@@ -79,7 +79,7 @@ func (s *Store) UpsertDBSchema(
databaseName string,
dbMetadata *storepb.DatabaseSchemaMetadata,
dbConfig *storepb.DatabaseConfig,
- dbSchema []byte,
+ rawDump []byte,
) error {
metadataBytes, err := protojson.Marshal(dbMetadata)
if err != nil {
@@ -108,7 +108,7 @@ func (s *Store) UpsertDBSchema(
databaseName,
metadataBytes,
// Convert to string because []byte{} is null which violates db schema constraints.
- string(dbSchema),
+ string(rawDump),
configBytes)
query, args, err := q.ToSQL()
@@ -138,7 +138,7 @@ func (s *Store) UpsertDBSchema(
return err
}
- s.dbSchemaCache.Add(getDatabaseCacheKey(instanceID, databaseName), updatedDBSchema)
+ s.dbMetadataCache.Add(getDatabaseCacheKey(instanceID, databaseName), updatedDBSchema)
return nil
}
@@ -175,11 +175,11 @@ func (s *Store) UpdateDBSchema(ctx context.Context, instanceID, databaseName str
return err
}
// Invalid the cache and read the value again.
- s.dbSchemaCache.Remove(getDatabaseCacheKey(instanceID, databaseName))
+ s.dbMetadataCache.Remove(getDatabaseCacheKey(instanceID, databaseName))
return nil
}
-func (s *Store) convertMetadataAndConfig(ctx context.Context, metadata, schema, config []byte, instanceID string) (*model.DatabaseSchema, error) {
+func (s *Store) convertMetadataAndConfig(ctx context.Context, metadata, schema, config []byte, instanceID string) (*model.DatabaseMetadata, error) {
var databaseSchema storepb.DatabaseSchemaMetadata
var databaseConfig storepb.DatabaseConfig
if err := common.ProtojsonUnmarshaler.Unmarshal(metadata, &databaseSchema); err != nil {
@@ -192,5 +192,5 @@ func (s *Store) convertMetadataAndConfig(ctx context.Context, metadata, schema,
if err != nil {
return nil, err
}
- return model.NewDatabaseSchema(&databaseSchema, schema, &databaseConfig, instance.Metadata.GetEngine(), IsObjectCaseSensitive(instance)), nil
+ return model.NewDatabaseMetadata(&databaseSchema, schema, &databaseConfig, instance.Metadata.GetEngine(), IsObjectCaseSensitive(instance)), nil
}
diff --git a/backend/store/model/changed_resources.go b/backend/store/model/changed_resources.go
index 1461ed206c..7d72b49e49 100644
--- a/backend/store/model/changed_resources.go
+++ b/backend/store/model/changed_resources.go
@@ -9,7 +9,7 @@ import (
type ChangedResources struct {
databases map[string]*ChangedDatabase
- dbSchema *DatabaseSchema
+ dbMetadata *DatabaseMetadata
}
type ChangedDatabase struct {
@@ -28,10 +28,10 @@ type ChangedTable struct {
affectedTable bool
}
-func NewChangedResources(dbSchema *DatabaseSchema) *ChangedResources {
+func NewChangedResources(dbMetadata *DatabaseMetadata) *ChangedResources {
return &ChangedResources{
- databases: make(map[string]*ChangedDatabase),
- dbSchema: dbSchema,
+ databases: make(map[string]*ChangedDatabase),
+ dbMetadata: dbMetadata,
}
}
@@ -42,13 +42,10 @@ func (r *ChangedResources) Build() *storepb.ChangedResources {
d.Name = name
for _, schema := range d.Schemas {
for _, table := range schema.Tables {
- if r.dbSchema == nil {
+ if r.dbMetadata == nil {
continue
}
- if r.dbSchema.GetDatabaseMetadata() == nil {
- continue
- }
- schemaMetadata := r.dbSchema.GetDatabaseMetadata().GetSchema(schema.GetName())
+ schemaMetadata := r.dbMetadata.GetSchemaMetadata(schema.GetName())
if schemaMetadata == nil {
continue
}
@@ -229,7 +226,7 @@ func (r *ChangedResources) AddProcedure(database string, schema string, change *
}
func (r *ChangedResources) CountAffectedTableRows() int64 {
- if r.dbSchema == nil {
+ if r.dbMetadata == nil {
return 0
}
@@ -240,11 +237,10 @@ func (r *ChangedResources) CountAffectedTableRows() int64 {
if !table.affectedTable {
continue
}
- dbMeta := r.dbSchema.GetDatabaseMetadata()
- if dbMeta == nil {
+ if r.dbMetadata == nil {
continue
}
- schemaMeta := dbMeta.GetSchema(schemaName)
+ schemaMeta := r.dbMetadata.GetSchemaMetadata(schemaName)
if schemaMeta == nil {
continue
}
diff --git a/backend/store/model/database.go b/backend/store/model/database.go
index ca3f2f2ba8..24de50636b 100644
--- a/backend/store/model/database.go
+++ b/backend/store/model/database.go
@@ -9,187 +9,58 @@ import (
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
)
-// DatabaseSchema is the database schema including the metadata and schema (raw dump).
-type DatabaseSchema struct {
- metadata *storepb.DatabaseSchemaMetadata
- schema []byte
- config *storepb.DatabaseConfig
+// DatabaseMetadata is the unified database schema including metadata, config, and raw dump.
+// This struct combines what were previously separate types: DatabaseMetadata, and DatabaseConfig.
+type DatabaseMetadata struct {
+ // Proto representations for serialization
+ metadata *storepb.DatabaseSchemaMetadata
+ config *storepb.DatabaseConfig
+ schema []byte
+
+ // Case sensitivity flags
isObjectCaseSensitive bool
isDetailCaseSensitive bool
- metadataInternal *DatabaseMetadata
- configInternal *DatabaseConfig
+ // Metadata fields (formerly in DatabaseMetadata)
+ name string
+ owner string
+ searchPath []string
+ internal map[string]*SchemaMetadata
+ linkedDatabase map[string]*LinkedDatabaseMetadata
+
+ // Config fields (formerly in DatabaseConfig)
+ configName string
+ configInternal map[string]*SchemaConfig
}
-func NewDatabaseSchema(
+func NewDatabaseMetadata(
metadata *storepb.DatabaseSchemaMetadata,
schema []byte,
config *storepb.DatabaseConfig,
engine storepb.Engine,
isObjectCaseSensitive bool,
-) *DatabaseSchema {
- databaseMetadata := NewDatabaseMetadata(metadata, engine, isObjectCaseSensitive)
- databaseConfig := NewDatabaseConfig(config)
- return &DatabaseSchema{
+) *DatabaseMetadata {
+ isDetailCaseSensitive := getIsDetailCaseSensitive(engine)
+ dbMetadata := &DatabaseMetadata{
metadata: metadata,
schema: schema,
config: config,
isObjectCaseSensitive: isObjectCaseSensitive,
- isDetailCaseSensitive: getIsDetailCaseSensitive(engine),
- metadataInternal: databaseMetadata,
- configInternal: databaseConfig,
- }
-}
-
-func (dbs *DatabaseSchema) GetMetadata() *storepb.DatabaseSchemaMetadata {
- return dbs.metadata
-}
-
-func (dbs *DatabaseSchema) GetSchema() []byte {
- return dbs.schema
-}
-
-func (dbs *DatabaseSchema) GetConfig() *storepb.DatabaseConfig {
- return dbs.config
-}
-
-func (dbs *DatabaseSchema) GetDatabaseMetadata() *DatabaseMetadata {
- return dbs.metadataInternal
-}
-
-func (dbs *DatabaseSchema) GetInternalConfig() *DatabaseConfig {
- return dbs.configInternal
-}
-
-// DatabaseConfig is the config for a database.
-type DatabaseConfig struct {
- name string
- internal map[string]*SchemaConfig
-}
-
-// NewDatabaseConfig creates a new database config.
-func NewDatabaseConfig(config *storepb.DatabaseConfig) *DatabaseConfig {
- databaseConfig := &DatabaseConfig{
- internal: make(map[string]*SchemaConfig),
- }
- if config == nil {
- return databaseConfig
- }
- databaseConfig.name = config.Name
- for _, schema := range config.Schemas {
- schemaConfig := &SchemaConfig{
- internal: make(map[string]*TableConfig),
- }
- for _, table := range schema.Tables {
- tableConfig := &TableConfig{
- Classification: table.Classification,
- internal: make(map[string]*storepb.ColumnCatalog),
- }
- for _, column := range table.Columns {
- tableConfig.internal[column.Name] = column
- }
- schemaConfig.internal[table.Name] = tableConfig
- }
- databaseConfig.internal[schema.Name] = schemaConfig
- }
- return databaseConfig
-}
-
-// GetSchemaConfig gets the schema config by name.
-// If not found, returns a new empty schema config.
-func (d *DatabaseConfig) GetSchemaConfig(name string) *SchemaConfig {
- if config := d.internal[name]; config != nil {
- return config
- }
- return &SchemaConfig{
- internal: make(map[string]*TableConfig),
- }
-}
-
-func (d *DatabaseConfig) BuildDatabaseConfig() *storepb.DatabaseConfig {
- config := &storepb.DatabaseConfig{Name: d.name}
-
- for schemaName, sConfig := range d.internal {
- schemaConfig := &storepb.SchemaCatalog{Name: schemaName}
-
- for tableName, tConfig := range sConfig.internal {
- tableConfig := &storepb.TableCatalog{Name: tableName, Classification: tConfig.Classification}
-
- for colName, colConfig := range tConfig.internal {
- tableConfig.Columns = append(tableConfig.Columns, &storepb.ColumnCatalog{
- Name: colName,
- SemanticType: colConfig.SemanticType,
- Labels: colConfig.Labels,
- Classification: colConfig.Classification,
- })
- }
- schemaConfig.Tables = append(schemaConfig.Tables, tableConfig)
- }
- config.Schemas = append(config.Schemas, schemaConfig)
- }
-
- return config
-}
-
-// SchemaConfig is the config for a schema.
-type SchemaConfig struct {
- internal map[string]*TableConfig
-}
-
-// GetTableConfig gets the table config by name.
-// If not found, returns a new empty table config.
-func (s *SchemaConfig) GetTableConfig(name string) *TableConfig {
- if config := s.internal[name]; config != nil {
- return config
- }
- return &TableConfig{
- internal: make(map[string]*storepb.ColumnCatalog),
- }
-}
-
-// TableConfig is the config for a table.
-type TableConfig struct {
- Classification string
- internal map[string]*storepb.ColumnCatalog
-}
-
-// GetColumnConfig gets the column config by name.
-// If not found, returns a new empty column config.
-func (t *TableConfig) GetColumnConfig(name string) *storepb.ColumnCatalog {
- if config := t.internal[name]; config != nil {
- return config
- }
- return &storepb.ColumnCatalog{
- Name: name,
- }
-}
-
-// DatabaseMetadata is the metadata for a database.
-type DatabaseMetadata struct {
- proto *storepb.DatabaseSchemaMetadata
- name string
- owner string
- searchPath []string
- isObjectCaseSensitive bool
- isDetailCaseSensitive bool
- internal map[string]*SchemaMetadata
- linkedDatabase map[string]*LinkedDatabaseMetadata
-}
-
-// NewDatabaseMetadata creates a new database metadata.
-func NewDatabaseMetadata(metadata *storepb.DatabaseSchemaMetadata, engineType storepb.Engine, isObjectCaseSensitive bool) *DatabaseMetadata {
- isDetailCaseSensitive := getIsDetailCaseSensitive(engineType)
- databaseMetadata := &DatabaseMetadata{
- proto: metadata,
+ isDetailCaseSensitive: isDetailCaseSensitive,
name: metadata.Name,
owner: metadata.Owner,
searchPath: normalizeSearchPath(metadata.SearchPath),
- isObjectCaseSensitive: isObjectCaseSensitive,
- isDetailCaseSensitive: isDetailCaseSensitive,
internal: make(map[string]*SchemaMetadata),
linkedDatabase: make(map[string]*LinkedDatabaseMetadata),
+ configInternal: make(map[string]*SchemaConfig),
+ }
+
+ if config != nil {
+ dbMetadata.configName = config.Name
}
- for _, schema := range metadata.Schemas {
+
+ // Build schema metadata maps
+ for _, s := range metadata.Schemas {
schemaMetadata := &SchemaMetadata{
isObjectCaseSensitive: isObjectCaseSensitive,
isDetailCaseSensitive: isDetailCaseSensitive,
@@ -201,9 +72,9 @@ func NewDatabaseMetadata(metadata *storepb.DatabaseSchemaMetadata, engineType st
internalProcedures: make(map[string]*ProcedureMetadata),
internalPackages: make(map[string]*PackageMetadata),
internalSequences: make(map[string]*SequenceMetadata),
- proto: schema,
+ proto: s,
}
- for _, table := range schema.Tables {
+ for _, table := range s.Tables {
tables, names := buildTablesMetadata(table, isDetailCaseSensitive)
for i, table := range tables {
var tableID string
@@ -215,7 +86,7 @@ func NewDatabaseMetadata(metadata *storepb.DatabaseSchemaMetadata, engineType st
schemaMetadata.internalTables[tableID] = table
}
}
- for _, externalTable := range schema.ExternalTables {
+ for _, externalTable := range s.ExternalTables {
externalTableMetadata := &ExternalTableMetadata{
isDetailCaseSensitive: isDetailCaseSensitive,
internal: make(map[string]*storepb.ColumnMetadata),
@@ -239,7 +110,7 @@ func NewDatabaseMetadata(metadata *storepb.DatabaseSchemaMetadata, engineType st
}
schemaMetadata.internalExternalTable[tableID] = externalTableMetadata
}
- for _, view := range schema.Views {
+ for _, view := range s.Views {
var viewID string
if isObjectCaseSensitive {
viewID = view.Name
@@ -251,7 +122,7 @@ func NewDatabaseMetadata(metadata *storepb.DatabaseSchemaMetadata, engineType st
proto: view,
}
}
- for _, materializedView := range schema.MaterializedViews {
+ for _, materializedView := range s.MaterializedViews {
var viewID string
if isObjectCaseSensitive {
viewID = materializedView.Name
@@ -263,13 +134,13 @@ func NewDatabaseMetadata(metadata *storepb.DatabaseSchemaMetadata, engineType st
proto: materializedView,
}
}
- for _, function := range schema.Functions {
+ for _, function := range s.Functions {
schemaMetadata.internalFunctions = append(schemaMetadata.internalFunctions, &FunctionMetadata{
Definition: function.Definition,
proto: function,
})
}
- for _, procedure := range schema.Procedures {
+ for _, procedure := range s.Procedures {
var procedureID string
if isDetailCaseSensitive {
procedureID = procedure.Name
@@ -281,7 +152,7 @@ func NewDatabaseMetadata(metadata *storepb.DatabaseSchemaMetadata, engineType st
proto: procedure,
}
}
- for _, p := range schema.Packages {
+ for _, p := range s.Packages {
var packageID string
if isDetailCaseSensitive {
packageID = p.Name
@@ -293,7 +164,7 @@ func NewDatabaseMetadata(metadata *storepb.DatabaseSchemaMetadata, engineType st
proto: p,
}
}
- for _, sequence := range schema.Sequences {
+ for _, sequence := range s.Sequences {
var sequenceID string
if isDetailCaseSensitive {
sequenceID = sequence.Name
@@ -306,12 +177,13 @@ func NewDatabaseMetadata(metadata *storepb.DatabaseSchemaMetadata, engineType st
}
var schemaID string
if isObjectCaseSensitive {
- schemaID = schema.Name
+ schemaID = s.Name
} else {
- schemaID = strings.ToLower(schema.Name)
+ schemaID = strings.ToLower(s.Name)
}
- databaseMetadata.internal[schemaID] = schemaMetadata
+ dbMetadata.internal[schemaID] = schemaMetadata
}
+
for _, dbLink := range metadata.LinkedDatabases {
var dbLinkID string
if isObjectCaseSensitive {
@@ -319,21 +191,63 @@ func NewDatabaseMetadata(metadata *storepb.DatabaseSchemaMetadata, engineType st
} else {
dbLinkID = strings.ToLower(dbLink.Name)
}
- databaseMetadata.linkedDatabase[dbLinkID] = &LinkedDatabaseMetadata{
+ dbMetadata.linkedDatabase[dbLinkID] = &LinkedDatabaseMetadata{
name: dbLink.Name,
username: dbLink.Username,
host: dbLink.Host,
}
}
- return databaseMetadata
+
+ // Build config maps
+ if config != nil {
+ for _, schemaProto := range config.Schemas {
+ schemaConfig := &SchemaConfig{
+ internal: make(map[string]*TableConfig),
+ }
+ for _, table := range schemaProto.Tables {
+ tableConfig := &TableConfig{
+ Classification: table.Classification,
+ internal: make(map[string]*storepb.ColumnCatalog),
+ }
+ for _, column := range table.Columns {
+ tableConfig.internal[column.Name] = column
+ }
+ schemaConfig.internal[table.Name] = tableConfig
+ }
+ dbMetadata.configInternal[schemaProto.Name] = schemaConfig
+ }
+ }
+
+ return dbMetadata
+}
+
+// Proto getters for serialization
+func (d *DatabaseMetadata) GetMetadata() *storepb.DatabaseSchemaMetadata {
+ return d.metadata
+}
+
+func (d *DatabaseMetadata) GetSchema() []byte {
+ return d.schema
}
+func (d *DatabaseMetadata) GetConfig() *storepb.DatabaseConfig {
+ return d.config
+}
+
+// Metadata methods (formerly from DatabaseMetadata)
func (d *DatabaseMetadata) GetName() string {
return d.name
}
-// GetSchema gets the schema by name.
-func (d *DatabaseMetadata) GetSchema(name string) *SchemaMetadata {
+func (d *DatabaseMetadata) GetOwner() string {
+ return d.owner
+}
+
+func (d *DatabaseMetadata) GetSearchPath() []string {
+ return d.searchPath
+}
+
+func (d *DatabaseMetadata) GetSchemaMetadata(name string) *SchemaMetadata {
var schemaID string
if d.isObjectCaseSensitive {
schemaID = name
@@ -343,15 +257,13 @@ func (d *DatabaseMetadata) GetSchema(name string) *SchemaMetadata {
return d.internal[schemaID]
}
-// DatabaseName returns the name of the database.
func (d *DatabaseMetadata) DatabaseName() string {
- if d.proto == nil {
+ if d.metadata == nil {
return ""
}
- return d.proto.Name
+ return d.metadata.Name
}
-// HasNoTable returns true if the database has no tables.
func (d *DatabaseMetadata) HasNoTable() bool {
for _, schema := range d.internal {
if schema != nil && schema.proto != nil && len(schema.proto.Tables) > 0 {
@@ -361,7 +273,6 @@ func (d *DatabaseMetadata) HasNoTable() bool {
return true
}
-// ListSchemaNames lists the schema names.
func (d *DatabaseMetadata) ListSchemaNames() []string {
var result []string
for _, schema := range d.internal {
@@ -380,30 +291,18 @@ func (d *DatabaseMetadata) GetLinkedDatabase(name string) *LinkedDatabaseMetadat
return d.linkedDatabase[nameID]
}
-func (d *DatabaseMetadata) GetOwner() string {
- return d.owner
-}
-
-func (d *DatabaseMetadata) GetSearchPath() []string {
- return d.searchPath
-}
-
-// GetProto returns the underlying proto for this database metadata.
func (d *DatabaseMetadata) GetProto() *storepb.DatabaseSchemaMetadata {
- return d.proto
+ return d.metadata
}
-// SortProto sorts the proto structures to ensure deterministic output.
-// This matches the behavior of the old DatabaseState.convertToDatabaseMetadata.
-// This should be called before comparing protos in tests.
func (d *DatabaseMetadata) SortProto() {
// Sort schemas by name
- slices.SortFunc(d.proto.Schemas, func(x, y *storepb.SchemaMetadata) int {
+ slices.SortFunc(d.metadata.Schemas, func(x, y *storepb.SchemaMetadata) int {
return strings.Compare(x.Name, y.Name)
})
// Sort tables and indexes within each schema
- for _, schema := range d.proto.Schemas {
+ for _, schema := range d.metadata.Schemas {
// Sort tables by name
slices.SortFunc(schema.Tables, func(x, y *storepb.TableMetadata) int {
return strings.Compare(x.Name, y.Name)
@@ -433,13 +332,10 @@ func (d *DatabaseMetadata) SortProto() {
}
}
-// GetIsObjectCaseSensitive returns whether object names (schemas, tables) are case-sensitive.
func (d *DatabaseMetadata) GetIsObjectCaseSensitive() bool {
return d.isObjectCaseSensitive
}
-// CreateSchema creates a new schema in the database.
-// Returns the created SchemaMetadata.
func (d *DatabaseMetadata) CreateSchema(schemaName string) *SchemaMetadata {
// Create new schema proto
newSchemaProto := &storepb.SchemaMetadata{
@@ -449,7 +345,7 @@ func (d *DatabaseMetadata) CreateSchema(schemaName string) *SchemaMetadata {
}
// Add to proto's schema list
- d.proto.Schemas = append(d.proto.Schemas, newSchemaProto)
+ d.metadata.Schemas = append(d.metadata.Schemas, newSchemaProto)
// Create SchemaMetadata wrapper
schemaMeta := &SchemaMetadata{
@@ -478,11 +374,9 @@ func (d *DatabaseMetadata) CreateSchema(schemaName string) *SchemaMetadata {
return schemaMeta
}
-// DropSchema drops a schema from the database.
-// Returns an error if the schema does not exist.
func (d *DatabaseMetadata) DropSchema(schemaName string) error {
// Check if schema exists
- if d.GetSchema(schemaName) == nil {
+ if d.GetSchemaMetadata(schemaName) == nil {
return errors.Errorf("schema %q does not exist in database %q", schemaName, d.name)
}
@@ -496,8 +390,8 @@ func (d *DatabaseMetadata) DropSchema(schemaName string) error {
delete(d.internal, schemaID)
// Remove from proto's schema list
- newSchemas := make([]*storepb.SchemaMetadata, 0, len(d.proto.Schemas)-1)
- for _, schema := range d.proto.Schemas {
+ newSchemas := make([]*storepb.SchemaMetadata, 0, len(d.metadata.Schemas)-1)
+ for _, schema := range d.metadata.Schemas {
if d.isObjectCaseSensitive {
if schema.Name != schemaName {
newSchemas = append(newSchemas, schema)
@@ -508,11 +402,91 @@ func (d *DatabaseMetadata) DropSchema(schemaName string) error {
}
}
}
- d.proto.Schemas = newSchemas
+ d.metadata.Schemas = newSchemas
return nil
}
+// Config methods (formerly from DatabaseConfig)
+func (d *DatabaseMetadata) GetSchemaConfig(name string) *SchemaConfig {
+ if d == nil {
+ return nil
+ }
+ if config := d.configInternal[name]; config != nil {
+ return config
+ }
+ return &SchemaConfig{
+ internal: make(map[string]*TableConfig),
+ }
+}
+
+func (d *DatabaseMetadata) BuildDatabaseConfig() *storepb.DatabaseConfig {
+ if d == nil {
+ return nil
+ }
+ config := &storepb.DatabaseConfig{Name: d.configName}
+
+ for schemaName, sConfig := range d.configInternal {
+ schemaConfig := &storepb.SchemaCatalog{Name: schemaName}
+
+ for tableName, tConfig := range sConfig.internal {
+ tableConfig := &storepb.TableCatalog{Name: tableName, Classification: tConfig.Classification}
+
+ for colName, colConfig := range tConfig.internal {
+ tableConfig.Columns = append(tableConfig.Columns, &storepb.ColumnCatalog{
+ Name: colName,
+ SemanticType: colConfig.SemanticType,
+ Labels: colConfig.Labels,
+ Classification: colConfig.Classification,
+ })
+ }
+ schemaConfig.Tables = append(schemaConfig.Tables, tableConfig)
+ }
+ config.Schemas = append(config.Schemas, schemaConfig)
+ }
+
+ return config
+}
+
+// SchemaConfig is the config for a schema.
+type SchemaConfig struct {
+ internal map[string]*TableConfig
+}
+
+// GetTableConfig gets the table config by name.
+// If not found, returns a new empty table config.
+func (s *SchemaConfig) GetTableConfig(name string) *TableConfig {
+ if s == nil {
+ return nil
+ }
+ if config := s.internal[name]; config != nil {
+ return config
+ }
+ return &TableConfig{
+ internal: make(map[string]*storepb.ColumnCatalog),
+ }
+}
+
+// TableConfig is the config for a table.
+type TableConfig struct {
+ Classification string
+ internal map[string]*storepb.ColumnCatalog
+}
+
+// GetColumnConfig gets the column config by name.
+// If not found, returns a new empty column config.
+func (t *TableConfig) GetColumnConfig(name string) *storepb.ColumnCatalog {
+ if t == nil {
+ return nil
+ }
+ if config := t.internal[name]; config != nil {
+ return config
+ }
+ return &storepb.ColumnCatalog{
+ Name: name,
+ }
+}
+
// LinkedDatabaseMetadata is the metadata for a linked database.
type LinkedDatabaseMetadata struct {
name string
diff --git a/backend/store/model/database_test.go b/backend/store/model/database_test.go
index 48f2bbfe78..c51baef8e5 100644
--- a/backend/store/model/database_test.go
+++ b/backend/store/model/database_test.go
@@ -103,9 +103,8 @@ func TestSchemaMetadata_CreateTable(t *testing.T) {
},
}
- schema := NewDatabaseSchema(metadata, nil, nil, storepb.Engine_POSTGRES, true)
- dbMeta := schema.GetDatabaseMetadata()
- schemaMeta := dbMeta.GetSchema("public")
+ schema := NewDatabaseMetadata(metadata, nil, nil, storepb.Engine_POSTGRES, true)
+ schemaMeta := schema.GetSchemaMetadata("public")
// Create a new table
tableMeta, err := schemaMeta.CreateTable("products")
@@ -133,9 +132,8 @@ func TestSchemaMetadata_CreateTable_AlreadyExists(t *testing.T) {
},
}
- schema := NewDatabaseSchema(metadata, nil, nil, storepb.Engine_POSTGRES, true)
- dbMeta := schema.GetDatabaseMetadata()
- schemaMeta := dbMeta.GetSchema("public")
+ schema := NewDatabaseMetadata(metadata, nil, nil, storepb.Engine_POSTGRES, true)
+ schemaMeta := schema.GetSchemaMetadata("public")
// Try to create table that already exists
_, err := schemaMeta.CreateTable("users")
@@ -158,9 +156,8 @@ func TestSchemaMetadata_DropTable(t *testing.T) {
},
}
- schema := NewDatabaseSchema(metadata, nil, nil, storepb.Engine_POSTGRES, true)
- dbMeta := schema.GetDatabaseMetadata()
- schemaMeta := dbMeta.GetSchema("public")
+ schema := NewDatabaseMetadata(metadata, nil, nil, storepb.Engine_POSTGRES, true)
+ schemaMeta := schema.GetSchemaMetadata("public")
// Drop table
err := schemaMeta.DropTable("users")
@@ -184,9 +181,8 @@ func TestSchemaMetadata_DropTable_NotExists(t *testing.T) {
},
}
- schema := NewDatabaseSchema(metadata, nil, nil, storepb.Engine_POSTGRES, true)
- dbMeta := schema.GetDatabaseMetadata()
- schemaMeta := dbMeta.GetSchema("public")
+ schema := NewDatabaseMetadata(metadata, nil, nil, storepb.Engine_POSTGRES, true)
+ schemaMeta := schema.GetSchemaMetadata("public")
// Try to drop non-existent table
err := schemaMeta.DropTable("nonexistent")
@@ -213,9 +209,8 @@ func TestTableMetadata_CreateColumn(t *testing.T) {
},
}
- schema := NewDatabaseSchema(metadata, nil, nil, storepb.Engine_POSTGRES, true)
- dbMeta := schema.GetDatabaseMetadata()
- schemaMeta := dbMeta.GetSchema("public")
+ schema := NewDatabaseMetadata(metadata, nil, nil, storepb.Engine_POSTGRES, true)
+ schemaMeta := schema.GetSchemaMetadata("public")
tableMeta := schemaMeta.GetTable("users")
// Create a new column
@@ -253,9 +248,8 @@ func TestTableMetadata_CreateColumn_AlreadyExists(t *testing.T) {
},
}
- schema := NewDatabaseSchema(metadata, nil, nil, storepb.Engine_POSTGRES, true)
- dbMeta := schema.GetDatabaseMetadata()
- schemaMeta := dbMeta.GetSchema("public")
+ schema := NewDatabaseMetadata(metadata, nil, nil, storepb.Engine_POSTGRES, true)
+ schemaMeta := schema.GetSchemaMetadata("public")
tableMeta := schemaMeta.GetTable("users")
// Try to create column that already exists
@@ -289,9 +283,8 @@ func TestTableMetadata_DropColumn(t *testing.T) {
},
}
- schema := NewDatabaseSchema(metadata, nil, nil, storepb.Engine_POSTGRES, true)
- dbMeta := schema.GetDatabaseMetadata()
- schemaMeta := dbMeta.GetSchema("public")
+ schema := NewDatabaseMetadata(metadata, nil, nil, storepb.Engine_POSTGRES, true)
+ schemaMeta := schema.GetSchemaMetadata("public")
tableMeta := schemaMeta.GetTable("users")
// Drop column
@@ -321,9 +314,8 @@ func TestTableMetadata_DropColumn_NotExists(t *testing.T) {
},
}
- schema := NewDatabaseSchema(metadata, nil, nil, storepb.Engine_POSTGRES, true)
- dbMeta := schema.GetDatabaseMetadata()
- schemaMeta := dbMeta.GetSchema("public")
+ schema := NewDatabaseMetadata(metadata, nil, nil, storepb.Engine_POSTGRES, true)
+ schemaMeta := schema.GetSchemaMetadata("public")
tableMeta := schemaMeta.GetTable("users")
// Try to drop non-existent column
diff --git a/backend/store/model/pg_searcher.go b/backend/store/model/pg_searcher.go
index 6ac5a0f48b..c31e137fd3 100644
--- a/backend/store/model/pg_searcher.go
+++ b/backend/store/model/pg_searcher.go
@@ -2,62 +2,6 @@ package model
import "strings"
-// isSystemPath checks if a path is a PostgreSQL system schema.
-// NOTE: This is primarily designed for PostgreSQL.
-func isSystemPath(path string) bool {
- // PostgreSQL system schemas.
- systemSchemas := []string{"pg_catalog", "information_schema", "pg_toast", "pg_temp_1", "pg_temp_2", "pg_global", "$user"}
- for _, schema := range systemSchemas {
- if strings.EqualFold(path, schema) {
- return true
- }
- }
- return false
-}
-
-// normalizeSearchPath normalizes the search path string into a slice of strings.
-// NOTE: This is primarily designed for PostgreSQL's search_path concept.
-func normalizeSearchPath(searchPath string) []string {
- if searchPath == "" {
- return []string{}
- }
-
- // Split the search path by comma and trim spaces.
- parts := strings.Split(searchPath, ",")
- for i, part := range parts {
- parts[i] = strings.TrimSpace(part)
- }
-
- // Remove empty parts.
- var result []string
- for _, part := range parts {
- schema := strings.TrimSpace(part)
- if part == "\"$user\"" {
- continue
- }
- if strings.HasPrefix(part, "\"") && strings.HasSuffix(part, "\"") {
- // Remove the quotes from the schema name.
- schema = strings.Trim(schema, "\"")
- } else if strings.HasPrefix(part, "'") && strings.HasSuffix(part, "'") {
- // Remove the single quotes from the schema name.
- schema = strings.Trim(schema, "'")
- } else {
- // For non-quoted schema names, we just return the lower string for PostgreSQL.
- schema = strings.ToLower(schema)
- }
- schema = strings.TrimSpace(schema)
- if isSystemPath(schema) {
- // Skip system schemas.
- continue
- }
- if schema != "" {
- result = append(result, schema)
- }
- }
-
- return result
-}
-
// DatabaseSearcher provides a fluent interface for searching database objects with a specific search path.
// This helper avoids repetitive searchPath parameter passing when performing multiple searches.
// NOTE: This is primarily designed for PostgreSQL's search_path concept.
@@ -71,7 +15,7 @@ type DatabaseSearcher struct {
// If the database's search path is empty, defaults to ["public"] for PostgreSQL.
// NOTE: This is primarily designed for PostgreSQL's search_path concept.
func (d *DatabaseMetadata) NewSearcher(schemaName string) *DatabaseSearcher {
- searchPath := d.searchPath
+ searchPath := d.GetSearchPath()
if schemaName != "" {
searchPath = []string{schemaName}
} else if len(searchPath) == 0 {
@@ -88,7 +32,7 @@ func (d *DatabaseMetadata) NewSearcher(schemaName string) *DatabaseSearcher {
// NOTE: This is primarily designed for PostgreSQL's search_path concept.
func (s *DatabaseSearcher) SearchTable(name string) (string, *TableMetadata) {
for _, schemaName := range s.searchPath {
- schema := s.db.GetSchema(schemaName)
+ schema := s.db.GetSchemaMetadata(schemaName)
if schema == nil {
continue
}
@@ -104,7 +48,7 @@ func (s *DatabaseSearcher) SearchTable(name string) (string, *TableMetadata) {
// NOTE: This is primarily designed for PostgreSQL's search_path concept.
func (s *DatabaseSearcher) SearchIndex(name string) (string, *IndexMetadata) {
for _, schemaName := range s.searchPath {
- schema := s.db.GetSchema(schemaName)
+ schema := s.db.GetSchemaMetadata(schemaName)
if schema == nil {
continue
}
@@ -120,7 +64,7 @@ func (s *DatabaseSearcher) SearchIndex(name string) (string, *IndexMetadata) {
// NOTE: This is primarily designed for PostgreSQL's search_path concept.
func (s *DatabaseSearcher) SearchView(name string) (string, *ViewMetadata) {
for _, schemaName := range s.searchPath {
- schema := s.db.GetSchema(schemaName)
+ schema := s.db.GetSchemaMetadata(schemaName)
if schema == nil {
continue
}
@@ -136,7 +80,7 @@ func (s *DatabaseSearcher) SearchView(name string) (string, *ViewMetadata) {
// NOTE: This is primarily designed for PostgreSQL's search_path concept.
func (s *DatabaseSearcher) SearchExternalTable(name string) (string, *ExternalTableMetadata) {
for _, schemaName := range s.searchPath {
- schema := s.db.GetSchema(schemaName)
+ schema := s.db.GetSchemaMetadata(schemaName)
if schema == nil {
continue
}
@@ -152,7 +96,7 @@ func (s *DatabaseSearcher) SearchExternalTable(name string) (string, *ExternalTa
// NOTE: This is primarily designed for PostgreSQL's search_path concept.
func (s *DatabaseSearcher) SearchSequence(name string) (string, *SequenceMetadata) {
for _, schemaName := range s.searchPath {
- schema := s.db.GetSchema(schemaName)
+ schema := s.db.GetSchemaMetadata(schemaName)
if schema == nil {
continue
}
@@ -168,7 +112,7 @@ func (s *DatabaseSearcher) SearchSequence(name string) (string, *SequenceMetadat
// NOTE: This is primarily designed for PostgreSQL's search_path concept.
func (s *DatabaseSearcher) SearchMaterializedView(name string) (string, *MaterializedViewMetadata) {
for _, schemaName := range s.searchPath {
- schema := s.db.GetSchema(schemaName)
+ schema := s.db.GetSchemaMetadata(schemaName)
if schema == nil {
continue
}
@@ -186,7 +130,7 @@ func (s *DatabaseSearcher) SearchFunctions(name string) ([]string, []*FunctionMe
var schemas []string
var funcs []*FunctionMetadata
for _, schemaName := range s.searchPath {
- schema := s.db.GetSchema(schemaName)
+ schema := s.db.GetSchemaMetadata(schemaName)
if schema == nil {
continue
}
@@ -211,7 +155,7 @@ func (s *DatabaseSearcher) SearchFunctions(name string) ([]string, []*FunctionMe
// NOTE: This is primarily designed for PostgreSQL's search_path concept.
func (s *DatabaseSearcher) SearchObject(name string) (string, string) {
for _, schemaName := range s.searchPath {
- schema := s.db.GetSchema(schemaName)
+ schema := s.db.GetSchemaMetadata(schemaName)
if schema == nil {
continue
}
@@ -226,7 +170,7 @@ func (s *DatabaseSearcher) SearchObject(name string) (string, string) {
// NOTE: This is primarily designed for PostgreSQL's search_path concept.
func (d *DatabaseMetadata) SearchTable(searchPath []string, name string) (string, *TableMetadata) {
for _, schemaName := range searchPath {
- schema := d.GetSchema(schemaName)
+ schema := d.GetSchemaMetadata(schemaName)
if schema == nil {
continue
}
@@ -242,7 +186,7 @@ func (d *DatabaseMetadata) SearchTable(searchPath []string, name string) (string
// NOTE: This is primarily designed for PostgreSQL's search_path concept.
func (d *DatabaseMetadata) SearchIndex(searchPath []string, name string) (string, *IndexMetadata) {
for _, schemaName := range searchPath {
- schema := d.GetSchema(schemaName)
+ schema := d.GetSchemaMetadata(schemaName)
if schema == nil {
continue
}
@@ -258,7 +202,7 @@ func (d *DatabaseMetadata) SearchIndex(searchPath []string, name string) (string
// NOTE: This is primarily designed for PostgreSQL's search_path concept.
func (d *DatabaseMetadata) SearchView(searchPath []string, name string) (string, *ViewMetadata) {
for _, schemaName := range searchPath {
- schema := d.GetSchema(schemaName)
+ schema := d.GetSchemaMetadata(schemaName)
if schema == nil {
continue
}
@@ -274,7 +218,7 @@ func (d *DatabaseMetadata) SearchView(searchPath []string, name string) (string,
// NOTE: This is primarily designed for PostgreSQL's search_path concept.
func (d *DatabaseMetadata) SearchExternalTable(searchPath []string, name string) (string, *ExternalTableMetadata) {
for _, schemaName := range searchPath {
- schema := d.GetSchema(schemaName)
+ schema := d.GetSchemaMetadata(schemaName)
if schema == nil {
continue
}
@@ -290,7 +234,7 @@ func (d *DatabaseMetadata) SearchExternalTable(searchPath []string, name string)
// NOTE: This is primarily designed for PostgreSQL's search_path concept.
func (d *DatabaseMetadata) SearchSequence(searchPath []string, name string) (string, *SequenceMetadata) {
for _, schemaName := range searchPath {
- schema := d.GetSchema(schemaName)
+ schema := d.GetSchemaMetadata(schemaName)
if schema == nil {
continue
}
@@ -306,7 +250,7 @@ func (d *DatabaseMetadata) SearchSequence(searchPath []string, name string) (str
// NOTE: This is primarily designed for PostgreSQL's search_path concept.
func (d *DatabaseMetadata) SearchMaterializedView(searchPath []string, name string) (string, *MaterializedViewMetadata) {
for _, schemaName := range searchPath {
- schema := d.GetSchema(schemaName)
+ schema := d.GetSchemaMetadata(schemaName)
if schema == nil {
continue
}
@@ -324,7 +268,7 @@ func (d *DatabaseMetadata) SearchFunctions(searchPath []string, name string) ([]
var schemas []string
var funcs []*FunctionMetadata
for _, schemaName := range searchPath {
- schema := d.GetSchema(schemaName)
+ schema := d.GetSchemaMetadata(schemaName)
if schema == nil {
continue
}
@@ -349,7 +293,7 @@ func (d *DatabaseMetadata) SearchFunctions(searchPath []string, name string) ([]
// NOTE: This is primarily designed for PostgreSQL's search_path concept.
func (d *DatabaseMetadata) SearchObject(searchPath []string, name string) (string, string) {
for _, schemaName := range searchPath {
- schema := d.GetSchema(schemaName)
+ schema := d.GetSchemaMetadata(schemaName)
if schema == nil {
continue
}
@@ -359,3 +303,59 @@ func (d *DatabaseMetadata) SearchObject(searchPath []string, name string) (strin
}
return "", ""
}
+
+// normalizeSearchPath normalizes the search path string into a slice of strings.
+// NOTE: This is primarily designed for PostgreSQL's search_path concept.
+func normalizeSearchPath(searchPath string) []string {
+ if searchPath == "" {
+ return []string{}
+ }
+
+ // Split the search path by comma and trim spaces.
+ parts := strings.Split(searchPath, ",")
+ for i, part := range parts {
+ parts[i] = strings.TrimSpace(part)
+ }
+
+ // Remove empty parts.
+ var result []string
+ for _, part := range parts {
+ schema := strings.TrimSpace(part)
+ if part == "\"$user\"" {
+ continue
+ }
+ if strings.HasPrefix(part, "\"") && strings.HasSuffix(part, "\"") {
+ // Remove the quotes from the schema name.
+ schema = strings.Trim(schema, "\"")
+ } else if strings.HasPrefix(part, "'") && strings.HasSuffix(part, "'") {
+ // Remove the single quotes from the schema name.
+ schema = strings.Trim(schema, "'")
+ } else {
+ // For non-quoted schema names, we just return the lower string for PostgreSQL.
+ schema = strings.ToLower(schema)
+ }
+ schema = strings.TrimSpace(schema)
+ if isSystemPath(schema) {
+ // Skip system schemas.
+ continue
+ }
+ if schema != "" {
+ result = append(result, schema)
+ }
+ }
+
+ return result
+}
+
+// isSystemPath checks if a path is a PostgreSQL system schema.
+// NOTE: This is primarily designed for PostgreSQL.
+func isSystemPath(path string) bool {
+ // PostgreSQL system schemas.
+ systemSchemas := []string{"pg_catalog", "information_schema", "pg_toast", "pg_temp_1", "pg_temp_2", "pg_global", "$user"}
+ for _, schema := range systemSchemas {
+ if strings.EqualFold(path, schema) {
+ return true
+ }
+ }
+ return false
+}
diff --git a/backend/store/store.go b/backend/store/store.go
index f06a7d639d..baff3497f9 100644
--- a/backend/store/store.go
+++ b/backend/store/store.go
@@ -38,7 +38,7 @@ type Store struct {
// Large objects.
sheetStatementCache *lru.Cache[int, string]
- dbSchemaCache *lru.Cache[string, *model.DatabaseSchema]
+ dbMetadataCache *lru.Cache[string, *model.DatabaseMetadata]
}
// New creates a new instance of Store.
@@ -108,7 +108,7 @@ func New(ctx context.Context, pgURL string, enableCache bool) (*Store, error) {
if err != nil {
return nil, err
}
- dbSchemaCache, err := lru.New[string, *model.DatabaseSchema](128)
+ dbMetadataCache, err := lru.New[string, *model.DatabaseMetadata](128)
if err != nil {
return nil, err
}
@@ -144,7 +144,7 @@ func New(ctx context.Context, pgURL string, enableCache bool) (*Store, error) {
rolesCache: rolesCache,
sheetCache: sheetCache,
sheetStatementCache: sheetStatementCache,
- dbSchemaCache: dbSchemaCache,
+ dbMetadataCache: dbMetadataCache,
groupCache: groupCache,
}