Database governance built for humans and agents — controlling changes and access across every major database.
Go cicddata-governancedata-maskingdata-securitydatabase-accessdatabase-governancedevopsdevsecopsflywaygitopsliquibasemongodbmysqloraclepostgresqlschema-migrationssecuritysql-clientsqlservertidb
refactor(v1): extract converter functions to dedicated files (#17769)
Danny Xu7071ea21807f
diff --git a/backend/api/v1/database_service.go b/backend/api/v1/database_service.goindex 8184334ff5..89431ebc3e 100644--- a/backend/api/v1/database_service.go+++ b/backend/api/v1/database_service.go@@ -22,7 +22,6 @@ import (v1pb "github.com/bytebase/bytebase/backend/generated-go/v1""github.com/bytebase/bytebase/backend/generated-go/v1/v1connect"parserbase "github.com/bytebase/bytebase/backend/plugin/parser/base"- "github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/transform""github.com/bytebase/bytebase/backend/plugin/schema""github.com/bytebase/bytebase/backend/runner/schemasync""github.com/bytebase/bytebase/backend/store"@@ -866,29 +865,7 @@ func (s *DatabaseService) GetDatabaseSchema(ctx context.Context, req *connect.Re}dbSchema = newDBSchema}- // We only support MySQL engine for now.schemaString := string(dbSchema.GetSchema())- if req.Msg.SdlFormat {- switch instance.Metadata.GetEngine() {- case storepb.Engine_MYSQL, storepb.Engine_TIDB, storepb.Engine_MARIADB, storepb.Engine_OCEANBASE:- sdlSchema, err := transform.SchemaTransform(storepb.Engine_MYSQL, schemaString)- if err != nil {- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to convert schema to sdl format, error %v", err.Error()))- }- schemaString = sdlSchema- case storepb.Engine_POSTGRES:- // Use the new SDL format for PostgreSQL- sdlSchema, err := schema.GetDatabaseDefinition(instance.Metadata.GetEngine(), schema.GetDefinitionContext{- SkipBackupSchema: true,- SDLFormat: true,- }, dbSchema.GetMetadata())- if err != nil {- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to convert PostgreSQL schema to SDL format, error %v", err.Error()))- }- schemaString = sdlSchema- default:- }- }return connect.NewResponse(&v1pb.DatabaseSchema{Schema: schemaString}), nil}@@ -1146,9 +1123,8 @@ func (s *DatabaseService) getSourceSchema(ctx context.Context, request *v1pb.Difif strings.Contains(request.Name, common.ChangelogPrefix) {changeHistory, err := s.GetChangelog(ctx, &connect.Request[v1pb.GetChangelogRequest]{Msg: &v1pb.GetChangelogRequest{- Name: request.Name,- View: v1pb.ChangelogView_CHANGELOG_VIEW_FULL,- SdlFormat: true,+ Name: request.Name,+ View: v1pb.ChangelogView_CHANGELOG_VIEW_FULL,},})if err != nil {@@ -1159,8 +1135,7 @@ func (s *DatabaseService) getSourceSchema(ctx context.Context, request *v1pb.DifdatabaseSchema, err := s.GetDatabaseSchema(ctx, &connect.Request[v1pb.GetDatabaseSchemaRequest]{Msg: &v1pb.GetDatabaseSchemaRequest{- Name: fmt.Sprintf("%s/schema", request.Name),- SdlFormat: request.SdlFormat,+ Name: fmt.Sprintf("%s/schema", request.Name),},})if err != nil {@@ -1181,9 +1156,8 @@ func (s *DatabaseService) getTargetSchema(ctx context.Context, request *v1pb.Difif changeHistoryID != "" {changeHistory, err := s.GetChangelog(ctx, &connect.Request[v1pb.GetChangelogRequest]{Msg: &v1pb.GetChangelogRequest{- Name: changeHistoryID,- View: v1pb.ChangelogView_CHANGELOG_VIEW_FULL,- SdlFormat: true,+ Name: changeHistoryID,+ View: v1pb.ChangelogView_CHANGELOG_VIEW_FULL,},})if err != nil {diff --git a/backend/api/v1/database_service_changelog.go b/backend/api/v1/database_service_changelog.goindex 56756c3573..8f010e6ce1 100644--- a/backend/api/v1/database_service_changelog.go+++ b/backend/api/v1/database_service_changelog.go@@ -12,7 +12,6 @@ import ("github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store"v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"- "github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/transform""github.com/bytebase/bytebase/backend/store")@@ -129,24 +128,6 @@ func (s *DatabaseService) GetChangelog(ctx context.Context, req *connect.Request}converted := s.convertToChangelog(database, changelog)- if req.Msg.SdlFormat {- switch instance.Metadata.GetEngine() {- case storepb.Engine_MYSQL, storepb.Engine_TIDB, storepb.Engine_MARIADB, storepb.Engine_OCEANBASE:- sdlSchema, err := transform.SchemaTransform(storepb.Engine_MYSQL, converted.Schema)- if err != nil {- return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to convert schema to sdl format"))- }- converted.Schema = sdlSchema- converted.SchemaSize = int64(len(sdlSchema))- sdlSchema, err = transform.SchemaTransform(storepb.Engine_MYSQL, converted.PrevSchema)- if err != nil {- return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to convert previous schema to sdl format"))- }- converted.PrevSchema = sdlSchema- converted.PrevSchemaSize = int64(len(sdlSchema))- default:- }- }return connect.NewResponse(converted), nil}diff --git a/backend/api/v1/instance_service.go b/backend/api/v1/instance_service.goindex a2fd80c550..5d1092371b 100644--- a/backend/api/v1/instance_service.go+++ b/backend/api/v1/instance_service.go@@ -1148,518 +1148,6 @@ func buildEnvironmentName(environmentID *string) *string {return &result}-func convertInstanceMessage(instance *store.InstanceMessage) *v1pb.Instance {- engine := convertToEngine(instance.Metadata.GetEngine())- dataSources := convertDataSources(instance.Metadata.GetDataSources())-- return &v1pb.Instance{- Name: buildInstanceName(instance.ResourceID),- Title: instance.Metadata.GetTitle(),- Engine: engine,- EngineVersion: instance.Metadata.GetVersion(),- ExternalLink: instance.Metadata.GetExternalLink(),- DataSources: dataSources,- State: convertDeletedToState(instance.Deleted),- Environment: buildEnvironmentName(instance.EnvironmentID),- Activation: instance.Metadata.GetActivation(),- SyncInterval: instance.Metadata.GetSyncInterval(),- MaximumConnections: instance.Metadata.GetMaximumConnections(),- SyncDatabases: instance.Metadata.GetSyncDatabases(),- Roles: convertInstanceRoles(instance, instance.Metadata.GetRoles()),- LastSyncTime: instance.Metadata.GetLastSyncTime(),- Labels: instance.Metadata.GetLabels(),- }-}--// buildRoleName builds the role name with the given instance ID and role name.-func buildRoleName(b *strings.Builder, instanceID, roleName string) string {- b.Reset()- _, _ = b.WriteString(common.InstanceNamePrefix)- _, _ = b.WriteString(instanceID)- _, _ = b.WriteString("/")- _, _ = b.WriteString(common.RolePrefix)- _, _ = b.WriteString(roleName)- return b.String()-}--func convertInstanceRoles(instance *store.InstanceMessage, roles []*storepb.InstanceRole) []*v1pb.InstanceRole {- var v1Roles []*v1pb.InstanceRole- var b strings.Builder-- // preallocate memory for the builder- b.Grow(len(common.InstanceNamePrefix) + len(instance.ResourceID) + 1 + len(common.RolePrefix) + 20)-- for _, role := range roles {- v1Roles = append(v1Roles, &v1pb.InstanceRole{- Name: buildRoleName(&b, instance.ResourceID, role.Name),- RoleName: role.Name,- Attribute: role.Attribute,- })- }- return v1Roles-}--func convertInstanceToInstanceMessage(instanceID string, instance *v1pb.Instance) (*store.InstanceMessage, error) {- datasources, err := convertV1DataSources(instance.DataSources)- if err != nil {- return nil, err- }-- var environmentID *string- if instance.Environment != nil && *instance.Environment != "" {- envID, err := common.GetEnvironmentID(*instance.Environment)- if err != nil {- return nil, err- }- environmentID = &envID- }-- return &store.InstanceMessage{- ResourceID: instanceID,- EnvironmentID: environmentID,- Metadata: &storepb.Instance{- Title: instance.GetTitle(),- Engine: convertEngine(instance.Engine),- ExternalLink: instance.GetExternalLink(),- Activation: instance.GetActivation(),- DataSources: datasources,- SyncInterval: instance.GetSyncInterval(),- MaximumConnections: instance.GetMaximumConnections(),- SyncDatabases: instance.GetSyncDatabases(),- Labels: instance.GetLabels(),- },- }, nil-}--func convertInstanceMessageToInstanceResource(instanceMessage *store.InstanceMessage) *v1pb.InstanceResource {- instance := convertInstanceMessage(instanceMessage)- return &v1pb.InstanceResource{- Name: instance.Name,- Title: instance.Title,- Engine: instance.Engine,- EngineVersion: instance.EngineVersion,- DataSources: instance.DataSources,- Activation: instance.Activation,- Environment: instance.Environment,- }-}--func convertV1DataSources(dataSources []*v1pb.DataSource) ([]*storepb.DataSource, error) {- var values []*storepb.DataSource- for _, ds := range dataSources {- dataSource, err := convertV1DataSource(ds)- if err != nil {- return nil, err- }- values = append(values, dataSource)- }-- return values, nil-}--func convertDataSourceExternalSecret(externalSecret *storepb.DataSourceExternalSecret) *v1pb.DataSourceExternalSecret {- if externalSecret == nil {- return nil- }-- resp := &v1pb.DataSourceExternalSecret{- SecretType: v1pb.DataSourceExternalSecret_SecretType(externalSecret.SecretType),- Url: externalSecret.Url,- AuthType: v1pb.DataSourceExternalSecret_AuthType(externalSecret.AuthType),- EngineName: externalSecret.EngineName,- SecretName: externalSecret.SecretName,- PasswordKeyName: externalSecret.PasswordKeyName,- }-- // clear sensitive data.- switch resp.AuthType {- case v1pb.DataSourceExternalSecret_VAULT_APP_ROLE:- appRole := externalSecret.GetAppRole()- if appRole != nil {- resp.AuthOption = &v1pb.DataSourceExternalSecret_AppRole{- AppRole: &v1pb.DataSourceExternalSecret_AppRoleAuthOption{- Type: v1pb.DataSourceExternalSecret_AppRoleAuthOption_SecretType(appRole.Type),- MountPath: appRole.MountPath,- },- }- }- case v1pb.DataSourceExternalSecret_TOKEN:- resp.AuthOption = &v1pb.DataSourceExternalSecret_Token{- Token: "",- }- default:- }-- return resp-}--func convertDataSources(dataSources []*storepb.DataSource) []*v1pb.DataSource {- var v1DataSources []*v1pb.DataSource- for _, ds := range dataSources {- externalSecret := convertDataSourceExternalSecret(ds.GetExternalSecret())-- dataSourceType := v1pb.DataSourceType_DATA_SOURCE_UNSPECIFIED- switch ds.GetType() {- case storepb.DataSourceType_ADMIN:- dataSourceType = v1pb.DataSourceType_ADMIN- case storepb.DataSourceType_READ_ONLY:- dataSourceType = v1pb.DataSourceType_READ_ONLY- default:- }-- authenticationType := v1pb.DataSource_AUTHENTICATION_UNSPECIFIED- switch ds.GetAuthenticationType() {- case storepb.DataSource_AUTHENTICATION_UNSPECIFIED, storepb.DataSource_PASSWORD:- authenticationType = v1pb.DataSource_PASSWORD- case storepb.DataSource_GOOGLE_CLOUD_SQL_IAM:- authenticationType = v1pb.DataSource_GOOGLE_CLOUD_SQL_IAM- case storepb.DataSource_AWS_RDS_IAM:- authenticationType = v1pb.DataSource_AWS_RDS_IAM- case storepb.DataSource_AZURE_IAM:- authenticationType = v1pb.DataSource_AZURE_IAM- default:- }-- dataSource := &v1pb.DataSource{- Id: ds.GetId(),- Type: dataSourceType,- Username: ds.GetUsername(),- // We don't return the password and SSLs on reads.- Host: ds.GetHost(),- Port: ds.GetPort(),- Database: ds.GetDatabase(),- Srv: ds.GetSrv(),- AuthenticationDatabase: ds.GetAuthenticationDatabase(),- Sid: ds.GetSid(),- ServiceName: ds.GetServiceName(),- SshHost: ds.GetSshHost(),- SshPort: ds.GetSshPort(),- SshUser: ds.GetSshUser(),- ExternalSecret: externalSecret,- AuthenticationType: authenticationType,- SaslConfig: convertDataSourceSaslConfig(ds.GetSaslConfig()),- AdditionalAddresses: convertDataSourceAddresses(ds.GetAdditionalAddresses()),- ReplicaSet: ds.GetReplicaSet(),- DirectConnection: ds.GetDirectConnection(),- Region: ds.GetRegion(),- WarehouseId: ds.GetWarehouseId(),- UseSsl: ds.GetUseSsl(),- VerifyTlsCertificate: ds.GetVerifyTlsCertificate(),- RedisType: convertRedisType(ds.GetRedisType()),- MasterName: ds.GetMasterName(),- MasterUsername: ds.GetMasterUsername(),- ExtraConnectionParameters: ds.GetExtraConnectionParameters(),- }-- switch dataSource.AuthenticationType {- case v1pb.DataSource_AZURE_IAM:- if azureCredential := ds.GetAzureCredential(); azureCredential != nil {- dataSource.IamExtension = &v1pb.DataSource_AzureCredential_{- AzureCredential: &v1pb.DataSource_AzureCredential{- TenantId: azureCredential.TenantId,- ClientId: azureCredential.ClientId,- },- }- }- case v1pb.DataSource_AWS_RDS_IAM:- if awsCredential := ds.GetAwsCredential(); awsCredential != nil {- dataSource.IamExtension = &v1pb.DataSource_AwsCredential{- AwsCredential: &v1pb.DataSource_AWSCredential{},- }- }- case v1pb.DataSource_GOOGLE_CLOUD_SQL_IAM:- if gcpCredential := ds.GetGcpCredential(); gcpCredential != nil {- dataSource.IamExtension = &v1pb.DataSource_GcpCredential{- GcpCredential: &v1pb.DataSource_GCPCredential{},- }- }- default:- }-- v1DataSources = append(v1DataSources, dataSource)- }-- return v1DataSources-}--func convertV1DataSourceExternalSecret(externalSecret *v1pb.DataSourceExternalSecret) (*storepb.DataSourceExternalSecret, error) {- if externalSecret == nil {- return nil, nil- }-- secret := &storepb.DataSourceExternalSecret{- SecretType: storepb.DataSourceExternalSecret_SecretType(externalSecret.SecretType),- Url: externalSecret.Url,- AuthType: storepb.DataSourceExternalSecret_AuthType(externalSecret.AuthType),- EngineName: externalSecret.EngineName,- SecretName: externalSecret.SecretName,- PasswordKeyName: externalSecret.PasswordKeyName,- }-- // Convert auth options- switch externalSecret.AuthOption.(type) {- case *v1pb.DataSourceExternalSecret_Token:- secret.AuthOption = &storepb.DataSourceExternalSecret_Token{- Token: externalSecret.GetToken(),- }- case *v1pb.DataSourceExternalSecret_AppRole:- appRole := externalSecret.GetAppRole()- if appRole != nil {- secret.AuthOption = &storepb.DataSourceExternalSecret_AppRole{- AppRole: &storepb.DataSourceExternalSecret_AppRoleAuthOption{- Type: storepb.DataSourceExternalSecret_AppRoleAuthOption_SecretType(appRole.Type),- MountPath: appRole.MountPath,- },- }- }- }-- switch secret.SecretType {- case storepb.DataSourceExternalSecret_VAULT_KV_V2:- if secret.Url == "" {- return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("missing Vault URL"))- }- if secret.EngineName == "" {- return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("missing Vault engine name"))- }- if secret.SecretName == "" || secret.PasswordKeyName == "" {- return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("missing secret name or key name"))- }- case storepb.DataSourceExternalSecret_AWS_SECRETS_MANAGER:- if secret.SecretName == "" || secret.PasswordKeyName == "" {- return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("missing secret name or key name"))- }- case storepb.DataSourceExternalSecret_GCP_SECRET_MANAGER:- if secret.SecretName == "" {- return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("missing GCP secret name"))- }- default:- }-- switch secret.AuthType {- case storepb.DataSourceExternalSecret_TOKEN:- if secret.GetToken() == "" {- return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("missing token"))- }- case storepb.DataSourceExternalSecret_VAULT_APP_ROLE:- if secret.GetAppRole() == nil {- return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("missing Vault approle"))- }- default:- }-- return secret, nil-}--func convertV1DataSourceSaslConfig(saslConfig *v1pb.SASLConfig) *storepb.SASLConfig {- if saslConfig == nil {- return nil- }- storeSaslConfig := &storepb.SASLConfig{}- switch m := saslConfig.Mechanism.(type) {- case *v1pb.SASLConfig_KrbConfig:- storeSaslConfig.Mechanism = &storepb.SASLConfig_KrbConfig{- KrbConfig: &storepb.KerberosConfig{- Primary: m.KrbConfig.Primary,- Instance: m.KrbConfig.Instance,- Realm: m.KrbConfig.Realm,- Keytab: m.KrbConfig.Keytab,- KdcHost: m.KrbConfig.KdcHost,- KdcPort: m.KrbConfig.KdcPort,- KdcTransportProtocol: m.KrbConfig.KdcTransportProtocol,- },- }- default:- return nil- }- return storeSaslConfig-}--func convertDataSourceSaslConfig(saslConfig *storepb.SASLConfig) *v1pb.SASLConfig {- if saslConfig == nil {- return nil- }- storeSaslConfig := &v1pb.SASLConfig{}- switch m := saslConfig.Mechanism.(type) {- case *storepb.SASLConfig_KrbConfig:- storeSaslConfig.Mechanism = &v1pb.SASLConfig_KrbConfig{- KrbConfig: &v1pb.KerberosConfig{- Primary: m.KrbConfig.Primary,- Instance: m.KrbConfig.Instance,- Realm: m.KrbConfig.Realm,- Keytab: m.KrbConfig.Keytab,- KdcHost: m.KrbConfig.KdcHost,- KdcPort: m.KrbConfig.KdcPort,- KdcTransportProtocol: m.KrbConfig.KdcTransportProtocol,- },- }- default:- return nil- }- return storeSaslConfig-}--func convertDataSourceAddresses(addresses []*storepb.DataSource_Address) []*v1pb.DataSource_Address {- res := make([]*v1pb.DataSource_Address, 0, len(addresses))- for _, address := range addresses {- res = append(res, &v1pb.DataSource_Address{- Host: address.Host,- Port: address.Port,- })- }- return res-}--func convertAdditionalAddresses(addresses []*v1pb.DataSource_Address) []*storepb.DataSource_Address {- res := make([]*storepb.DataSource_Address, 0, len(addresses))- for _, address := range addresses {- res = append(res, &storepb.DataSource_Address{- Host: address.Host,- Port: address.Port,- })- }- return res-}--func convertV1AuthenticationType(authType v1pb.DataSource_AuthenticationType) storepb.DataSource_AuthenticationType {- authenticationType := storepb.DataSource_AUTHENTICATION_UNSPECIFIED- switch authType {- case v1pb.DataSource_AUTHENTICATION_UNSPECIFIED, v1pb.DataSource_PASSWORD:- authenticationType = storepb.DataSource_PASSWORD- case v1pb.DataSource_GOOGLE_CLOUD_SQL_IAM:- authenticationType = storepb.DataSource_GOOGLE_CLOUD_SQL_IAM- case v1pb.DataSource_AWS_RDS_IAM:- authenticationType = storepb.DataSource_AWS_RDS_IAM- case v1pb.DataSource_AZURE_IAM:- authenticationType = storepb.DataSource_AZURE_IAM- default:- }- return authenticationType-}--func convertV1RedisType(redisType v1pb.DataSource_RedisType) storepb.DataSource_RedisType {- authenticationType := storepb.DataSource_REDIS_TYPE_UNSPECIFIED- switch redisType {- case v1pb.DataSource_STANDALONE:- authenticationType = storepb.DataSource_STANDALONE- case v1pb.DataSource_SENTINEL:- authenticationType = storepb.DataSource_SENTINEL- case v1pb.DataSource_CLUSTER:- authenticationType = storepb.DataSource_CLUSTER- default:- }- return authenticationType-}--func convertRedisType(redisType storepb.DataSource_RedisType) v1pb.DataSource_RedisType {- authenticationType := v1pb.DataSource_STANDALONE- switch redisType {- case storepb.DataSource_STANDALONE:- authenticationType = v1pb.DataSource_STANDALONE- case storepb.DataSource_SENTINEL:- authenticationType = v1pb.DataSource_SENTINEL- case storepb.DataSource_CLUSTER:- authenticationType = v1pb.DataSource_CLUSTER- default:- }- return authenticationType-}--func convertV1DataSource(dataSource *v1pb.DataSource) (*storepb.DataSource, error) {- dsType, err := convertV1DataSourceType(dataSource.Type)- if err != nil {- return nil, err- }- externalSecret, err := convertV1DataSourceExternalSecret(dataSource.ExternalSecret)- if err != nil {- return nil, err- }- saslConfig := convertV1DataSourceSaslConfig(dataSource.SaslConfig)-- storeDataSource := &storepb.DataSource{- Id: dataSource.Id,- Type: dsType,- Username: dataSource.Username,- Password: dataSource.Password,- SslCa: dataSource.SslCa,- SslCert: dataSource.SslCert,- SslKey: dataSource.SslKey,- Host: dataSource.Host,- Port: dataSource.Port,- Database: dataSource.Database,- Srv: dataSource.Srv,- AuthenticationDatabase: dataSource.AuthenticationDatabase,- Sid: dataSource.Sid,- ServiceName: dataSource.ServiceName,- SshHost: dataSource.SshHost,- SshPort: dataSource.SshPort,- SshUser: dataSource.SshUser,- SshPassword: dataSource.SshPassword,- SshPrivateKey: dataSource.SshPrivateKey,- AuthenticationPrivateKey: dataSource.AuthenticationPrivateKey,- ExternalSecret: externalSecret,- SaslConfig: saslConfig,- AuthenticationType: convertV1AuthenticationType(dataSource.AuthenticationType),- AdditionalAddresses: convertAdditionalAddresses(dataSource.AdditionalAddresses),- ReplicaSet: dataSource.ReplicaSet,- DirectConnection: dataSource.DirectConnection,- Region: dataSource.Region,- WarehouseId: dataSource.WarehouseId,- UseSsl: dataSource.UseSsl,- VerifyTlsCertificate: dataSource.VerifyTlsCertificate,- RedisType: convertV1RedisType(dataSource.RedisType),- MasterName: dataSource.MasterName,- MasterUsername: dataSource.MasterUsername,- MasterPassword: dataSource.MasterPassword,- ExtraConnectionParameters: dataSource.ExtraConnectionParameters,- }-- switch dataSource.AuthenticationType {- case v1pb.DataSource_AZURE_IAM:- if azureCredential := dataSource.GetAzureCredential(); azureCredential != nil {- storeDataSource.IamExtension = &storepb.DataSource_AzureCredential_{- AzureCredential: &storepb.DataSource_AzureCredential{- TenantId: azureCredential.TenantId,- ClientId: azureCredential.ClientId,- ClientSecret: azureCredential.ClientSecret,- },- }- }- case v1pb.DataSource_AWS_RDS_IAM:- if awsCredential := dataSource.GetAwsCredential(); awsCredential != nil {- storeDataSource.IamExtension = &storepb.DataSource_AwsCredential{- AwsCredential: &storepb.DataSource_AWSCredential{- AccessKeyId: awsCredential.AccessKeyId,- SecretAccessKey: awsCredential.SecretAccessKey,- SessionToken: awsCredential.SessionToken,- },- }- }- case v1pb.DataSource_GOOGLE_CLOUD_SQL_IAM:- if gcpCredential := dataSource.GetGcpCredential(); gcpCredential != nil {- storeDataSource.IamExtension = &storepb.DataSource_GcpCredential{- GcpCredential: &storepb.DataSource_GCPCredential{- Content: gcpCredential.Content,- },- }- }- default:- }-- return storeDataSource, nil-}--func convertV1DataSourceType(tp v1pb.DataSourceType) (storepb.DataSourceType, error) {- switch tp {- case v1pb.DataSourceType_READ_ONLY:- return storepb.DataSourceType_READ_ONLY, nil- case v1pb.DataSourceType_ADMIN:- return storepb.DataSourceType_ADMIN, nil- default:- return storepb.DataSourceType_DATA_SOURCE_UNSPECIFIED, errors.Errorf("invalid data source type %v", tp)- }-}-func (s *InstanceService) instanceCountGuard(ctx context.Context) error {instanceLimit := s.licenseService.GetInstanceLimit(ctx)diff --git a/backend/api/v1/instance_service_converter.go b/backend/api/v1/instance_service_converter.gonew file mode 100644index 0000000000..396cd2ded3--- /dev/null+++ b/backend/api/v1/instance_service_converter.go@@ -0,0 +1,525 @@+package v1++import (+ "strings"++ "connectrpc.com/connect"+ "github.com/pkg/errors"++ "github.com/bytebase/bytebase/backend/common"+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"+ "github.com/bytebase/bytebase/backend/store"+)++func convertInstanceMessage(instance *store.InstanceMessage) *v1pb.Instance {+ engine := convertToEngine(instance.Metadata.GetEngine())+ dataSources := convertDataSources(instance.Metadata.GetDataSources())++ return &v1pb.Instance{+ Name: buildInstanceName(instance.ResourceID),+ Title: instance.Metadata.GetTitle(),+ Engine: engine,+ EngineVersion: instance.Metadata.GetVersion(),+ ExternalLink: instance.Metadata.GetExternalLink(),+ DataSources: dataSources,+ State: convertDeletedToState(instance.Deleted),+ Environment: buildEnvironmentName(instance.EnvironmentID),+ Activation: instance.Metadata.GetActivation(),+ SyncInterval: instance.Metadata.GetSyncInterval(),+ MaximumConnections: instance.Metadata.GetMaximumConnections(),+ SyncDatabases: instance.Metadata.GetSyncDatabases(),+ Roles: convertInstanceRoles(instance, instance.Metadata.GetRoles()),+ LastSyncTime: instance.Metadata.GetLastSyncTime(),+ Labels: instance.Metadata.GetLabels(),+ }+}++// buildRoleName builds the role name with the given instance ID and role name.+func buildRoleName(b *strings.Builder, instanceID, roleName string) string {+ b.Reset()+ _, _ = b.WriteString(common.InstanceNamePrefix)+ _, _ = b.WriteString(instanceID)+ _, _ = b.WriteString("/")+ _, _ = b.WriteString(common.RolePrefix)+ _, _ = b.WriteString(roleName)+ return b.String()+}++func convertInstanceRoles(instance *store.InstanceMessage, roles []*storepb.InstanceRole) []*v1pb.InstanceRole {+ var v1Roles []*v1pb.InstanceRole+ var b strings.Builder++ // preallocate memory for the builder+ b.Grow(len(common.InstanceNamePrefix) + len(instance.ResourceID) + 1 + len(common.RolePrefix) + 20)++ for _, role := range roles {+ v1Roles = append(v1Roles, &v1pb.InstanceRole{+ Name: buildRoleName(&b, instance.ResourceID, role.Name),+ RoleName: role.Name,+ Attribute: role.Attribute,+ })+ }+ return v1Roles+}++func convertInstanceToInstanceMessage(instanceID string, instance *v1pb.Instance) (*store.InstanceMessage, error) {+ datasources, err := convertV1DataSources(instance.DataSources)+ if err != nil {+ return nil, err+ }++ var environmentID *string+ if instance.Environment != nil && *instance.Environment != "" {+ envID, err := common.GetEnvironmentID(*instance.Environment)+ if err != nil {+ return nil, err+ }+ environmentID = &envID+ }++ return &store.InstanceMessage{+ ResourceID: instanceID,+ EnvironmentID: environmentID,+ Metadata: &storepb.Instance{+ Title: instance.GetTitle(),+ Engine: convertEngine(instance.Engine),+ ExternalLink: instance.GetExternalLink(),+ Activation: instance.GetActivation(),+ DataSources: datasources,+ SyncInterval: instance.GetSyncInterval(),+ MaximumConnections: instance.GetMaximumConnections(),+ SyncDatabases: instance.GetSyncDatabases(),+ Labels: instance.GetLabels(),+ },+ }, nil+}++func convertInstanceMessageToInstanceResource(instanceMessage *store.InstanceMessage) *v1pb.InstanceResource {+ instance := convertInstanceMessage(instanceMessage)+ return &v1pb.InstanceResource{+ Name: instance.Name,+ Title: instance.Title,+ Engine: instance.Engine,+ EngineVersion: instance.EngineVersion,+ DataSources: instance.DataSources,+ Activation: instance.Activation,+ Environment: instance.Environment,+ }+}++func convertV1DataSources(dataSources []*v1pb.DataSource) ([]*storepb.DataSource, error) {+ var values []*storepb.DataSource+ for _, ds := range dataSources {+ dataSource, err := convertV1DataSource(ds)+ if err != nil {+ return nil, err+ }+ values = append(values, dataSource)+ }++ return values, nil+}++func convertDataSourceExternalSecret(externalSecret *storepb.DataSourceExternalSecret) *v1pb.DataSourceExternalSecret {+ if externalSecret == nil {+ return nil+ }++ resp := &v1pb.DataSourceExternalSecret{+ SecretType: v1pb.DataSourceExternalSecret_SecretType(externalSecret.SecretType),+ Url: externalSecret.Url,+ AuthType: v1pb.DataSourceExternalSecret_AuthType(externalSecret.AuthType),+ EngineName: externalSecret.EngineName,+ SecretName: externalSecret.SecretName,+ PasswordKeyName: externalSecret.PasswordKeyName,+ }++ // clear sensitive data.+ switch resp.AuthType {+ case v1pb.DataSourceExternalSecret_VAULT_APP_ROLE:+ appRole := externalSecret.GetAppRole()+ if appRole != nil {+ resp.AuthOption = &v1pb.DataSourceExternalSecret_AppRole{+ AppRole: &v1pb.DataSourceExternalSecret_AppRoleAuthOption{+ Type: v1pb.DataSourceExternalSecret_AppRoleAuthOption_SecretType(appRole.Type),+ MountPath: appRole.MountPath,+ },+ }+ }+ case v1pb.DataSourceExternalSecret_TOKEN:+ resp.AuthOption = &v1pb.DataSourceExternalSecret_Token{+ Token: "",+ }+ default:+ }++ return resp+}++func convertDataSources(dataSources []*storepb.DataSource) []*v1pb.DataSource {+ var v1DataSources []*v1pb.DataSource+ for _, ds := range dataSources {+ externalSecret := convertDataSourceExternalSecret(ds.GetExternalSecret())++ dataSourceType := v1pb.DataSourceType_DATA_SOURCE_UNSPECIFIED+ switch ds.GetType() {+ case storepb.DataSourceType_ADMIN:+ dataSourceType = v1pb.DataSourceType_ADMIN+ case storepb.DataSourceType_READ_ONLY:+ dataSourceType = v1pb.DataSourceType_READ_ONLY+ default:+ }++ authenticationType := v1pb.DataSource_AUTHENTICATION_UNSPECIFIED+ switch ds.GetAuthenticationType() {+ case storepb.DataSource_AUTHENTICATION_UNSPECIFIED, storepb.DataSource_PASSWORD:+ authenticationType = v1pb.DataSource_PASSWORD+ case storepb.DataSource_GOOGLE_CLOUD_SQL_IAM:+ authenticationType = v1pb.DataSource_GOOGLE_CLOUD_SQL_IAM+ case storepb.DataSource_AWS_RDS_IAM:+ authenticationType = v1pb.DataSource_AWS_RDS_IAM+ case storepb.DataSource_AZURE_IAM:+ authenticationType = v1pb.DataSource_AZURE_IAM+ default:+ }++ dataSource := &v1pb.DataSource{+ Id: ds.GetId(),+ Type: dataSourceType,+ Username: ds.GetUsername(),+ // We don't return the password and SSLs on reads.+ Host: ds.GetHost(),+ Port: ds.GetPort(),+ Database: ds.GetDatabase(),+ Srv: ds.GetSrv(),+ AuthenticationDatabase: ds.GetAuthenticationDatabase(),+ Sid: ds.GetSid(),+ ServiceName: ds.GetServiceName(),+ SshHost: ds.GetSshHost(),+ SshPort: ds.GetSshPort(),+ SshUser: ds.GetSshUser(),+ ExternalSecret: externalSecret,+ AuthenticationType: authenticationType,+ SaslConfig: convertDataSourceSaslConfig(ds.GetSaslConfig()),+ AdditionalAddresses: convertDataSourceAddresses(ds.GetAdditionalAddresses()),+ ReplicaSet: ds.GetReplicaSet(),+ DirectConnection: ds.GetDirectConnection(),+ Region: ds.GetRegion(),+ WarehouseId: ds.GetWarehouseId(),+ UseSsl: ds.GetUseSsl(),+ VerifyTlsCertificate: ds.GetVerifyTlsCertificate(),+ RedisType: convertRedisType(ds.GetRedisType()),+ MasterName: ds.GetMasterName(),+ MasterUsername: ds.GetMasterUsername(),+ ExtraConnectionParameters: ds.GetExtraConnectionParameters(),+ }++ switch dataSource.AuthenticationType {+ case v1pb.DataSource_AZURE_IAM:+ if azureCredential := ds.GetAzureCredential(); azureCredential != nil {+ dataSource.IamExtension = &v1pb.DataSource_AzureCredential_{+ AzureCredential: &v1pb.DataSource_AzureCredential{+ TenantId: azureCredential.TenantId,+ ClientId: azureCredential.ClientId,+ },+ }+ }+ case v1pb.DataSource_AWS_RDS_IAM:+ if awsCredential := ds.GetAwsCredential(); awsCredential != nil {+ dataSource.IamExtension = &v1pb.DataSource_AwsCredential{+ AwsCredential: &v1pb.DataSource_AWSCredential{},+ }+ }+ case v1pb.DataSource_GOOGLE_CLOUD_SQL_IAM:+ if gcpCredential := ds.GetGcpCredential(); gcpCredential != nil {+ dataSource.IamExtension = &v1pb.DataSource_GcpCredential{+ GcpCredential: &v1pb.DataSource_GCPCredential{},+ }+ }+ default:+ }++ v1DataSources = append(v1DataSources, dataSource)+ }++ return v1DataSources+}++func convertV1DataSourceExternalSecret(externalSecret *v1pb.DataSourceExternalSecret) (*storepb.DataSourceExternalSecret, error) {+ if externalSecret == nil {+ return nil, nil+ }++ secret := &storepb.DataSourceExternalSecret{+ SecretType: storepb.DataSourceExternalSecret_SecretType(externalSecret.SecretType),+ Url: externalSecret.Url,+ AuthType: storepb.DataSourceExternalSecret_AuthType(externalSecret.AuthType),+ EngineName: externalSecret.EngineName,+ SecretName: externalSecret.SecretName,+ PasswordKeyName: externalSecret.PasswordKeyName,+ }++ // Convert auth options+ switch externalSecret.AuthOption.(type) {+ case *v1pb.DataSourceExternalSecret_Token:+ secret.AuthOption = &storepb.DataSourceExternalSecret_Token{+ Token: externalSecret.GetToken(),+ }+ case *v1pb.DataSourceExternalSecret_AppRole:+ appRole := externalSecret.GetAppRole()+ if appRole != nil {+ secret.AuthOption = &storepb.DataSourceExternalSecret_AppRole{+ AppRole: &storepb.DataSourceExternalSecret_AppRoleAuthOption{+ Type: storepb.DataSourceExternalSecret_AppRoleAuthOption_SecretType(appRole.Type),+ MountPath: appRole.MountPath,+ },+ }+ }+ }++ switch secret.SecretType {+ case storepb.DataSourceExternalSecret_VAULT_KV_V2:+ if secret.Url == "" {+ return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("missing Vault URL"))+ }+ if secret.EngineName == "" {+ return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("missing Vault engine name"))+ }+ if secret.SecretName == "" || secret.PasswordKeyName == "" {+ return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("missing secret name or key name"))+ }+ case storepb.DataSourceExternalSecret_AWS_SECRETS_MANAGER:+ if secret.SecretName == "" || secret.PasswordKeyName == "" {+ return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("missing secret name or key name"))+ }+ case storepb.DataSourceExternalSecret_GCP_SECRET_MANAGER:+ if secret.SecretName == "" {+ return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("missing GCP secret name"))+ }+ default:+ }++ switch secret.AuthType {+ case storepb.DataSourceExternalSecret_TOKEN:+ if secret.GetToken() == "" {+ return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("missing token"))+ }+ case storepb.DataSourceExternalSecret_VAULT_APP_ROLE:+ if secret.GetAppRole() == nil {+ return nil, connect.NewError(connect.CodeInvalidArgument, errors.New("missing Vault approle"))+ }+ default:+ }++ return secret, nil+}++func convertV1DataSourceSaslConfig(saslConfig *v1pb.SASLConfig) *storepb.SASLConfig {+ if saslConfig == nil {+ return nil+ }+ storeSaslConfig := &storepb.SASLConfig{}+ switch m := saslConfig.Mechanism.(type) {+ case *v1pb.SASLConfig_KrbConfig:+ storeSaslConfig.Mechanism = &storepb.SASLConfig_KrbConfig{+ KrbConfig: &storepb.KerberosConfig{+ Primary: m.KrbConfig.Primary,+ Instance: m.KrbConfig.Instance,+ Realm: m.KrbConfig.Realm,+ Keytab: m.KrbConfig.Keytab,+ KdcHost: m.KrbConfig.KdcHost,+ KdcPort: m.KrbConfig.KdcPort,+ KdcTransportProtocol: m.KrbConfig.KdcTransportProtocol,+ },+ }+ default:+ return nil+ }+ return storeSaslConfig+}++func convertDataSourceSaslConfig(saslConfig *storepb.SASLConfig) *v1pb.SASLConfig {+ if saslConfig == nil {+ return nil+ }+ storeSaslConfig := &v1pb.SASLConfig{}+ switch m := saslConfig.Mechanism.(type) {+ case *storepb.SASLConfig_KrbConfig:+ storeSaslConfig.Mechanism = &v1pb.SASLConfig_KrbConfig{+ KrbConfig: &v1pb.KerberosConfig{+ Primary: m.KrbConfig.Primary,+ Instance: m.KrbConfig.Instance,+ Realm: m.KrbConfig.Realm,+ Keytab: m.KrbConfig.Keytab,+ KdcHost: m.KrbConfig.KdcHost,+ KdcPort: m.KrbConfig.KdcPort,+ KdcTransportProtocol: m.KrbConfig.KdcTransportProtocol,+ },+ }+ default:+ return nil+ }+ return storeSaslConfig+}++func convertDataSourceAddresses(addresses []*storepb.DataSource_Address) []*v1pb.DataSource_Address {+ res := make([]*v1pb.DataSource_Address, 0, len(addresses))+ for _, address := range addresses {+ res = append(res, &v1pb.DataSource_Address{+ Host: address.Host,+ Port: address.Port,+ })+ }+ return res+}++func convertAdditionalAddresses(addresses []*v1pb.DataSource_Address) []*storepb.DataSource_Address {+ res := make([]*storepb.DataSource_Address, 0, len(addresses))+ for _, address := range addresses {+ res = append(res, &storepb.DataSource_Address{+ Host: address.Host,+ Port: address.Port,+ })+ }+ return res+}++func convertV1AuthenticationType(authType v1pb.DataSource_AuthenticationType) storepb.DataSource_AuthenticationType {+ authenticationType := storepb.DataSource_AUTHENTICATION_UNSPECIFIED+ switch authType {+ case v1pb.DataSource_AUTHENTICATION_UNSPECIFIED, v1pb.DataSource_PASSWORD:+ authenticationType = storepb.DataSource_PASSWORD+ case v1pb.DataSource_GOOGLE_CLOUD_SQL_IAM:+ authenticationType = storepb.DataSource_GOOGLE_CLOUD_SQL_IAM+ case v1pb.DataSource_AWS_RDS_IAM:+ authenticationType = storepb.DataSource_AWS_RDS_IAM+ case v1pb.DataSource_AZURE_IAM:+ authenticationType = storepb.DataSource_AZURE_IAM+ default:+ }+ return authenticationType+}++func convertV1RedisType(redisType v1pb.DataSource_RedisType) storepb.DataSource_RedisType {+ authenticationType := storepb.DataSource_REDIS_TYPE_UNSPECIFIED+ switch redisType {+ case v1pb.DataSource_STANDALONE:+ authenticationType = storepb.DataSource_STANDALONE+ case v1pb.DataSource_SENTINEL:+ authenticationType = storepb.DataSource_SENTINEL+ case v1pb.DataSource_CLUSTER:+ authenticationType = storepb.DataSource_CLUSTER+ default:+ }+ return authenticationType+}++func convertRedisType(redisType storepb.DataSource_RedisType) v1pb.DataSource_RedisType {+ authenticationType := v1pb.DataSource_STANDALONE+ switch redisType {+ case storepb.DataSource_STANDALONE:+ authenticationType = v1pb.DataSource_STANDALONE+ case storepb.DataSource_SENTINEL:+ authenticationType = v1pb.DataSource_SENTINEL+ case storepb.DataSource_CLUSTER:+ authenticationType = v1pb.DataSource_CLUSTER+ default:+ }+ return authenticationType+}++func convertV1DataSource(dataSource *v1pb.DataSource) (*storepb.DataSource, error) {+ dsType, err := convertV1DataSourceType(dataSource.Type)+ if err != nil {+ return nil, err+ }+ externalSecret, err := convertV1DataSourceExternalSecret(dataSource.ExternalSecret)+ if err != nil {+ return nil, err+ }+ saslConfig := convertV1DataSourceSaslConfig(dataSource.SaslConfig)++ storeDataSource := &storepb.DataSource{+ Id: dataSource.Id,+ Type: dsType,+ Username: dataSource.Username,+ Password: dataSource.Password,+ SslCa: dataSource.SslCa,+ SslCert: dataSource.SslCert,+ SslKey: dataSource.SslKey,+ Host: dataSource.Host,+ Port: dataSource.Port,+ Database: dataSource.Database,+ Srv: dataSource.Srv,+ AuthenticationDatabase: dataSource.AuthenticationDatabase,+ Sid: dataSource.Sid,+ ServiceName: dataSource.ServiceName,+ SshHost: dataSource.SshHost,+ SshPort: dataSource.SshPort,+ SshUser: dataSource.SshUser,+ SshPassword: dataSource.SshPassword,+ SshPrivateKey: dataSource.SshPrivateKey,+ AuthenticationPrivateKey: dataSource.AuthenticationPrivateKey,+ ExternalSecret: externalSecret,+ SaslConfig: saslConfig,+ AuthenticationType: convertV1AuthenticationType(dataSource.AuthenticationType),+ AdditionalAddresses: convertAdditionalAddresses(dataSource.AdditionalAddresses),+ ReplicaSet: dataSource.ReplicaSet,+ DirectConnection: dataSource.DirectConnection,+ Region: dataSource.Region,+ WarehouseId: dataSource.WarehouseId,+ UseSsl: dataSource.UseSsl,+ VerifyTlsCertificate: dataSource.VerifyTlsCertificate,+ RedisType: convertV1RedisType(dataSource.RedisType),+ MasterName: dataSource.MasterName,+ MasterUsername: dataSource.MasterUsername,+ MasterPassword: dataSource.MasterPassword,+ ExtraConnectionParameters: dataSource.ExtraConnectionParameters,+ }++ switch dataSource.AuthenticationType {+ case v1pb.DataSource_AZURE_IAM:+ if azureCredential := dataSource.GetAzureCredential(); azureCredential != nil {+ storeDataSource.IamExtension = &storepb.DataSource_AzureCredential_{+ AzureCredential: &storepb.DataSource_AzureCredential{+ TenantId: azureCredential.TenantId,+ ClientId: azureCredential.ClientId,+ ClientSecret: azureCredential.ClientSecret,+ },+ }+ }+ case v1pb.DataSource_AWS_RDS_IAM:+ if awsCredential := dataSource.GetAwsCredential(); awsCredential != nil {+ storeDataSource.IamExtension = &storepb.DataSource_AwsCredential{+ AwsCredential: &storepb.DataSource_AWSCredential{+ AccessKeyId: awsCredential.AccessKeyId,+ SecretAccessKey: awsCredential.SecretAccessKey,+ SessionToken: awsCredential.SessionToken,+ },+ }+ }+ case v1pb.DataSource_GOOGLE_CLOUD_SQL_IAM:+ if gcpCredential := dataSource.GetGcpCredential(); gcpCredential != nil {+ storeDataSource.IamExtension = &storepb.DataSource_GcpCredential{+ GcpCredential: &storepb.DataSource_GCPCredential{+ Content: gcpCredential.Content,+ },+ }+ }+ default:+ }++ return storeDataSource, nil+}++func convertV1DataSourceType(tp v1pb.DataSourceType) (storepb.DataSourceType, error) {+ switch tp {+ case v1pb.DataSourceType_READ_ONLY:+ return storepb.DataSourceType_READ_ONLY, nil+ case v1pb.DataSourceType_ADMIN:+ return storepb.DataSourceType_ADMIN, nil+ default:+ return storepb.DataSourceType_DATA_SOURCE_UNSPECIFIED, errors.Errorf("invalid data source type %v", tp)+ }+}diff --git a/backend/api/v1/issue_service_convert.go b/backend/api/v1/issue_service_converter.gosimilarity index 100%rename from backend/api/v1/issue_service_convert.gorename to backend/api/v1/issue_service_converter.godiff --git a/backend/api/v1/org_policy_service.go b/backend/api/v1/org_policy_service.goindex 90a0a2be34..692ace8779 100644--- a/backend/api/v1/org_policy_service.go+++ b/backend/api/v1/org_policy_service.go@@ -7,7 +7,6 @@ import ("connectrpc.com/connect""github.com/pkg/errors"- "google.golang.org/genproto/googleapis/type/expr""google.golang.org/protobuf/encoding/protojson""google.golang.org/protobuf/types/known/emptypb"@@ -562,285 +561,3 @@ func (s *OrgPolicyService) convertToPolicy(ctx context.Context, policyMessage *sreturn policy, nil}--func convertToV1PBSQLReviewRules(ruleList []*storepb.SQLReviewRule) []*v1pb.SQLReviewRule {- var rules []*v1pb.SQLReviewRule- for _, rule := range ruleList {- level := v1pb.SQLReviewRuleLevel_LEVEL_UNSPECIFIED- switch rule.Level {- case storepb.SQLReviewRuleLevel_ERROR:- level = v1pb.SQLReviewRuleLevel_ERROR- case storepb.SQLReviewRuleLevel_WARNING:- level = v1pb.SQLReviewRuleLevel_WARNING- default:- }- rules = append(rules, &v1pb.SQLReviewRule{- Level: level,- Type: string(rule.Type),- Payload: rule.Payload,- Comment: rule.Comment,- Engine: convertToEngine(rule.Engine),- })- }-- return rules-}--func convertToSQLReviewRules(rules []*v1pb.SQLReviewRule) ([]*storepb.SQLReviewRule, error) {- var ruleList []*storepb.SQLReviewRule- for _, rule := range rules {- var level storepb.SQLReviewRuleLevel- switch rule.Level {- case v1pb.SQLReviewRuleLevel_ERROR:- level = storepb.SQLReviewRuleLevel_ERROR- case v1pb.SQLReviewRuleLevel_WARNING:- level = storepb.SQLReviewRuleLevel_WARNING- default:- return nil, errors.Errorf("invalid rule level %v", rule.Level)- }- ruleList = append(ruleList, &storepb.SQLReviewRule{- Level: level,- Payload: rule.Payload,- Type: rule.Type,- Comment: rule.Comment,- Engine: convertEngine(rule.Engine),- })- }-- return ruleList, nil-}--func convertToV1PBAction(action storepb.MaskingExceptionPolicy_MaskingException_Action) v1pb.MaskingExceptionPolicy_MaskingException_Action {- switch action {- case storepb.MaskingExceptionPolicy_MaskingException_ACTION_UNSPECIFIED:- return v1pb.MaskingExceptionPolicy_MaskingException_ACTION_UNSPECIFIED- case storepb.MaskingExceptionPolicy_MaskingException_QUERY:- return v1pb.MaskingExceptionPolicy_MaskingException_QUERY- case storepb.MaskingExceptionPolicy_MaskingException_EXPORT:- return v1pb.MaskingExceptionPolicy_MaskingException_EXPORT- default:- }- return v1pb.MaskingExceptionPolicy_MaskingException_ACTION_UNSPECIFIED-}--func convertToStorePBAction(action v1pb.MaskingExceptionPolicy_MaskingException_Action) storepb.MaskingExceptionPolicy_MaskingException_Action {- switch action {- case v1pb.MaskingExceptionPolicy_MaskingException_ACTION_UNSPECIFIED:- return storepb.MaskingExceptionPolicy_MaskingException_ACTION_UNSPECIFIED- case v1pb.MaskingExceptionPolicy_MaskingException_QUERY:- return storepb.MaskingExceptionPolicy_MaskingException_QUERY- case v1pb.MaskingExceptionPolicy_MaskingException_EXPORT:- return storepb.MaskingExceptionPolicy_MaskingException_EXPORT- default:- }- return storepb.MaskingExceptionPolicy_MaskingException_ACTION_UNSPECIFIED-}--func convertToV1RolloutPolicyPayload(payloadStr string) (*v1pb.Policy_RolloutPolicy, error) {- p := &v1pb.RolloutPolicy{}- if err := common.ProtojsonUnmarshaler.Unmarshal([]byte(payloadStr), p); err != nil {- return nil, errors.Wrapf(err, "failed to unmarshal rollout policy payload")- }- return &v1pb.Policy_RolloutPolicy{- RolloutPolicy: p,- }, nil-}--func convertToStorePBRolloutPolicy(policy *v1pb.RolloutPolicy) *storepb.RolloutPolicy {- return &storepb.RolloutPolicy{- Automatic: policy.Automatic,- Roles: policy.Roles,- Checkers: convertToStorePBCheckers(policy.Checkers),- }-}--func convertToStorePBCheckers(checkers *v1pb.RolloutPolicy_Checkers) *storepb.RolloutPolicy_Checkers {- if checkers == nil {- return nil- }- result := &storepb.RolloutPolicy_Checkers{- RequiredIssueApproval: checkers.RequiredIssueApproval,- }- if checkers.RequiredStatusChecks != nil {- result.RequiredStatusChecks = &storepb.RolloutPolicy_Checkers_RequiredStatusChecks{- PlanCheckEnforcement: storepb.RolloutPolicy_Checkers_PlanCheckEnforcement(checkers.RequiredStatusChecks.PlanCheckEnforcement),- }- }- return result-}--func convertToV1PBQueryDataPolicy(payloadStr string) (*v1pb.Policy_QueryDataPolicy, error) {- payload := &storepb.QueryDataPolicy{}- if err := common.ProtojsonUnmarshaler.Unmarshal([]byte(payloadStr), payload); err != nil {- return nil, errors.Wrapf(err, "failed to unmarshal query data policy payload")- }- return &v1pb.Policy_QueryDataPolicy{- QueryDataPolicy: &v1pb.QueryDataPolicy{- Timeout: payload.Timeout,- DisableExport: payload.DisableExport,- MaximumResultSize: payload.MaximumResultSize,- MaximumResultRows: payload.MaximumResultRows,- DisableCopyData: payload.DisableCopyData,- },- }, nil-}--func convertToQueryDataPolicyPayload(policy *v1pb.QueryDataPolicy) *storepb.QueryDataPolicy {- return &storepb.QueryDataPolicy{- Timeout: policy.Timeout,- DisableExport: policy.DisableExport,- MaximumResultSize: policy.MaximumResultSize,- MaximumResultRows: policy.MaximumResultRows,- DisableCopyData: policy.DisableCopyData,- }-}--func convertToStorePBMskingRulePolicy(policy *v1pb.MaskingRulePolicy) *storepb.MaskingRulePolicy {- var rules []*storepb.MaskingRulePolicy_MaskingRule- for _, rule := range policy.Rules {- rules = append(rules, &storepb.MaskingRulePolicy_MaskingRule{- Id: rule.Id,- Condition: &expr.Expr{- Title: rule.Condition.Title,- Expression: rule.Condition.Expression,- Description: rule.Condition.Description,- Location: rule.Condition.Location,- },- SemanticType: rule.SemanticType,- })- }-- return &storepb.MaskingRulePolicy{- Rules: rules,- }-}--func convertToV1PBMaskingRulePolicy(policy *storepb.MaskingRulePolicy) *v1pb.MaskingRulePolicy {- var rules []*v1pb.MaskingRulePolicy_MaskingRule- for _, rule := range policy.Rules {- rules = append(rules, &v1pb.MaskingRulePolicy_MaskingRule{- Id: rule.Id,- Condition: &expr.Expr{- Title: rule.Condition.Title,- Expression: rule.Condition.Expression,- Description: rule.Condition.Description,- Location: rule.Condition.Location,- },- SemanticType: rule.SemanticType,- })- }-- return &v1pb.MaskingRulePolicy{- Rules: rules,- }-}--func (s *OrgPolicyService) convertToStorePBMaskingExceptionPolicyPayload(ctx context.Context, policy *v1pb.MaskingExceptionPolicy) (*storepb.MaskingExceptionPolicy, error) {- var exceptions []*storepb.MaskingExceptionPolicy_MaskingException- for _, exception := range policy.MaskingExceptions {- member, err := convertToStoreIamPolicyMember(ctx, s.store, exception.Member)- if err != nil {- return nil, err- }- exceptions = append(exceptions, &storepb.MaskingExceptionPolicy_MaskingException{- Action: convertToStorePBAction(exception.Action),- Member: member,- Condition: &expr.Expr{- Title: exception.Condition.Title,- Expression: exception.Condition.Expression,- Description: exception.Condition.Description,- Location: exception.Condition.Location,- },- })- }-- return &storepb.MaskingExceptionPolicy{- MaskingExceptions: exceptions,- }, nil-}--func (s *OrgPolicyService) convertToV1PBMaskingExceptionPolicyPayload(ctx context.Context, policy *storepb.MaskingExceptionPolicy) *v1pb.MaskingExceptionPolicy {- var exceptions []*v1pb.MaskingExceptionPolicy_MaskingException- for _, exception := range policy.MaskingExceptions {- memberInBinding := convertToV1MemberInBinding(ctx, s.store, exception.Member)- if memberInBinding == "" {- continue- }-- exceptions = append(exceptions, &v1pb.MaskingExceptionPolicy_MaskingException{- Action: convertToV1PBAction(exception.Action),- Member: memberInBinding,- Condition: &expr.Expr{- Title: exception.Condition.Title,- Expression: exception.Condition.Expression,- Description: exception.Condition.Description,- Location: exception.Condition.Location,- },- })- }-- return &v1pb.MaskingExceptionPolicy{- MaskingExceptions: exceptions,- }-}--func convertToV1PBDataSourceQueryPolicy(payloadStr string) (*v1pb.Policy_DataSourceQueryPolicy, error) {- payload := &storepb.DataSourceQueryPolicy{}- if err := common.ProtojsonUnmarshaler.Unmarshal([]byte(payloadStr), payload); err != nil {- return nil, err- }-- return &v1pb.Policy_DataSourceQueryPolicy{- DataSourceQueryPolicy: &v1pb.DataSourceQueryPolicy{- AdminDataSourceRestriction: v1pb.DataSourceQueryPolicy_Restriction(payload.AdminDataSourceRestriction),- DisallowDdl: payload.DisallowDdl,- DisallowDml: payload.DisallowDml,- },- }, nil-}--func convertToDataSourceQueryPayload(policy *v1pb.DataSourceQueryPolicy) *storepb.DataSourceQueryPolicy {- return &storepb.DataSourceQueryPolicy{- AdminDataSourceRestriction: storepb.DataSourceQueryPolicy_Restriction(policy.AdminDataSourceRestriction),- DisallowDdl: policy.DisallowDdl,- DisallowDml: policy.DisallowDml,- }-}--func convertV1PBToStorePBPolicyType(pType v1pb.PolicyType) (storepb.Policy_Type, error) {- switch pType {- case v1pb.PolicyType_ROLLOUT_POLICY:- return storepb.Policy_ROLLOUT, nil- case v1pb.PolicyType_TAG:- return storepb.Policy_TAG, nil- case v1pb.PolicyType_MASKING_RULE:- return storepb.Policy_MASKING_RULE, nil- case v1pb.PolicyType_MASKING_EXCEPTION:- return storepb.Policy_MASKING_EXCEPTION, nil- case v1pb.PolicyType_DATA_QUERY:- return storepb.Policy_QUERY_DATA, nil- case v1pb.PolicyType_DATA_SOURCE_QUERY:- return storepb.Policy_DATA_SOURCE_QUERY, nil- default:- }- return storepb.Policy_TYPE_UNSPECIFIED, errors.Errorf("invalid policy type %v", pType)-}--func convertStorePBToV1PBPolicyType(pType storepb.Policy_Type) v1pb.PolicyType {- switch pType {- case storepb.Policy_ROLLOUT:- return v1pb.PolicyType_ROLLOUT_POLICY- case storepb.Policy_TAG:- return v1pb.PolicyType_TAG- case storepb.Policy_MASKING_RULE:- return v1pb.PolicyType_MASKING_RULE- case storepb.Policy_MASKING_EXCEPTION:- return v1pb.PolicyType_MASKING_EXCEPTION- case storepb.Policy_QUERY_DATA:- return v1pb.PolicyType_DATA_QUERY- case storepb.Policy_DATA_SOURCE_QUERY:- return v1pb.PolicyType_DATA_SOURCE_QUERY- default:- }- return v1pb.PolicyType_POLICY_TYPE_UNSPECIFIED-}diff --git a/backend/api/v1/org_policy_service_converter.go b/backend/api/v1/org_policy_service_converter.gonew file mode 100644index 0000000000..afa66c648e--- /dev/null+++ b/backend/api/v1/org_policy_service_converter.go@@ -0,0 +1,294 @@+package v1++import (+ "context"++ "github.com/pkg/errors"+ "google.golang.org/genproto/googleapis/type/expr"++ "github.com/bytebase/bytebase/backend/common"+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"+)++func convertToV1PBSQLReviewRules(ruleList []*storepb.SQLReviewRule) []*v1pb.SQLReviewRule {+ var rules []*v1pb.SQLReviewRule+ for _, rule := range ruleList {+ level := v1pb.SQLReviewRuleLevel_LEVEL_UNSPECIFIED+ switch rule.Level {+ case storepb.SQLReviewRuleLevel_ERROR:+ level = v1pb.SQLReviewRuleLevel_ERROR+ case storepb.SQLReviewRuleLevel_WARNING:+ level = v1pb.SQLReviewRuleLevel_WARNING+ default:+ }+ rules = append(rules, &v1pb.SQLReviewRule{+ Level: level,+ Type: string(rule.Type),+ Payload: rule.Payload,+ Comment: rule.Comment,+ Engine: convertToEngine(rule.Engine),+ })+ }++ return rules+}++func convertToSQLReviewRules(rules []*v1pb.SQLReviewRule) ([]*storepb.SQLReviewRule, error) {+ var ruleList []*storepb.SQLReviewRule+ for _, rule := range rules {+ var level storepb.SQLReviewRuleLevel+ switch rule.Level {+ case v1pb.SQLReviewRuleLevel_ERROR:+ level = storepb.SQLReviewRuleLevel_ERROR+ case v1pb.SQLReviewRuleLevel_WARNING:+ level = storepb.SQLReviewRuleLevel_WARNING+ default:+ return nil, errors.Errorf("invalid rule level %v", rule.Level)+ }+ ruleList = append(ruleList, &storepb.SQLReviewRule{+ Level: level,+ Payload: rule.Payload,+ Type: rule.Type,+ Comment: rule.Comment,+ Engine: convertEngine(rule.Engine),+ })+ }++ return ruleList, nil+}++func convertToV1PBAction(action storepb.MaskingExceptionPolicy_MaskingException_Action) v1pb.MaskingExceptionPolicy_MaskingException_Action {+ switch action {+ case storepb.MaskingExceptionPolicy_MaskingException_ACTION_UNSPECIFIED:+ return v1pb.MaskingExceptionPolicy_MaskingException_ACTION_UNSPECIFIED+ case storepb.MaskingExceptionPolicy_MaskingException_QUERY:+ return v1pb.MaskingExceptionPolicy_MaskingException_QUERY+ case storepb.MaskingExceptionPolicy_MaskingException_EXPORT:+ return v1pb.MaskingExceptionPolicy_MaskingException_EXPORT+ default:+ }+ return v1pb.MaskingExceptionPolicy_MaskingException_ACTION_UNSPECIFIED+}++func convertToStorePBAction(action v1pb.MaskingExceptionPolicy_MaskingException_Action) storepb.MaskingExceptionPolicy_MaskingException_Action {+ switch action {+ case v1pb.MaskingExceptionPolicy_MaskingException_ACTION_UNSPECIFIED:+ return storepb.MaskingExceptionPolicy_MaskingException_ACTION_UNSPECIFIED+ case v1pb.MaskingExceptionPolicy_MaskingException_QUERY:+ return storepb.MaskingExceptionPolicy_MaskingException_QUERY+ case v1pb.MaskingExceptionPolicy_MaskingException_EXPORT:+ return storepb.MaskingExceptionPolicy_MaskingException_EXPORT+ default:+ }+ return storepb.MaskingExceptionPolicy_MaskingException_ACTION_UNSPECIFIED+}++func convertToV1RolloutPolicyPayload(payloadStr string) (*v1pb.Policy_RolloutPolicy, error) {+ p := &v1pb.RolloutPolicy{}+ if err := common.ProtojsonUnmarshaler.Unmarshal([]byte(payloadStr), p); err != nil {+ return nil, errors.Wrapf(err, "failed to unmarshal rollout policy payload")+ }+ return &v1pb.Policy_RolloutPolicy{+ RolloutPolicy: p,+ }, nil+}++func convertToStorePBRolloutPolicy(policy *v1pb.RolloutPolicy) *storepb.RolloutPolicy {+ return &storepb.RolloutPolicy{+ Automatic: policy.Automatic,+ Roles: policy.Roles,+ Checkers: convertToStorePBCheckers(policy.Checkers),+ }+}++func convertToStorePBCheckers(checkers *v1pb.RolloutPolicy_Checkers) *storepb.RolloutPolicy_Checkers {+ if checkers == nil {+ return nil+ }+ result := &storepb.RolloutPolicy_Checkers{+ RequiredIssueApproval: checkers.RequiredIssueApproval,+ }+ if checkers.RequiredStatusChecks != nil {+ result.RequiredStatusChecks = &storepb.RolloutPolicy_Checkers_RequiredStatusChecks{+ PlanCheckEnforcement: storepb.RolloutPolicy_Checkers_PlanCheckEnforcement(checkers.RequiredStatusChecks.PlanCheckEnforcement),+ }+ }+ return result+}++func convertToV1PBQueryDataPolicy(payloadStr string) (*v1pb.Policy_QueryDataPolicy, error) {+ payload := &storepb.QueryDataPolicy{}+ if err := common.ProtojsonUnmarshaler.Unmarshal([]byte(payloadStr), payload); err != nil {+ return nil, errors.Wrapf(err, "failed to unmarshal query data policy payload")+ }+ return &v1pb.Policy_QueryDataPolicy{+ QueryDataPolicy: &v1pb.QueryDataPolicy{+ Timeout: payload.Timeout,+ DisableExport: payload.DisableExport,+ MaximumResultSize: payload.MaximumResultSize,+ MaximumResultRows: payload.MaximumResultRows,+ DisableCopyData: payload.DisableCopyData,+ },+ }, nil+}++func convertToQueryDataPolicyPayload(policy *v1pb.QueryDataPolicy) *storepb.QueryDataPolicy {+ return &storepb.QueryDataPolicy{+ Timeout: policy.Timeout,+ DisableExport: policy.DisableExport,+ MaximumResultSize: policy.MaximumResultSize,+ MaximumResultRows: policy.MaximumResultRows,+ DisableCopyData: policy.DisableCopyData,+ }+}++func convertToStorePBMskingRulePolicy(policy *v1pb.MaskingRulePolicy) *storepb.MaskingRulePolicy {+ var rules []*storepb.MaskingRulePolicy_MaskingRule+ for _, rule := range policy.Rules {+ rules = append(rules, &storepb.MaskingRulePolicy_MaskingRule{+ Id: rule.Id,+ Condition: &expr.Expr{+ Title: rule.Condition.Title,+ Expression: rule.Condition.Expression,+ Description: rule.Condition.Description,+ Location: rule.Condition.Location,+ },+ SemanticType: rule.SemanticType,+ })+ }++ return &storepb.MaskingRulePolicy{+ Rules: rules,+ }+}++func convertToV1PBMaskingRulePolicy(policy *storepb.MaskingRulePolicy) *v1pb.MaskingRulePolicy {+ var rules []*v1pb.MaskingRulePolicy_MaskingRule+ for _, rule := range policy.Rules {+ rules = append(rules, &v1pb.MaskingRulePolicy_MaskingRule{+ Id: rule.Id,+ Condition: &expr.Expr{+ Title: rule.Condition.Title,+ Expression: rule.Condition.Expression,+ Description: rule.Condition.Description,+ Location: rule.Condition.Location,+ },+ SemanticType: rule.SemanticType,+ })+ }++ return &v1pb.MaskingRulePolicy{+ Rules: rules,+ }+}++func (s *OrgPolicyService) convertToStorePBMaskingExceptionPolicyPayload(ctx context.Context, policy *v1pb.MaskingExceptionPolicy) (*storepb.MaskingExceptionPolicy, error) {+ var exceptions []*storepb.MaskingExceptionPolicy_MaskingException+ for _, exception := range policy.MaskingExceptions {+ member, err := convertToStoreIamPolicyMember(ctx, s.store, exception.Member)+ if err != nil {+ return nil, err+ }+ exceptions = append(exceptions, &storepb.MaskingExceptionPolicy_MaskingException{+ Action: convertToStorePBAction(exception.Action),+ Member: member,+ Condition: &expr.Expr{+ Title: exception.Condition.Title,+ Expression: exception.Condition.Expression,+ Description: exception.Condition.Description,+ Location: exception.Condition.Location,+ },+ })+ }++ return &storepb.MaskingExceptionPolicy{+ MaskingExceptions: exceptions,+ }, nil+}++func (s *OrgPolicyService) convertToV1PBMaskingExceptionPolicyPayload(ctx context.Context, policy *storepb.MaskingExceptionPolicy) *v1pb.MaskingExceptionPolicy {+ var exceptions []*v1pb.MaskingExceptionPolicy_MaskingException+ for _, exception := range policy.MaskingExceptions {+ memberInBinding := convertToV1MemberInBinding(ctx, s.store, exception.Member)+ if memberInBinding == "" {+ continue+ }++ exceptions = append(exceptions, &v1pb.MaskingExceptionPolicy_MaskingException{+ Action: convertToV1PBAction(exception.Action),+ Member: memberInBinding,+ Condition: &expr.Expr{+ Title: exception.Condition.Title,+ Expression: exception.Condition.Expression,+ Description: exception.Condition.Description,+ Location: exception.Condition.Location,+ },+ })+ }++ return &v1pb.MaskingExceptionPolicy{+ MaskingExceptions: exceptions,+ }+}++func convertToV1PBDataSourceQueryPolicy(payloadStr string) (*v1pb.Policy_DataSourceQueryPolicy, error) {+ payload := &storepb.DataSourceQueryPolicy{}+ if err := common.ProtojsonUnmarshaler.Unmarshal([]byte(payloadStr), payload); err != nil {+ return nil, err+ }++ return &v1pb.Policy_DataSourceQueryPolicy{+ DataSourceQueryPolicy: &v1pb.DataSourceQueryPolicy{+ AdminDataSourceRestriction: v1pb.DataSourceQueryPolicy_Restriction(payload.AdminDataSourceRestriction),+ DisallowDdl: payload.DisallowDdl,+ DisallowDml: payload.DisallowDml,+ },+ }, nil+}++func convertToDataSourceQueryPayload(policy *v1pb.DataSourceQueryPolicy) *storepb.DataSourceQueryPolicy {+ return &storepb.DataSourceQueryPolicy{+ AdminDataSourceRestriction: storepb.DataSourceQueryPolicy_Restriction(policy.AdminDataSourceRestriction),+ DisallowDdl: policy.DisallowDdl,+ DisallowDml: policy.DisallowDml,+ }+}++func convertV1PBToStorePBPolicyType(pType v1pb.PolicyType) (storepb.Policy_Type, error) {+ switch pType {+ case v1pb.PolicyType_ROLLOUT_POLICY:+ return storepb.Policy_ROLLOUT, nil+ case v1pb.PolicyType_TAG:+ return storepb.Policy_TAG, nil+ case v1pb.PolicyType_MASKING_RULE:+ return storepb.Policy_MASKING_RULE, nil+ case v1pb.PolicyType_MASKING_EXCEPTION:+ return storepb.Policy_MASKING_EXCEPTION, nil+ case v1pb.PolicyType_DATA_QUERY:+ return storepb.Policy_QUERY_DATA, nil+ case v1pb.PolicyType_DATA_SOURCE_QUERY:+ return storepb.Policy_DATA_SOURCE_QUERY, nil+ default:+ }+ return storepb.Policy_TYPE_UNSPECIFIED, errors.Errorf("invalid policy type %v", pType)+}++func convertStorePBToV1PBPolicyType(pType storepb.Policy_Type) v1pb.PolicyType {+ switch pType {+ case storepb.Policy_ROLLOUT:+ return v1pb.PolicyType_ROLLOUT_POLICY+ case storepb.Policy_TAG:+ return v1pb.PolicyType_TAG+ case storepb.Policy_MASKING_RULE:+ return v1pb.PolicyType_MASKING_RULE+ case storepb.Policy_MASKING_EXCEPTION:+ return v1pb.PolicyType_MASKING_EXCEPTION+ case storepb.Policy_QUERY_DATA:+ return v1pb.PolicyType_DATA_QUERY+ case storepb.Policy_DATA_SOURCE_QUERY:+ return v1pb.PolicyType_DATA_SOURCE_QUERY+ default:+ }+ return v1pb.PolicyType_POLICY_TYPE_UNSPECIFIED+}diff --git a/backend/api/v1/plan_service_converter.go b/backend/api/v1/plan_service_converter.gonew file mode 100644index 0000000000..548e89a211--- /dev/null+++ b/backend/api/v1/plan_service_converter.go@@ -0,0 +1,421 @@+package v1++import (+ "context"++ "github.com/pkg/errors"+ "google.golang.org/protobuf/types/known/timestamppb"++ "github.com/bytebase/bytebase/backend/common"+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"+ "github.com/bytebase/bytebase/backend/store"+)++func convertToPlans(ctx context.Context, s *store.Store, plans []*store.PlanMessage) ([]*v1pb.Plan, error) {+ v1Plans := make([]*v1pb.Plan, len(plans))+ for i := range plans {+ p, err := convertToPlan(ctx, s, plans[i])+ if err != nil {+ return nil, errors.Wrapf(err, "failed to convert plan")+ }+ v1Plans[i] = p+ }+ return v1Plans, nil+}++func convertToPlan(ctx context.Context, s *store.Store, plan *store.PlanMessage) (*v1pb.Plan, error) {+ p := &v1pb.Plan{+ Name: common.FormatPlan(plan.ProjectID, plan.UID),+ Title: plan.Name,+ Description: plan.Description,+ Specs: convertToPlanSpecs(plan.Config.Specs), // Use specs field for output+ Deployment: convertToPlanDeployment(plan.Config.Deployment),+ CreateTime: timestamppb.New(plan.CreatedAt),+ UpdateTime: timestamppb.New(plan.UpdatedAt),+ State: convertDeletedToState(plan.Deleted),+ PlanCheckRunStatusCount: map[string]int32{},+ }++ creator, err := s.GetUserByID(ctx, plan.CreatorUID)+ if err != nil {+ return nil, errors.Wrapf(err, "failed to get plan creator")+ }+ p.Creator = common.FormatUserEmail(creator.Email)++ issue, err := s.GetIssueV2(ctx, &store.FindIssueMessage{PlanUID: &plan.UID})+ if err != nil {+ return nil, errors.Wrapf(err, "failed to get issue by plan uid %d", plan.UID)+ }+ if issue != nil {+ p.Issue = common.FormatIssue(issue.Project.ResourceID, issue.UID)+ }+ if plan.PipelineUID != nil {+ p.Rollout = common.FormatRollout(plan.ProjectID, *plan.PipelineUID)+ }+ planCheckRuns, err := s.ListPlanCheckRuns(ctx, &store.FindPlanCheckRunMessage{+ PlanUID: &plan.UID,+ })+ if err != nil {+ return nil, errors.Wrapf(err, "failed to list plan check runs for plan uid %d", plan.UID)+ }+ for _, run := range planCheckRuns {+ p.PlanCheckRunStatusCount[string(run.Status)]+++ for _, result := range run.Result.Results {+ p.PlanCheckRunStatusCount[storepb.Advice_Status_name[int32(result.Status)]]+++ }+ }+ return p, nil+}++func convertToPlanSpecs(specs []*storepb.PlanConfig_Spec) []*v1pb.Plan_Spec {+ v1Specs := make([]*v1pb.Plan_Spec, len(specs))+ for i := range specs {+ v1Specs[i] = convertToPlanSpec(specs[i])+ }+ return v1Specs+}++func convertToPlanSpec(spec *storepb.PlanConfig_Spec) *v1pb.Plan_Spec {+ v1Spec := &v1pb.Plan_Spec{+ Id: spec.Id,+ }++ switch v := spec.Config.(type) {+ case *storepb.PlanConfig_Spec_CreateDatabaseConfig:+ v1Spec.Config = convertToPlanSpecCreateDatabaseConfig(v)+ case *storepb.PlanConfig_Spec_ChangeDatabaseConfig:+ v1Spec.Config = convertToPlanSpecChangeDatabaseConfig(v)+ case *storepb.PlanConfig_Spec_ExportDataConfig:+ v1Spec.Config = convertToPlanSpecExportDataConfig(v)+ }++ return v1Spec+}++func convertToPlanSpecCreateDatabaseConfig(config *storepb.PlanConfig_Spec_CreateDatabaseConfig) *v1pb.Plan_Spec_CreateDatabaseConfig {+ c := config.CreateDatabaseConfig+ return &v1pb.Plan_Spec_CreateDatabaseConfig{+ CreateDatabaseConfig: &v1pb.Plan_CreateDatabaseConfig{+ Target: c.Target,+ Database: c.Database,+ Table: c.Table,+ CharacterSet: c.CharacterSet,+ Collation: c.Collation,+ Cluster: c.Cluster,+ Owner: c.Owner,+ Environment: c.Environment,+ },+ }+}++func convertToPlanSpecChangeDatabaseConfig(config *storepb.PlanConfig_Spec_ChangeDatabaseConfig) *v1pb.Plan_Spec_ChangeDatabaseConfig {+ c := config.ChangeDatabaseConfig+ return &v1pb.Plan_Spec_ChangeDatabaseConfig{+ ChangeDatabaseConfig: &v1pb.Plan_ChangeDatabaseConfig{+ Targets: c.Targets,+ Sheet: c.Sheet,+ Release: c.Release,+ Type: convertToPlanSpecChangeDatabaseConfigType(c.Type),+ MigrationType: convertToPlanSpecMigrationType(c.MigrateType),+ GhostFlags: c.GhostFlags,+ EnablePriorBackup: c.EnablePriorBackup,+ },+ }+}++func convertToPlanSpecChangeDatabaseConfigType(t storepb.PlanConfig_ChangeDatabaseConfig_Type) v1pb.DatabaseChangeType {+ switch t {+ case storepb.PlanConfig_ChangeDatabaseConfig_TYPE_UNSPECIFIED:+ return v1pb.DatabaseChangeType_DATABASE_CHANGE_TYPE_UNSPECIFIED+ case storepb.PlanConfig_ChangeDatabaseConfig_MIGRATE:+ return v1pb.DatabaseChangeType_MIGRATE+ case storepb.PlanConfig_ChangeDatabaseConfig_SDL:+ return v1pb.DatabaseChangeType_SDL+ default:+ return v1pb.DatabaseChangeType_DATABASE_CHANGE_TYPE_UNSPECIFIED+ }+}++func convertToPlanSpecMigrationType(t storepb.MigrationType) v1pb.MigrationType {+ switch t {+ case storepb.MigrationType_DDL:+ return v1pb.MigrationType_DDL+ case storepb.MigrationType_GHOST:+ return v1pb.MigrationType_GHOST+ case storepb.MigrationType_DML:+ return v1pb.MigrationType_DML+ default:+ return v1pb.MigrationType_MIGRATION_TYPE_UNSPECIFIED+ }+}++func convertToPlanSpecExportDataConfig(config *storepb.PlanConfig_Spec_ExportDataConfig) *v1pb.Plan_Spec_ExportDataConfig {+ c := config.ExportDataConfig+ return &v1pb.Plan_Spec_ExportDataConfig{+ ExportDataConfig: &v1pb.Plan_ExportDataConfig{+ Targets: c.Targets,+ Sheet: c.Sheet,+ Format: convertExportFormat(c.Format),+ Password: c.Password,+ },+ }+}++func convertToPlanDeployment(deployment *storepb.PlanConfig_Deployment) *v1pb.Plan_Deployment {+ if deployment == nil {+ return nil+ }+ return &v1pb.Plan_Deployment{+ Environments: deployment.Environments,+ DatabaseGroupMappings: convertToDatabaseGroupMappings(deployment.DatabaseGroupMappings),+ }+}++func convertToDatabaseGroupMappings(mappings []*storepb.PlanConfig_Deployment_DatabaseGroupMapping) []*v1pb.Plan_Deployment_DatabaseGroupMapping {+ v1Mappings := make([]*v1pb.Plan_Deployment_DatabaseGroupMapping, len(mappings))+ for i := range mappings {+ v1Mappings[i] = convertToDatabaseGroupMapping(mappings[i])+ }+ return v1Mappings+}++func convertToDatabaseGroupMapping(mapping *storepb.PlanConfig_Deployment_DatabaseGroupMapping) *v1pb.Plan_Deployment_DatabaseGroupMapping {+ if mapping == nil {+ return nil+ }+ return &v1pb.Plan_Deployment_DatabaseGroupMapping{+ DatabaseGroup: mapping.DatabaseGroup,+ Databases: mapping.Databases,+ }+}++func convertPlan(plan *v1pb.Plan) *storepb.PlanConfig {+ if plan == nil {+ return nil+ }++ // At this point, plan.Specs should always be populated+ // (either originally or converted from steps at API entry point)+ return &storepb.PlanConfig{+ Specs: convertPlanSpecs(plan.Specs),+ Deployment: nil,+ }+}++func convertPlanSpecs(specs []*v1pb.Plan_Spec) []*storepb.PlanConfig_Spec {+ storeSpecs := make([]*storepb.PlanConfig_Spec, len(specs))+ for i := range specs {+ storeSpecs[i] = convertPlanSpec(specs[i])+ }+ return storeSpecs+}++func convertPlanSpec(spec *v1pb.Plan_Spec) *storepb.PlanConfig_Spec {+ storeSpec := &storepb.PlanConfig_Spec{+ Id: spec.Id,+ }++ switch v := spec.Config.(type) {+ case *v1pb.Plan_Spec_CreateDatabaseConfig:+ storeSpec.Config = convertPlanSpecCreateDatabaseConfig(v)+ case *v1pb.Plan_Spec_ChangeDatabaseConfig:+ storeSpec.Config = convertPlanSpecChangeDatabaseConfig(v)+ case *v1pb.Plan_Spec_ExportDataConfig:+ storeSpec.Config = convertPlanSpecExportDataConfig(v)+ }+ return storeSpec+}++func convertPlanSpecCreateDatabaseConfig(config *v1pb.Plan_Spec_CreateDatabaseConfig) *storepb.PlanConfig_Spec_CreateDatabaseConfig {+ c := config.CreateDatabaseConfig+ return &storepb.PlanConfig_Spec_CreateDatabaseConfig{+ CreateDatabaseConfig: convertPlanConfigCreateDatabaseConfig(c),+ }+}++func convertPlanConfigCreateDatabaseConfig(c *v1pb.Plan_CreateDatabaseConfig) *storepb.PlanConfig_CreateDatabaseConfig {+ return &storepb.PlanConfig_CreateDatabaseConfig{+ Target: c.Target,+ Database: c.Database,+ Table: c.Table,+ CharacterSet: c.CharacterSet,+ Collation: c.Collation,+ Cluster: c.Cluster,+ Owner: c.Owner,+ Environment: c.Environment,+ }+}++func convertPlanSpecChangeDatabaseConfig(config *v1pb.Plan_Spec_ChangeDatabaseConfig) *storepb.PlanConfig_Spec_ChangeDatabaseConfig {+ c := config.ChangeDatabaseConfig++ // Convert v1 DatabaseChangeType to store Type+ var storeType storepb.PlanConfig_ChangeDatabaseConfig_Type+ switch c.Type {+ case v1pb.DatabaseChangeType_MIGRATE:+ storeType = storepb.PlanConfig_ChangeDatabaseConfig_MIGRATE+ case v1pb.DatabaseChangeType_SDL:+ storeType = storepb.PlanConfig_ChangeDatabaseConfig_SDL+ default:+ storeType = storepb.PlanConfig_ChangeDatabaseConfig_TYPE_UNSPECIFIED+ }++ // Convert v1 MigrationType to store MigrateType+ var storeMigrateType storepb.MigrationType+ switch c.MigrationType {+ case v1pb.MigrationType_DDL:+ storeMigrateType = storepb.MigrationType_DDL+ case v1pb.MigrationType_DML:+ storeMigrateType = storepb.MigrationType_DML+ case v1pb.MigrationType_GHOST:+ storeMigrateType = storepb.MigrationType_GHOST+ default:+ storeMigrateType = storepb.MigrationType_MIGRATION_TYPE_UNSPECIFIED+ }++ return &storepb.PlanConfig_Spec_ChangeDatabaseConfig{+ ChangeDatabaseConfig: &storepb.PlanConfig_ChangeDatabaseConfig{+ Targets: c.Targets,+ Sheet: c.Sheet,+ Release: c.Release,+ Type: storeType,+ MigrateType: storeMigrateType,+ GhostFlags: c.GhostFlags,+ EnablePriorBackup: c.EnablePriorBackup,+ },+ }+}++func convertPlanSpecExportDataConfig(config *v1pb.Plan_Spec_ExportDataConfig) *storepb.PlanConfig_Spec_ExportDataConfig {+ c := config.ExportDataConfig+ return &storepb.PlanConfig_Spec_ExportDataConfig{+ ExportDataConfig: &storepb.PlanConfig_ExportDataConfig{+ Targets: c.Targets,+ Sheet: c.Sheet,+ Format: convertToExportFormat(c.Format),+ Password: c.Password,+ },+ }+}++func convertToPlanCheckRuns(ctx context.Context, s *store.Store, projectID string, planUID int64, runs []*store.PlanCheckRunMessage) ([]*v1pb.PlanCheckRun, error) {+ var planCheckRuns []*v1pb.PlanCheckRun+ for _, run := range runs {+ converted, err := convertToPlanCheckRun(ctx, s, projectID, planUID, run)+ if err != nil {+ return nil, errors.Wrapf(err, "failed to convert plan check run")+ }+ planCheckRuns = append(planCheckRuns, converted)+ }+ return planCheckRuns, nil+}++func convertToPlanCheckRun(ctx context.Context, s *store.Store, projectID string, planUID int64, run *store.PlanCheckRunMessage) (*v1pb.PlanCheckRun, error) {+ converted := &v1pb.PlanCheckRun{+ Name: common.FormatPlanCheckRun(projectID, planUID, int64(run.UID)),+ CreateTime: timestamppb.New(run.CreatedAt),+ Type: convertToPlanCheckRunType(run.Type),+ Status: convertToPlanCheckRunStatus(run.Status),+ Target: common.FormatDatabase(run.Config.InstanceId, run.Config.DatabaseName),+ Sheet: "",+ Results: convertToPlanCheckRunResults(run.Result.Results),+ Error: run.Result.Error,+ }++ if sheetUID := int(run.Config.GetSheetUid()); sheetUID != 0 {+ sheet, err := s.GetSheet(ctx, &store.FindSheetMessage{UID: &sheetUID})+ if err != nil {+ return nil, errors.Wrapf(err, "failed to get sheet")+ }+ if sheet == nil {+ return nil, errors.Errorf("sheet not found for uid %d", sheetUID)+ }+ converted.Sheet = common.FormatSheet(projectID, sheet.UID)+ }++ return converted, nil+}++func convertToPlanCheckRunType(t store.PlanCheckRunType) v1pb.PlanCheckRun_Type {+ switch t {+ case store.PlanCheckDatabaseStatementFakeAdvise:+ return v1pb.PlanCheckRun_DATABASE_STATEMENT_FAKE_ADVISE+ case store.PlanCheckDatabaseStatementAdvise:+ return v1pb.PlanCheckRun_DATABASE_STATEMENT_ADVISE+ case store.PlanCheckDatabaseStatementSummaryReport:+ return v1pb.PlanCheckRun_DATABASE_STATEMENT_SUMMARY_REPORT+ case store.PlanCheckDatabaseConnect:+ return v1pb.PlanCheckRun_DATABASE_CONNECT+ case store.PlanCheckDatabaseGhostSync:+ return v1pb.PlanCheckRun_DATABASE_GHOST_SYNC+ default:+ return v1pb.PlanCheckRun_TYPE_UNSPECIFIED+ }+}++func convertToPlanCheckRunStatus(status store.PlanCheckRunStatus) v1pb.PlanCheckRun_Status {+ switch status {+ case store.PlanCheckRunStatusCanceled:+ return v1pb.PlanCheckRun_CANCELED+ case store.PlanCheckRunStatusDone:+ return v1pb.PlanCheckRun_DONE+ case store.PlanCheckRunStatusFailed:+ return v1pb.PlanCheckRun_FAILED+ case store.PlanCheckRunStatusRunning:+ return v1pb.PlanCheckRun_RUNNING+ default:+ return v1pb.PlanCheckRun_STATUS_UNSPECIFIED+ }+}++func convertToPlanCheckRunResults(results []*storepb.PlanCheckRunResult_Result) []*v1pb.PlanCheckRun_Result {+ var resultsV1 []*v1pb.PlanCheckRun_Result+ for _, result := range results {+ resultsV1 = append(resultsV1, convertToPlanCheckRunResult(result))+ }+ return resultsV1+}++func convertToPlanCheckRunResult(result *storepb.PlanCheckRunResult_Result) *v1pb.PlanCheckRun_Result {+ resultV1 := &v1pb.PlanCheckRun_Result{+ Status: convertToPlanCheckRunResultStatus(result.Status),+ Title: result.Title,+ Content: result.Content,+ Code: result.Code,+ Report: nil,+ }+ switch report := result.Report.(type) {+ case *storepb.PlanCheckRunResult_Result_SqlSummaryReport_:+ resultV1.Report = &v1pb.PlanCheckRun_Result_SqlSummaryReport_{+ SqlSummaryReport: &v1pb.PlanCheckRun_Result_SqlSummaryReport{+ StatementTypes: report.SqlSummaryReport.StatementTypes,+ AffectedRows: report.SqlSummaryReport.AffectedRows,+ ChangedResources: convertToChangedResources(report.SqlSummaryReport.ChangedResources),+ },+ }+ case *storepb.PlanCheckRunResult_Result_SqlReviewReport_:+ resultV1.Report = &v1pb.PlanCheckRun_Result_SqlReviewReport_{+ SqlReviewReport: &v1pb.PlanCheckRun_Result_SqlReviewReport{+ StartPosition: convertToPosition(report.SqlReviewReport.StartPosition),+ EndPosition: convertToPosition(report.SqlReviewReport.EndPosition),+ },+ }+ }+ return resultV1+}++func convertToPlanCheckRunResultStatus(status storepb.Advice_Status) v1pb.Advice_Level {+ switch status {+ case storepb.Advice_STATUS_UNSPECIFIED:+ return v1pb.Advice_ADVICE_LEVEL_UNSPECIFIED+ case storepb.Advice_SUCCESS:+ return v1pb.Advice_SUCCESS+ case storepb.Advice_WARNING:+ return v1pb.Advice_WARNING+ case storepb.Advice_ERROR:+ return v1pb.Advice_ERROR+ default:+ return v1pb.Advice_ADVICE_LEVEL_UNSPECIFIED+ }+}diff --git a/backend/api/v1/project_service.go b/backend/api/v1/project_service.goindex 52dc13963d..b346071f50 100644--- a/backend/api/v1/project_service.go+++ b/backend/api/v1/project_service.go@@ -17,7 +17,6 @@ import ("github.com/pkg/errors""google.golang.org/genproto/googleapis/type/expr""google.golang.org/protobuf/encoding/protojson"- "google.golang.org/protobuf/types/known/anypb""google.golang.org/protobuf/types/known/durationpb""google.golang.org/protobuf/types/known/emptypb"@@ -31,7 +30,6 @@ import ("github.com/bytebase/bytebase/backend/generated-go/v1/v1connect"webhookplugin "github.com/bytebase/bytebase/backend/plugin/webhook""github.com/bytebase/bytebase/backend/store"- "github.com/bytebase/bytebase/backend/utils")// ProjectService implements the project service.@@ -799,20 +797,6 @@ func (s *ProjectService) SetIamPolicy(ctx context.Context, req *connect.Request[return connect.NewResponse(iamPolicy), nil}-func convertToProtoAny(i any) (*anypb.Any, error) {- switch deltas := i.(type) {- case []*v1pb.BindingDelta:- auditData := v1pb.AuditData{- PolicyDelta: &v1pb.PolicyDelta{- BindingDeltas: deltas,- },- }- return anypb.New(&auditData)- default:- return &anypb.Any{}, nil- }-}-type bindMapKey struct {User stringRole string@@ -1160,131 +1144,6 @@ func (s *ProjectService) TestWebhook(ctx context.Context, req *connect.Request[vreturn connect.NewResponse(resp), nil}-func convertToStoreProjectWebhookMessage(webhook *v1pb.Webhook) (*store.ProjectWebhookMessage, error) {- tp, err := convertToAPIWebhookTypeString(webhook.Type)- if err != nil {- return nil, err- }- activityTypes, err := convertToActivityTypeStrings(webhook.NotificationTypes)- if err != nil {- return nil, err- }- return &store.ProjectWebhookMessage{- Type: tp,- URL: webhook.Url,- Title: webhook.Title,- Events: activityTypes,- Payload: &storepb.ProjectWebhookPayload{- DirectMessage: webhook.DirectMessage,- },- }, nil-}--func convertToActivityTypeStrings(types []v1pb.Activity_Type) ([]string, error) {- var result []string- for _, tp := range types {- switch tp {- case v1pb.Activity_TYPE_UNSPECIFIED:- return nil, common.Errorf(common.Invalid, "activity type must not be unspecified")- case v1pb.Activity_ISSUE_CREATE:- result = append(result, string(common.EventTypeIssueCreate))- case v1pb.Activity_ISSUE_COMMENT_CREATE:- result = append(result, string(common.EventTypeIssueCommentCreate))- case v1pb.Activity_ISSUE_FIELD_UPDATE:- result = append(result, string(common.EventTypeIssueUpdate))- case v1pb.Activity_ISSUE_STATUS_UPDATE:- result = append(result, string(common.EventTypeIssueStatusUpdate))- case v1pb.Activity_ISSUE_APPROVAL_NOTIFY:- result = append(result, string(common.EventTypeIssueApprovalCreate))- case v1pb.Activity_ISSUE_PIPELINE_STAGE_STATUS_UPDATE:- result = append(result, string(common.EventTypeStageStatusUpdate))- case v1pb.Activity_ISSUE_PIPELINE_TASK_RUN_STATUS_UPDATE:- result = append(result, string(common.EventTypeTaskRunStatusUpdate))- case v1pb.Activity_NOTIFY_ISSUE_APPROVED:- result = append(result, string(common.EventTypeIssueApprovalPass))- case v1pb.Activity_NOTIFY_PIPELINE_ROLLOUT:- result = append(result, string(common.EventTypeIssueRolloutReady))- default:- return nil, common.Errorf(common.Invalid, "unsupported activity type: %v", tp)- }- }- return result, nil-}--func convertNotificationTypeStrings(types []string) []v1pb.Activity_Type {- var result []v1pb.Activity_Type- for _, tp := range types {- switch tp {- case string(common.EventTypeIssueCreate):- result = append(result, v1pb.Activity_ISSUE_CREATE)- case string(common.EventTypeIssueCommentCreate):- result = append(result, v1pb.Activity_ISSUE_COMMENT_CREATE)- case string(common.EventTypeIssueUpdate):- result = append(result, v1pb.Activity_ISSUE_FIELD_UPDATE)- case string(common.EventTypeIssueStatusUpdate):- result = append(result, v1pb.Activity_ISSUE_STATUS_UPDATE)- case string(common.EventTypeIssueApprovalCreate):- result = append(result, v1pb.Activity_ISSUE_APPROVAL_NOTIFY)- case string(common.EventTypeStageStatusUpdate):- result = append(result, v1pb.Activity_ISSUE_PIPELINE_STAGE_STATUS_UPDATE)- case string(common.EventTypeTaskRunStatusUpdate):- result = append(result, v1pb.Activity_ISSUE_PIPELINE_TASK_RUN_STATUS_UPDATE)- case string(common.EventTypeIssueApprovalPass):- result = append(result, v1pb.Activity_NOTIFY_ISSUE_APPROVED)- case string(common.EventTypeIssueRolloutReady):- result = append(result, v1pb.Activity_NOTIFY_PIPELINE_ROLLOUT)- default:- result = append(result, v1pb.Activity_TYPE_UNSPECIFIED)- }- }- return result-}--func convertToAPIWebhookTypeString(tp v1pb.Webhook_Type) (string, error) {- switch tp {- case v1pb.Webhook_TYPE_UNSPECIFIED:- return "", common.Errorf(common.Invalid, "webhook type must not be unspecified")- // TODO(zp): find a better way to place the "bb.plugin.webhook.*".- case v1pb.Webhook_SLACK:- return "bb.plugin.webhook.slack", nil- case v1pb.Webhook_DISCORD:- return "bb.plugin.webhook.discord", nil- case v1pb.Webhook_TEAMS:- return "bb.plugin.webhook.teams", nil- case v1pb.Webhook_DINGTALK:- return "bb.plugin.webhook.dingtalk", nil- case v1pb.Webhook_FEISHU:- return "bb.plugin.webhook.feishu", nil- case v1pb.Webhook_WECOM:- return "bb.plugin.webhook.wecom", nil- case v1pb.Webhook_LARK:- return "bb.plugin.webhook.lark", nil- default:- return "", common.Errorf(common.Invalid, "webhook type %q is not supported", tp)- }-}--func convertWebhookTypeString(tp string) v1pb.Webhook_Type {- switch tp {- case "bb.plugin.webhook.slack":- return v1pb.Webhook_SLACK- case "bb.plugin.webhook.discord":- return v1pb.Webhook_DISCORD- case "bb.plugin.webhook.teams":- return v1pb.Webhook_TEAMS- case "bb.plugin.webhook.dingtalk":- return v1pb.Webhook_DINGTALK- case "bb.plugin.webhook.feishu":- return v1pb.Webhook_FEISHU- case "bb.plugin.webhook.wecom":- return v1pb.Webhook_WECOM- case "bb.plugin.webhook.lark":- return v1pb.Webhook_LARK- default:- return v1pb.Webhook_TYPE_UNSPECIFIED- }-}-func (s *ProjectService) getProjectMessage(ctx context.Context, name string) (*store.ProjectMessage, error) {projectID, err := common.GetProjectID(name)if err != nil {@@ -1306,225 +1165,6 @@ func (s *ProjectService) getProjectMessage(ctx context.Context, name string) (*sreturn project, nil}-func convertToV1MemberInBinding(ctx context.Context, stores *store.Store, member string) string {- if strings.HasPrefix(member, common.UserNamePrefix) {- userUID, err := common.GetUserID(member)- if err != nil {- slog.Error("failed to user id from member", slog.String("member", member), log.BBError(err))- return ""- }- user, err := stores.GetUserByID(ctx, userUID)- if err != nil {- slog.Error("failed to get user", slog.String("member", member), log.BBError(err))- return ""- }- if user == nil {- return ""- }- return fmt.Sprintf("%s%s", common.UserBindingPrefix, user.Email)- } else if strings.HasPrefix(member, common.GroupPrefix) {- email, err := common.GetGroupEmail(member)- if err != nil {- slog.Error("failed to parse group email from member", slog.String("member", member), log.BBError(err))- return ""- }- return fmt.Sprintf("%s%s", common.GroupBindingPrefix, email)- }- // handle allUsers.- return member-}--func convertToV1IamPolicy(ctx context.Context, stores *store.Store, iamPolicy *store.IamPolicyMessage) (*v1pb.IamPolicy, error) {- var bindings []*v1pb.Binding-- for _, binding := range iamPolicy.Policy.Bindings {- var members []string- for _, member := range binding.Members {- memberInBinding := convertToV1MemberInBinding(ctx, stores, member)- if memberInBinding == "" {- continue- }- members = append(members, memberInBinding)- }- if len(members) == 0 {- continue- }- v1pbBinding := &v1pb.Binding{- Role: binding.Role,- Members: members,- Condition: binding.Condition,- }- if v1pbBinding.Condition == nil {- v1pbBinding.Condition = &expr.Expr{}- }- if v1pbBinding.Condition.Expression != "" {- e, err := cel.NewEnv(common.IAMPolicyConditionCELAttributes...)- if err != nil {- return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to create cel environment"))- }- ast, issues := e.Parse(v1pbBinding.Condition.Expression)- if issues != nil && issues.Err() != nil {- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to parse expression with error: %v", issues.Err()))- }- expr, err := cel.AstToParsedExpr(ast)- if err != nil {- return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to convert ast to parsed expression with error"))- }- v1pbBinding.ParsedExpr = expr.Expr- }- bindings = append(bindings, v1pbBinding)- }-- return &v1pb.IamPolicy{- Bindings: bindings,- Etag: iamPolicy.Etag,- }, nil-}--func convertToStoreIamPolicy(ctx context.Context, stores *store.Store, iamPolicy *v1pb.IamPolicy) (*storepb.IamPolicy, error) {- var bindings []*storepb.Binding-- for _, binding := range iamPolicy.Bindings {- var members []string- for _, member := range utils.Uniq(binding.Members) {- storeMember, err := convertToStoreIamPolicyMember(ctx, stores, member)- if err != nil {- return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to convert iam member with error"))- }- members = append(members, storeMember)- }- if len(members) == 0 {- continue- }-- storeBinding := &storepb.Binding{- Role: binding.Role,- Members: members,- Condition: binding.Condition,- }- if storeBinding.Condition == nil {- storeBinding.Condition = &expr.Expr{}- }- bindings = append(bindings, storeBinding)- }-- if len(bindings) == 0 {- return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("policy binding is empty"))- }-- return &storepb.IamPolicy{- Bindings: bindings,- }, nil-}--func convertToStoreIamPolicyMember(ctx context.Context, stores *store.Store, member string) (string, error) {- if strings.HasPrefix(member, common.UserBindingPrefix) {- email := strings.TrimPrefix(member, common.UserBindingPrefix)- user, err := stores.GetUserByEmail(ctx, email)- if err != nil {- return "", connect.NewError(connect.CodeInternal, err)- }- if user == nil {- return "", connect.NewError(connect.CodeNotFound, errors.Errorf("user %q not found", member))- }- return common.FormatUserUID(user.ID), nil- } else if strings.HasPrefix(member, common.GroupBindingPrefix) {- email := strings.TrimPrefix(member, common.GroupBindingPrefix)- return common.FormatGroupEmail(email), nil- } else if member == common.AllUsers {- return member, nil- }- return "", connect.NewError(connect.CodeInvalidArgument, errors.Errorf("unsupport member %s", member))-}--func convertToProject(projectMessage *store.ProjectMessage) *v1pb.Project {- var projectWebhooks []*v1pb.Webhook- for _, webhook := range projectMessage.Webhooks {- projectWebhooks = append(projectWebhooks, &v1pb.Webhook{- Name: fmt.Sprintf("%s/%s%d", common.FormatProject(projectMessage.ResourceID), common.WebhookIDPrefix, webhook.ID),- Type: convertWebhookTypeString(webhook.Type),- Title: webhook.Title,- Url: webhook.URL,- NotificationTypes: convertNotificationTypeStrings(webhook.Events),- DirectMessage: webhook.Payload.GetDirectMessage(),- })- }-- var issueLabels []*v1pb.Label- for _, label := range projectMessage.Setting.IssueLabels {- issueLabels = append(issueLabels, &v1pb.Label{- Value: label.Value,- Color: label.Color,- Group: label.Group,- })- }-- return &v1pb.Project{- Name: common.FormatProject(projectMessage.ResourceID),- State: convertDeletedToState(projectMessage.Deleted),- Title: projectMessage.Title,- Webhooks: projectWebhooks,- DataClassificationConfigId: projectMessage.DataClassificationConfigID,- IssueLabels: issueLabels,- ForceIssueLabels: projectMessage.Setting.ForceIssueLabels,- AllowModifyStatement: projectMessage.Setting.AllowModifyStatement,- AutoResolveIssue: projectMessage.Setting.AutoResolveIssue,- EnforceIssueTitle: projectMessage.Setting.EnforceIssueTitle,- EnforceSqlReview: projectMessage.Setting.EnforceSqlReview,- AutoEnableBackup: projectMessage.Setting.AutoEnableBackup,- SkipBackupErrors: projectMessage.Setting.SkipBackupErrors,- PostgresDatabaseTenantMode: projectMessage.Setting.PostgresDatabaseTenantMode,- AllowSelfApproval: projectMessage.Setting.AllowSelfApproval,- ExecutionRetryPolicy: convertToV1ExecutionRetryPolicy(projectMessage.Setting.ExecutionRetryPolicy),- CiSamplingSize: projectMessage.Setting.CiSamplingSize,- ParallelTasksPerRollout: projectMessage.Setting.ParallelTasksPerRollout,- Labels: projectMessage.Setting.Labels,- }-}--func convertToV1ExecutionRetryPolicy(policy *storepb.Project_ExecutionRetryPolicy) *v1pb.Project_ExecutionRetryPolicy {- if policy == nil {- return &v1pb.Project_ExecutionRetryPolicy{- MaximumRetries: 0,- }- }- return &v1pb.Project_ExecutionRetryPolicy{- MaximumRetries: policy.MaximumRetries,- }-}--func convertToStoreExecutionRetryPolicy(policy *v1pb.Project_ExecutionRetryPolicy) *storepb.Project_ExecutionRetryPolicy {- if policy == nil {- return &storepb.Project_ExecutionRetryPolicy{- MaximumRetries: 0,- }- }- return &storepb.Project_ExecutionRetryPolicy{- MaximumRetries: policy.MaximumRetries,- }-}--func convertToProjectMessage(resourceID string, project *v1pb.Project) *store.ProjectMessage {- setting := &storepb.Project{- AllowModifyStatement: project.AllowModifyStatement,- AutoResolveIssue: project.AutoResolveIssue,- EnforceIssueTitle: project.EnforceIssueTitle,- AutoEnableBackup: project.AutoEnableBackup,- SkipBackupErrors: project.SkipBackupErrors,- PostgresDatabaseTenantMode: project.PostgresDatabaseTenantMode,- AllowSelfApproval: project.AllowSelfApproval,- CiSamplingSize: project.CiSamplingSize,- ParallelTasksPerRollout: project.ParallelTasksPerRollout,- Labels: project.Labels,- EnforceSqlReview: project.EnforceSqlReview,- }- return &store.ProjectMessage{- ResourceID: resourceID,- Title: project.Title,- Setting: setting,- }-}-func getBindingIdentifier(role string, condition *expr.Expr) string {ids := []string{fmt.Sprintf("[role] %s", role),diff --git a/backend/api/v1/project_service_converter.go b/backend/api/v1/project_service_converter.gonew file mode 100644index 0000000000..31ab4a68de--- /dev/null+++ b/backend/api/v1/project_service_converter.go@@ -0,0 +1,379 @@+package v1++import (+ "context"+ "fmt"+ "log/slog"+ "strings"++ "connectrpc.com/connect"+ "github.com/google/cel-go/cel"+ "github.com/pkg/errors"+ "google.golang.org/genproto/googleapis/type/expr"+ "google.golang.org/protobuf/types/known/anypb"++ "github.com/bytebase/bytebase/backend/common"+ "github.com/bytebase/bytebase/backend/common/log"+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"+ "github.com/bytebase/bytebase/backend/store"+ "github.com/bytebase/bytebase/backend/utils"+)++func convertToProtoAny(i any) (*anypb.Any, error) {+ switch deltas := i.(type) {+ case []*v1pb.BindingDelta:+ auditData := v1pb.AuditData{+ PolicyDelta: &v1pb.PolicyDelta{+ BindingDeltas: deltas,+ },+ }+ return anypb.New(&auditData)+ default:+ return &anypb.Any{}, nil+ }+}++func convertToStoreProjectWebhookMessage(webhook *v1pb.Webhook) (*store.ProjectWebhookMessage, error) {+ tp, err := convertToAPIWebhookTypeString(webhook.Type)+ if err != nil {+ return nil, err+ }+ activityTypes, err := convertToActivityTypeStrings(webhook.NotificationTypes)+ if err != nil {+ return nil, err+ }+ return &store.ProjectWebhookMessage{+ Type: tp,+ URL: webhook.Url,+ Title: webhook.Title,+ Events: activityTypes,+ Payload: &storepb.ProjectWebhookPayload{+ DirectMessage: webhook.DirectMessage,+ },+ }, nil+}++func convertToActivityTypeStrings(types []v1pb.Activity_Type) ([]string, error) {+ var result []string+ for _, tp := range types {+ switch tp {+ case v1pb.Activity_TYPE_UNSPECIFIED:+ return nil, common.Errorf(common.Invalid, "activity type must not be unspecified")+ case v1pb.Activity_ISSUE_CREATE:+ result = append(result, string(common.EventTypeIssueCreate))+ case v1pb.Activity_ISSUE_COMMENT_CREATE:+ result = append(result, string(common.EventTypeIssueCommentCreate))+ case v1pb.Activity_ISSUE_FIELD_UPDATE:+ result = append(result, string(common.EventTypeIssueUpdate))+ case v1pb.Activity_ISSUE_STATUS_UPDATE:+ result = append(result, string(common.EventTypeIssueStatusUpdate))+ case v1pb.Activity_ISSUE_APPROVAL_NOTIFY:+ result = append(result, string(common.EventTypeIssueApprovalCreate))+ case v1pb.Activity_ISSUE_PIPELINE_STAGE_STATUS_UPDATE:+ result = append(result, string(common.EventTypeStageStatusUpdate))+ case v1pb.Activity_ISSUE_PIPELINE_TASK_RUN_STATUS_UPDATE:+ result = append(result, string(common.EventTypeTaskRunStatusUpdate))+ case v1pb.Activity_NOTIFY_ISSUE_APPROVED:+ result = append(result, string(common.EventTypeIssueApprovalPass))+ case v1pb.Activity_NOTIFY_PIPELINE_ROLLOUT:+ result = append(result, string(common.EventTypeIssueRolloutReady))+ default:+ return nil, common.Errorf(common.Invalid, "unsupported activity type: %v", tp)+ }+ }+ return result, nil+}++func convertNotificationTypeStrings(types []string) []v1pb.Activity_Type {+ var result []v1pb.Activity_Type+ for _, tp := range types {+ switch tp {+ case string(common.EventTypeIssueCreate):+ result = append(result, v1pb.Activity_ISSUE_CREATE)+ case string(common.EventTypeIssueCommentCreate):+ result = append(result, v1pb.Activity_ISSUE_COMMENT_CREATE)+ case string(common.EventTypeIssueUpdate):+ result = append(result, v1pb.Activity_ISSUE_FIELD_UPDATE)+ case string(common.EventTypeIssueStatusUpdate):+ result = append(result, v1pb.Activity_ISSUE_STATUS_UPDATE)+ case string(common.EventTypeIssueApprovalCreate):+ result = append(result, v1pb.Activity_ISSUE_APPROVAL_NOTIFY)+ case string(common.EventTypeStageStatusUpdate):+ result = append(result, v1pb.Activity_ISSUE_PIPELINE_STAGE_STATUS_UPDATE)+ case string(common.EventTypeTaskRunStatusUpdate):+ result = append(result, v1pb.Activity_ISSUE_PIPELINE_TASK_RUN_STATUS_UPDATE)+ case string(common.EventTypeIssueApprovalPass):+ result = append(result, v1pb.Activity_NOTIFY_ISSUE_APPROVED)+ case string(common.EventTypeIssueRolloutReady):+ result = append(result, v1pb.Activity_NOTIFY_PIPELINE_ROLLOUT)+ default:+ result = append(result, v1pb.Activity_TYPE_UNSPECIFIED)+ }+ }+ return result+}++func convertToAPIWebhookTypeString(tp v1pb.Webhook_Type) (string, error) {+ switch tp {+ case v1pb.Webhook_TYPE_UNSPECIFIED:+ return "", common.Errorf(common.Invalid, "webhook type must not be unspecified")+ // TODO(zp): find a better way to place the "bb.plugin.webhook.*".+ case v1pb.Webhook_SLACK:+ return "bb.plugin.webhook.slack", nil+ case v1pb.Webhook_DISCORD:+ return "bb.plugin.webhook.discord", nil+ case v1pb.Webhook_TEAMS:+ return "bb.plugin.webhook.teams", nil+ case v1pb.Webhook_DINGTALK:+ return "bb.plugin.webhook.dingtalk", nil+ case v1pb.Webhook_FEISHU:+ return "bb.plugin.webhook.feishu", nil+ case v1pb.Webhook_WECOM:+ return "bb.plugin.webhook.wecom", nil+ case v1pb.Webhook_LARK:+ return "bb.plugin.webhook.lark", nil+ default:+ return "", common.Errorf(common.Invalid, "webhook type %q is not supported", tp)+ }+}++func convertWebhookTypeString(tp string) v1pb.Webhook_Type {+ switch tp {+ case "bb.plugin.webhook.slack":+ return v1pb.Webhook_SLACK+ case "bb.plugin.webhook.discord":+ return v1pb.Webhook_DISCORD+ case "bb.plugin.webhook.teams":+ return v1pb.Webhook_TEAMS+ case "bb.plugin.webhook.dingtalk":+ return v1pb.Webhook_DINGTALK+ case "bb.plugin.webhook.feishu":+ return v1pb.Webhook_FEISHU+ case "bb.plugin.webhook.wecom":+ return v1pb.Webhook_WECOM+ case "bb.plugin.webhook.lark":+ return v1pb.Webhook_LARK+ default:+ return v1pb.Webhook_TYPE_UNSPECIFIED+ }+}++func convertToV1MemberInBinding(ctx context.Context, stores *store.Store, member string) string {+ if strings.HasPrefix(member, common.UserNamePrefix) {+ userUID, err := common.GetUserID(member)+ if err != nil {+ slog.Error("failed to user id from member", slog.String("member", member), log.BBError(err))+ return ""+ }+ user, err := stores.GetUserByID(ctx, userUID)+ if err != nil {+ slog.Error("failed to get user", slog.String("member", member), log.BBError(err))+ return ""+ }+ if user == nil {+ return ""+ }+ return fmt.Sprintf("%s%s", common.UserBindingPrefix, user.Email)+ } else if strings.HasPrefix(member, common.GroupPrefix) {+ email, err := common.GetGroupEmail(member)+ if err != nil {+ slog.Error("failed to parse group email from member", slog.String("member", member), log.BBError(err))+ return ""+ }+ return fmt.Sprintf("%s%s", common.GroupBindingPrefix, email)+ }+ // handle allUsers.+ return member+}++func convertToV1IamPolicy(ctx context.Context, stores *store.Store, iamPolicy *store.IamPolicyMessage) (*v1pb.IamPolicy, error) {+ var bindings []*v1pb.Binding++ for _, binding := range iamPolicy.Policy.Bindings {+ var members []string+ for _, member := range binding.Members {+ memberInBinding := convertToV1MemberInBinding(ctx, stores, member)+ if memberInBinding == "" {+ continue+ }+ members = append(members, memberInBinding)+ }+ if len(members) == 0 {+ continue+ }+ v1pbBinding := &v1pb.Binding{+ Role: binding.Role,+ Members: members,+ Condition: binding.Condition,+ }+ if v1pbBinding.Condition == nil {+ v1pbBinding.Condition = &expr.Expr{}+ }+ if v1pbBinding.Condition.Expression != "" {+ e, err := cel.NewEnv(common.IAMPolicyConditionCELAttributes...)+ if err != nil {+ return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to create cel environment"))+ }+ ast, issues := e.Parse(v1pbBinding.Condition.Expression)+ if issues != nil && issues.Err() != nil {+ return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to parse expression with error: %v", issues.Err()))+ }+ expr, err := cel.AstToParsedExpr(ast)+ if err != nil {+ return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to convert ast to parsed expression with error"))+ }+ v1pbBinding.ParsedExpr = expr.Expr+ }+ bindings = append(bindings, v1pbBinding)+ }++ return &v1pb.IamPolicy{+ Bindings: bindings,+ Etag: iamPolicy.Etag,+ }, nil+}++func convertToStoreIamPolicy(ctx context.Context, stores *store.Store, iamPolicy *v1pb.IamPolicy) (*storepb.IamPolicy, error) {+ var bindings []*storepb.Binding++ for _, binding := range iamPolicy.Bindings {+ var members []string+ for _, member := range utils.Uniq(binding.Members) {+ storeMember, err := convertToStoreIamPolicyMember(ctx, stores, member)+ if err != nil {+ return nil, connect.NewError(connect.CodeInternal, errors.Wrapf(err, "failed to convert iam member with error"))+ }+ members = append(members, storeMember)+ }+ if len(members) == 0 {+ continue+ }++ storeBinding := &storepb.Binding{+ Role: binding.Role,+ Members: members,+ Condition: binding.Condition,+ }+ if storeBinding.Condition == nil {+ storeBinding.Condition = &expr.Expr{}+ }+ bindings = append(bindings, storeBinding)+ }++ if len(bindings) == 0 {+ return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("policy binding is empty"))+ }++ return &storepb.IamPolicy{+ Bindings: bindings,+ }, nil+}++func convertToStoreIamPolicyMember(ctx context.Context, stores *store.Store, member string) (string, error) {+ if strings.HasPrefix(member, common.UserBindingPrefix) {+ email := strings.TrimPrefix(member, common.UserBindingPrefix)+ user, err := stores.GetUserByEmail(ctx, email)+ if err != nil {+ return "", connect.NewError(connect.CodeInternal, err)+ }+ if user == nil {+ return "", connect.NewError(connect.CodeNotFound, errors.Errorf("user %q not found", member))+ }+ return common.FormatUserUID(user.ID), nil+ } else if strings.HasPrefix(member, common.GroupBindingPrefix) {+ email := strings.TrimPrefix(member, common.GroupBindingPrefix)+ return common.FormatGroupEmail(email), nil+ } else if member == common.AllUsers {+ return member, nil+ }+ return "", connect.NewError(connect.CodeInvalidArgument, errors.Errorf("unsupport member %s", member))+}++func convertToProject(projectMessage *store.ProjectMessage) *v1pb.Project {+ var projectWebhooks []*v1pb.Webhook+ for _, webhook := range projectMessage.Webhooks {+ projectWebhooks = append(projectWebhooks, &v1pb.Webhook{+ Name: fmt.Sprintf("%s/%s%d", common.FormatProject(projectMessage.ResourceID), common.WebhookIDPrefix, webhook.ID),+ Type: convertWebhookTypeString(webhook.Type),+ Title: webhook.Title,+ Url: webhook.URL,+ NotificationTypes: convertNotificationTypeStrings(webhook.Events),+ DirectMessage: webhook.Payload.GetDirectMessage(),+ })+ }++ var issueLabels []*v1pb.Label+ for _, label := range projectMessage.Setting.IssueLabels {+ issueLabels = append(issueLabels, &v1pb.Label{+ Value: label.Value,+ Color: label.Color,+ Group: label.Group,+ })+ }++ return &v1pb.Project{+ Name: common.FormatProject(projectMessage.ResourceID),+ State: convertDeletedToState(projectMessage.Deleted),+ Title: projectMessage.Title,+ Webhooks: projectWebhooks,+ DataClassificationConfigId: projectMessage.DataClassificationConfigID,+ IssueLabels: issueLabels,+ ForceIssueLabels: projectMessage.Setting.ForceIssueLabels,+ AllowModifyStatement: projectMessage.Setting.AllowModifyStatement,+ AutoResolveIssue: projectMessage.Setting.AutoResolveIssue,+ EnforceIssueTitle: projectMessage.Setting.EnforceIssueTitle,+ EnforceSqlReview: projectMessage.Setting.EnforceSqlReview,+ AutoEnableBackup: projectMessage.Setting.AutoEnableBackup,+ SkipBackupErrors: projectMessage.Setting.SkipBackupErrors,+ PostgresDatabaseTenantMode: projectMessage.Setting.PostgresDatabaseTenantMode,+ AllowSelfApproval: projectMessage.Setting.AllowSelfApproval,+ ExecutionRetryPolicy: convertToV1ExecutionRetryPolicy(projectMessage.Setting.ExecutionRetryPolicy),+ CiSamplingSize: projectMessage.Setting.CiSamplingSize,+ ParallelTasksPerRollout: projectMessage.Setting.ParallelTasksPerRollout,+ Labels: projectMessage.Setting.Labels,+ }+}++func convertToV1ExecutionRetryPolicy(policy *storepb.Project_ExecutionRetryPolicy) *v1pb.Project_ExecutionRetryPolicy {+ if policy == nil {+ return &v1pb.Project_ExecutionRetryPolicy{+ MaximumRetries: 0,+ }+ }+ return &v1pb.Project_ExecutionRetryPolicy{+ MaximumRetries: policy.MaximumRetries,+ }+}++func convertToStoreExecutionRetryPolicy(policy *v1pb.Project_ExecutionRetryPolicy) *storepb.Project_ExecutionRetryPolicy {+ if policy == nil {+ return &storepb.Project_ExecutionRetryPolicy{+ MaximumRetries: 0,+ }+ }+ return &storepb.Project_ExecutionRetryPolicy{+ MaximumRetries: policy.MaximumRetries,+ }+}++func convertToProjectMessage(resourceID string, project *v1pb.Project) *store.ProjectMessage {+ setting := &storepb.Project{+ AllowModifyStatement: project.AllowModifyStatement,+ AutoResolveIssue: project.AutoResolveIssue,+ EnforceIssueTitle: project.EnforceIssueTitle,+ AutoEnableBackup: project.AutoEnableBackup,+ SkipBackupErrors: project.SkipBackupErrors,+ PostgresDatabaseTenantMode: project.PostgresDatabaseTenantMode,+ AllowSelfApproval: project.AllowSelfApproval,+ CiSamplingSize: project.CiSamplingSize,+ ParallelTasksPerRollout: project.ParallelTasksPerRollout,+ Labels: project.Labels,+ EnforceSqlReview: project.EnforceSqlReview,+ }+ return &store.ProjectMessage{+ ResourceID: resourceID,+ Title: project.Title,+ Setting: setting,+ }+}diff --git a/backend/api/v1/rollout_service_converter.go b/backend/api/v1/rollout_service_converter.goindex 515a895ffc..1e8ab6a888 100644--- a/backend/api/v1/rollout_service_converter.go+++ b/backend/api/v1/rollout_service_converter.go@@ -36,414 +36,6 @@ func formatEnvironmentFromStageID(stageID string) string {return stageID}-func convertToPlans(ctx context.Context, s *store.Store, plans []*store.PlanMessage) ([]*v1pb.Plan, error) {- v1Plans := make([]*v1pb.Plan, len(plans))- for i := range plans {- p, err := convertToPlan(ctx, s, plans[i])- if err != nil {- return nil, errors.Wrapf(err, "failed to convert plan")- }- v1Plans[i] = p- }- return v1Plans, nil-}--func convertToPlan(ctx context.Context, s *store.Store, plan *store.PlanMessage) (*v1pb.Plan, error) {- p := &v1pb.Plan{- Name: common.FormatPlan(plan.ProjectID, plan.UID),- Title: plan.Name,- Description: plan.Description,- Specs: convertToPlanSpecs(plan.Config.Specs), // Use specs field for output- Deployment: convertToPlanDeployment(plan.Config.Deployment),- CreateTime: timestamppb.New(plan.CreatedAt),- UpdateTime: timestamppb.New(plan.UpdatedAt),- State: convertDeletedToState(plan.Deleted),- PlanCheckRunStatusCount: map[string]int32{},- }-- creator, err := s.GetUserByID(ctx, plan.CreatorUID)- if err != nil {- return nil, errors.Wrapf(err, "failed to get plan creator")- }- p.Creator = common.FormatUserEmail(creator.Email)-- issue, err := s.GetIssueV2(ctx, &store.FindIssueMessage{PlanUID: &plan.UID})- if err != nil {- return nil, errors.Wrapf(err, "failed to get issue by plan uid %d", plan.UID)- }- if issue != nil {- p.Issue = common.FormatIssue(issue.Project.ResourceID, issue.UID)- }- if plan.PipelineUID != nil {- p.Rollout = common.FormatRollout(plan.ProjectID, *plan.PipelineUID)- }- planCheckRuns, err := s.ListPlanCheckRuns(ctx, &store.FindPlanCheckRunMessage{- PlanUID: &plan.UID,- })- if err != nil {- return nil, errors.Wrapf(err, "failed to list plan check runs for plan uid %d", plan.UID)- }- for _, run := range planCheckRuns {- p.PlanCheckRunStatusCount[string(run.Status)]++- for _, result := range run.Result.Results {- p.PlanCheckRunStatusCount[storepb.Advice_Status_name[int32(result.Status)]]++- }- }- return p, nil-}--func convertToPlanSpecs(specs []*storepb.PlanConfig_Spec) []*v1pb.Plan_Spec {- v1Specs := make([]*v1pb.Plan_Spec, len(specs))- for i := range specs {- v1Specs[i] = convertToPlanSpec(specs[i])- }- return v1Specs-}--func convertToPlanSpec(spec *storepb.PlanConfig_Spec) *v1pb.Plan_Spec {- v1Spec := &v1pb.Plan_Spec{- Id: spec.Id,- }-- switch v := spec.Config.(type) {- case *storepb.PlanConfig_Spec_CreateDatabaseConfig:- v1Spec.Config = convertToPlanSpecCreateDatabaseConfig(v)- case *storepb.PlanConfig_Spec_ChangeDatabaseConfig:- v1Spec.Config = convertToPlanSpecChangeDatabaseConfig(v)- case *storepb.PlanConfig_Spec_ExportDataConfig:- v1Spec.Config = convertToPlanSpecExportDataConfig(v)- }-- return v1Spec-}--func convertToPlanSpecCreateDatabaseConfig(config *storepb.PlanConfig_Spec_CreateDatabaseConfig) *v1pb.Plan_Spec_CreateDatabaseConfig {- c := config.CreateDatabaseConfig- return &v1pb.Plan_Spec_CreateDatabaseConfig{- CreateDatabaseConfig: &v1pb.Plan_CreateDatabaseConfig{- Target: c.Target,- Database: c.Database,- Table: c.Table,- CharacterSet: c.CharacterSet,- Collation: c.Collation,- Cluster: c.Cluster,- Owner: c.Owner,- Environment: c.Environment,- },- }-}--func convertToPlanSpecChangeDatabaseConfig(config *storepb.PlanConfig_Spec_ChangeDatabaseConfig) *v1pb.Plan_Spec_ChangeDatabaseConfig {- c := config.ChangeDatabaseConfig- return &v1pb.Plan_Spec_ChangeDatabaseConfig{- ChangeDatabaseConfig: &v1pb.Plan_ChangeDatabaseConfig{- Targets: c.Targets,- Sheet: c.Sheet,- Release: c.Release,- Type: convertToPlanSpecChangeDatabaseConfigType(c.Type),- MigrationType: convertToPlanSpecMigrationType(c.MigrateType),- GhostFlags: c.GhostFlags,- EnablePriorBackup: c.EnablePriorBackup,- },- }-}--func convertToPlanSpecChangeDatabaseConfigType(t storepb.PlanConfig_ChangeDatabaseConfig_Type) v1pb.DatabaseChangeType {- switch t {- case storepb.PlanConfig_ChangeDatabaseConfig_TYPE_UNSPECIFIED:- return v1pb.DatabaseChangeType_DATABASE_CHANGE_TYPE_UNSPECIFIED- case storepb.PlanConfig_ChangeDatabaseConfig_MIGRATE:- return v1pb.DatabaseChangeType_MIGRATE- case storepb.PlanConfig_ChangeDatabaseConfig_SDL:- return v1pb.DatabaseChangeType_SDL- default:- return v1pb.DatabaseChangeType_DATABASE_CHANGE_TYPE_UNSPECIFIED- }-}--func convertToPlanSpecMigrationType(t storepb.MigrationType) v1pb.MigrationType {- switch t {- case storepb.MigrationType_DDL:- return v1pb.MigrationType_DDL- case storepb.MigrationType_GHOST:- return v1pb.MigrationType_GHOST- case storepb.MigrationType_DML:- return v1pb.MigrationType_DML- default:- return v1pb.MigrationType_MIGRATION_TYPE_UNSPECIFIED- }-}--func convertToPlanSpecExportDataConfig(config *storepb.PlanConfig_Spec_ExportDataConfig) *v1pb.Plan_Spec_ExportDataConfig {- c := config.ExportDataConfig- return &v1pb.Plan_Spec_ExportDataConfig{- ExportDataConfig: &v1pb.Plan_ExportDataConfig{- Targets: c.Targets,- Sheet: c.Sheet,- Format: convertExportFormat(c.Format),- Password: c.Password,- },- }-}--func convertToPlanDeployment(deployment *storepb.PlanConfig_Deployment) *v1pb.Plan_Deployment {- if deployment == nil {- return nil- }- return &v1pb.Plan_Deployment{- Environments: deployment.Environments,- DatabaseGroupMappings: convertToDatabaseGroupMappings(deployment.DatabaseGroupMappings),- }-}--func convertToDatabaseGroupMappings(mappings []*storepb.PlanConfig_Deployment_DatabaseGroupMapping) []*v1pb.Plan_Deployment_DatabaseGroupMapping {- v1Mappings := make([]*v1pb.Plan_Deployment_DatabaseGroupMapping, len(mappings))- for i := range mappings {- v1Mappings[i] = convertToDatabaseGroupMapping(mappings[i])- }- return v1Mappings-}--func convertToDatabaseGroupMapping(mapping *storepb.PlanConfig_Deployment_DatabaseGroupMapping) *v1pb.Plan_Deployment_DatabaseGroupMapping {- if mapping == nil {- return nil- }- return &v1pb.Plan_Deployment_DatabaseGroupMapping{- DatabaseGroup: mapping.DatabaseGroup,- Databases: mapping.Databases,- }-}--func convertPlan(plan *v1pb.Plan) *storepb.PlanConfig {- if plan == nil {- return nil- }-- // At this point, plan.Specs should always be populated- // (either originally or converted from steps at API entry point)- return &storepb.PlanConfig{- Specs: convertPlanSpecs(plan.Specs),- Deployment: nil,- }-}--func convertPlanSpecs(specs []*v1pb.Plan_Spec) []*storepb.PlanConfig_Spec {- storeSpecs := make([]*storepb.PlanConfig_Spec, len(specs))- for i := range specs {- storeSpecs[i] = convertPlanSpec(specs[i])- }- return storeSpecs-}--func convertPlanSpec(spec *v1pb.Plan_Spec) *storepb.PlanConfig_Spec {- storeSpec := &storepb.PlanConfig_Spec{- Id: spec.Id,- }-- switch v := spec.Config.(type) {- case *v1pb.Plan_Spec_CreateDatabaseConfig:- storeSpec.Config = convertPlanSpecCreateDatabaseConfig(v)- case *v1pb.Plan_Spec_ChangeDatabaseConfig:- storeSpec.Config = convertPlanSpecChangeDatabaseConfig(v)- case *v1pb.Plan_Spec_ExportDataConfig:- storeSpec.Config = convertPlanSpecExportDataConfig(v)- }- return storeSpec-}--func convertPlanSpecCreateDatabaseConfig(config *v1pb.Plan_Spec_CreateDatabaseConfig) *storepb.PlanConfig_Spec_CreateDatabaseConfig {- c := config.CreateDatabaseConfig- return &storepb.PlanConfig_Spec_CreateDatabaseConfig{- CreateDatabaseConfig: convertPlanConfigCreateDatabaseConfig(c),- }-}--func convertPlanConfigCreateDatabaseConfig(c *v1pb.Plan_CreateDatabaseConfig) *storepb.PlanConfig_CreateDatabaseConfig {- return &storepb.PlanConfig_CreateDatabaseConfig{- Target: c.Target,- Database: c.Database,- Table: c.Table,- CharacterSet: c.CharacterSet,- Collation: c.Collation,- Cluster: c.Cluster,- Owner: c.Owner,- Environment: c.Environment,- }-}--func convertPlanSpecChangeDatabaseConfig(config *v1pb.Plan_Spec_ChangeDatabaseConfig) *storepb.PlanConfig_Spec_ChangeDatabaseConfig {- c := config.ChangeDatabaseConfig-- // Convert v1 DatabaseChangeType to store Type- var storeType storepb.PlanConfig_ChangeDatabaseConfig_Type- switch c.Type {- case v1pb.DatabaseChangeType_MIGRATE:- storeType = storepb.PlanConfig_ChangeDatabaseConfig_MIGRATE- case v1pb.DatabaseChangeType_SDL:- storeType = storepb.PlanConfig_ChangeDatabaseConfig_SDL- default:- storeType = storepb.PlanConfig_ChangeDatabaseConfig_TYPE_UNSPECIFIED- }-- // Convert v1 MigrationType to store MigrateType- var storeMigrateType storepb.MigrationType- switch c.MigrationType {- case v1pb.MigrationType_DDL:- storeMigrateType = storepb.MigrationType_DDL- case v1pb.MigrationType_DML:- storeMigrateType = storepb.MigrationType_DML- case v1pb.MigrationType_GHOST:- storeMigrateType = storepb.MigrationType_GHOST- default:- storeMigrateType = storepb.MigrationType_MIGRATION_TYPE_UNSPECIFIED- }-- return &storepb.PlanConfig_Spec_ChangeDatabaseConfig{- ChangeDatabaseConfig: &storepb.PlanConfig_ChangeDatabaseConfig{- Targets: c.Targets,- Sheet: c.Sheet,- Release: c.Release,- Type: storeType,- MigrateType: storeMigrateType,- GhostFlags: c.GhostFlags,- EnablePriorBackup: c.EnablePriorBackup,- },- }-}--func convertPlanSpecExportDataConfig(config *v1pb.Plan_Spec_ExportDataConfig) *storepb.PlanConfig_Spec_ExportDataConfig {- c := config.ExportDataConfig- return &storepb.PlanConfig_Spec_ExportDataConfig{- ExportDataConfig: &storepb.PlanConfig_ExportDataConfig{- Targets: c.Targets,- Sheet: c.Sheet,- Format: convertToExportFormat(c.Format),- Password: c.Password,- },- }-}--func convertToPlanCheckRuns(ctx context.Context, s *store.Store, projectID string, planUID int64, runs []*store.PlanCheckRunMessage) ([]*v1pb.PlanCheckRun, error) {- var planCheckRuns []*v1pb.PlanCheckRun- for _, run := range runs {- converted, err := convertToPlanCheckRun(ctx, s, projectID, planUID, run)- if err != nil {- return nil, errors.Wrapf(err, "failed to convert plan check run")- }- planCheckRuns = append(planCheckRuns, converted)- }- return planCheckRuns, nil-}--func convertToPlanCheckRun(ctx context.Context, s *store.Store, projectID string, planUID int64, run *store.PlanCheckRunMessage) (*v1pb.PlanCheckRun, error) {- converted := &v1pb.PlanCheckRun{- Name: common.FormatPlanCheckRun(projectID, planUID, int64(run.UID)),- CreateTime: timestamppb.New(run.CreatedAt),- Type: convertToPlanCheckRunType(run.Type),- Status: convertToPlanCheckRunStatus(run.Status),- Target: common.FormatDatabase(run.Config.InstanceId, run.Config.DatabaseName),- Sheet: "",- Results: convertToPlanCheckRunResults(run.Result.Results),- Error: run.Result.Error,- }-- if sheetUID := int(run.Config.GetSheetUid()); sheetUID != 0 {- sheet, err := s.GetSheet(ctx, &store.FindSheetMessage{UID: &sheetUID})- if err != nil {- return nil, errors.Wrapf(err, "failed to get sheet")- }- if sheet == nil {- return nil, errors.Errorf("sheet not found for uid %d", sheetUID)- }- converted.Sheet = common.FormatSheet(projectID, sheet.UID)- }-- return converted, nil-}--func convertToPlanCheckRunType(t store.PlanCheckRunType) v1pb.PlanCheckRun_Type {- switch t {- case store.PlanCheckDatabaseStatementFakeAdvise:- return v1pb.PlanCheckRun_DATABASE_STATEMENT_FAKE_ADVISE- case store.PlanCheckDatabaseStatementAdvise:- return v1pb.PlanCheckRun_DATABASE_STATEMENT_ADVISE- case store.PlanCheckDatabaseStatementSummaryReport:- return v1pb.PlanCheckRun_DATABASE_STATEMENT_SUMMARY_REPORT- case store.PlanCheckDatabaseConnect:- return v1pb.PlanCheckRun_DATABASE_CONNECT- case store.PlanCheckDatabaseGhostSync:- return v1pb.PlanCheckRun_DATABASE_GHOST_SYNC- default:- return v1pb.PlanCheckRun_TYPE_UNSPECIFIED- }-}--func convertToPlanCheckRunStatus(status store.PlanCheckRunStatus) v1pb.PlanCheckRun_Status {- switch status {- case store.PlanCheckRunStatusCanceled:- return v1pb.PlanCheckRun_CANCELED- case store.PlanCheckRunStatusDone:- return v1pb.PlanCheckRun_DONE- case store.PlanCheckRunStatusFailed:- return v1pb.PlanCheckRun_FAILED- case store.PlanCheckRunStatusRunning:- return v1pb.PlanCheckRun_RUNNING- default:- return v1pb.PlanCheckRun_STATUS_UNSPECIFIED- }-}--func convertToPlanCheckRunResults(results []*storepb.PlanCheckRunResult_Result) []*v1pb.PlanCheckRun_Result {- var resultsV1 []*v1pb.PlanCheckRun_Result- for _, result := range results {- resultsV1 = append(resultsV1, convertToPlanCheckRunResult(result))- }- return resultsV1-}--func convertToPlanCheckRunResult(result *storepb.PlanCheckRunResult_Result) *v1pb.PlanCheckRun_Result {- resultV1 := &v1pb.PlanCheckRun_Result{- Status: convertToPlanCheckRunResultStatus(result.Status),- Title: result.Title,- Content: result.Content,- Code: result.Code,- Report: nil,- }- switch report := result.Report.(type) {- case *storepb.PlanCheckRunResult_Result_SqlSummaryReport_:- resultV1.Report = &v1pb.PlanCheckRun_Result_SqlSummaryReport_{- SqlSummaryReport: &v1pb.PlanCheckRun_Result_SqlSummaryReport{- StatementTypes: report.SqlSummaryReport.StatementTypes,- AffectedRows: report.SqlSummaryReport.AffectedRows,- ChangedResources: convertToChangedResources(report.SqlSummaryReport.ChangedResources),- },- }- case *storepb.PlanCheckRunResult_Result_SqlReviewReport_:- resultV1.Report = &v1pb.PlanCheckRun_Result_SqlReviewReport_{- SqlReviewReport: &v1pb.PlanCheckRun_Result_SqlReviewReport{- StartPosition: convertToPosition(report.SqlReviewReport.StartPosition),- EndPosition: convertToPosition(report.SqlReviewReport.EndPosition),- },- }- }- return resultV1-}--func convertToPlanCheckRunResultStatus(status storepb.Advice_Status) v1pb.Advice_Level {- switch status {- case storepb.Advice_STATUS_UNSPECIFIED:- return v1pb.Advice_ADVICE_LEVEL_UNSPECIFIED- case storepb.Advice_SUCCESS:- return v1pb.Advice_SUCCESS- case storepb.Advice_WARNING:- return v1pb.Advice_WARNING- case storepb.Advice_ERROR:- return v1pb.Advice_ERROR- default:- return v1pb.Advice_ADVICE_LEVEL_UNSPECIFIED- }-}-func convertToTaskRuns(ctx context.Context, s *store.Store, stateCfg *state.State, taskRuns []*store.TaskRunMessage) ([]*v1pb.TaskRun, error) {var taskRunsV1 []*v1pb.TaskRunfor _, taskRun := range taskRuns {diff --git a/backend/api/v1/setting_service.go b/backend/api/v1/setting_service.goindex 95306fed63..61e949ef8c 100644--- a/backend/api/v1/setting_service.go+++ b/backend/api/v1/setting_service.go@@ -2,7 +2,6 @@ package v1import ("context"- "fmt""log/slog""regexp""time"@@ -556,179 +555,32 @@ func (s *SettingService) UpdateSetting(ctx context.Context, request *connect.Reqreturn connect.NewResponse(settingMessage), nil}-func convertToSettingMessage(setting *store.SettingMessage, profile *config.Profile) (*v1pb.Setting, error) {- settingName := fmt.Sprintf("%s%s", common.SettingNamePrefix, convertStoreSettingNameToV1(setting.Name).String())- switch setting.Name {- case storepb.SettingName_APP_IM:- storeValue := new(storepb.AppIMSetting)- if err := common.ProtojsonUnmarshaler.Unmarshal([]byte(setting.Value), storeValue); err != nil {- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to unmarshal setting value for %s with error: %v", setting.Name, err))- }- return &v1pb.Setting{- Name: settingName,- Value: &v1pb.Value{- Value: &v1pb.Value_AppImSettingValue{- AppImSettingValue: &v1pb.AppIMSetting{- Slack: &v1pb.AppIMSetting_Slack{- Enabled: storeValue.GetSlack().GetEnabled(),- },- Feishu: &v1pb.AppIMSetting_Feishu{- Enabled: storeValue.GetFeishu().GetEnabled(),- },- Wecom: &v1pb.AppIMSetting_Wecom{- Enabled: storeValue.GetWecom().GetEnabled(),- },- Lark: &v1pb.AppIMSetting_Lark{- Enabled: storeValue.GetLark().GetEnabled(),- },- Dingtalk: &v1pb.AppIMSetting_DingTalk{- Enabled: storeValue.GetDingtalk().GetEnabled(),- },- },- },- },- }, nil- case storepb.SettingName_WORKSPACE_PROFILE:- storeValue := new(storepb.WorkspaceProfileSetting)- if err := common.ProtojsonUnmarshaler.Unmarshal([]byte(setting.Value), storeValue); err != nil {- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to unmarshal setting value for %s with error: %v", setting.Name, err))- }- v1Value := convertToWorkspaceProfileSetting(storeValue)- v1Value.DisallowSignup = v1Value.DisallowSignup || profile.SaaS- return &v1pb.Setting{- Name: settingName,- Value: &v1pb.Value{- Value: &v1pb.Value_WorkspaceProfileSettingValue{- WorkspaceProfileSettingValue: v1Value,- },- },- }, nil- case storepb.SettingName_WORKSPACE_APPROVAL:- storeValue := new(storepb.WorkspaceApprovalSetting)- if err := common.ProtojsonUnmarshaler.Unmarshal([]byte(setting.Value), storeValue); err != nil {- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to unmarshal setting value for %s with error: %v", setting.Name, err))- }- v1Value := &v1pb.WorkspaceApprovalSetting{}- for _, rule := range storeValue.Rules {- template := convertToApprovalTemplate(rule.Template)- v1Value.Rules = append(v1Value.Rules, &v1pb.WorkspaceApprovalSetting_Rule{- Condition: rule.Condition,- Template: template,- })- }- return &v1pb.Setting{- Name: settingName,- Value: &v1pb.Value{- Value: &v1pb.Value_WorkspaceApprovalSettingValue{- WorkspaceApprovalSettingValue: v1Value,- },- },- }, nil- case storepb.SettingName_SCHEMA_TEMPLATE:- storeValue := new(storepb.SchemaTemplateSetting)- if err := common.ProtojsonUnmarshaler.Unmarshal([]byte(setting.Value), storeValue); err != nil {- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to unmarshal setting value for %s with error: %v", setting.Name, err))- }-- sts := convertToSchemaTemplateSetting(storeValue)- return &v1pb.Setting{- Name: settingName,- Value: &v1pb.Value{- Value: &v1pb.Value_SchemaTemplateSettingValue{- SchemaTemplateSettingValue: sts,- },- },- }, nil- case storepb.SettingName_DATA_CLASSIFICATION:- storeValue := new(storepb.DataClassificationSetting)- if err := common.ProtojsonUnmarshaler.Unmarshal([]byte(setting.Value), storeValue); err != nil {- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to unmarshal setting value for %s with error: %v", setting.Name, err))- }- return &v1pb.Setting{- Name: settingName,- Value: &v1pb.Value{- Value: &v1pb.Value_DataClassificationSettingValue{- DataClassificationSettingValue: convertToDataClassificationSetting(storeValue),- },- },- }, nil- case storepb.SettingName_SEMANTIC_TYPES:- storeValue := new(storepb.SemanticTypeSetting)- if err := common.ProtojsonUnmarshaler.Unmarshal([]byte(setting.Value), storeValue); err != nil {- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to unmarshal setting value for %s with error: %v", setting.Name, err))- }- return &v1pb.Setting{- Name: settingName,- Value: &v1pb.Value{- Value: &v1pb.Value_SemanticTypeSettingValue{- SemanticTypeSettingValue: convertToSemanticTypeSetting(storeValue),- },- },- }, nil- case storepb.SettingName_SCIM:- storeValue := new(storepb.SCIMSetting)- if err := common.ProtojsonUnmarshaler.Unmarshal([]byte(setting.Value), storeValue); err != nil {- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to unmarshal setting value for %s with error: %v", setting.Name, err))- }- return &v1pb.Setting{- Name: settingName,- Value: &v1pb.Value{- Value: &v1pb.Value_ScimSetting{- ScimSetting: convertToSCIMSetting(storeValue),- },- },- }, nil- case storepb.SettingName_PASSWORD_RESTRICTION:- storeValue := new(storepb.PasswordRestrictionSetting)- if err := common.ProtojsonUnmarshaler.Unmarshal([]byte(setting.Value), storeValue); err != nil {- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to unmarshal setting value for %s with error: %v", setting.Name, err))- }- return &v1pb.Setting{- Name: settingName,- Value: &v1pb.Value{- Value: &v1pb.Value_PasswordRestrictionSetting{- PasswordRestrictionSetting: convertToPasswordRestrictionSetting(storeValue),- },- },- }, nil- case storepb.SettingName_AI:- storeValue := new(storepb.AISetting)- if err := common.ProtojsonUnmarshaler.Unmarshal([]byte(setting.Value), storeValue); err != nil {- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to unmarshal setting value for %s with error: %v", setting.Name, err))- }- // DO NOT expose the api key.- storeValue.ApiKey = ""- return &v1pb.Setting{- Name: settingName,- Value: &v1pb.Value{- Value: &v1pb.Value_AiSetting{- AiSetting: convertToAISetting(storeValue),- },- },- }, nil- case storepb.SettingName_ENVIRONMENT:- storeValue, err := convertToEnvironmentSetting(setting.Value)- if err != nil {- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to convert setting value for %s with error: %v", setting.Name, err))- }- return &v1pb.Setting{- Name: settingName,- Value: &v1pb.Value{- Value: &v1pb.Value_EnvironmentSetting{- EnvironmentSetting: storeValue,- },- },- }, nil- default:- return &v1pb.Setting{- Name: settingName,- Value: &v1pb.Value{- Value: &v1pb.Value_StringValue{- StringValue: setting.Value,- },- },- }, nil- }+var domainRegexp = regexp.MustCompile(`^(?i:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,}$`)+var disallowedDomains = map[string]bool{+ "gmail.com": true,+ "googlemail.com": true,+ "outlook.com": true,+ "hotmail.com": true,+ "live.com": true,+ "msn.com": true,+ "icloud.com": true,+ "me.com": true,+ "mac.com": true,+ "yahoo.com": true,+ "ymail.com": true,+ "rocketmail.com": true,+ "aol.com": true,+ "aim.com": true,+ "protonmail.com": true,+ "pm.me": true,+ "zoho.com": true,+ "mail.com": true,+ "gmx.com": true,+ "gmx.net": true,+ "163.com": true,+ "126.com": true,+ "qq.com": true,+ "yeah.net": true,}func (s *SettingService) validateSchemaTemplate(ctx context.Context, schemaTemplateSetting *v1pb.SchemaTemplateSetting) error {@@ -815,106 +667,6 @@ func settingInWhitelist(name storepb.SettingName) bool {return false}-// convertStringToSettingName converts a string to storepb.SettingName.-// It first converts to v1pb.Setting_SettingName, then to storepb.SettingName.-func convertStringToSettingName(name string) (storepb.SettingName, error) {- // First try to convert string to v1pb.Setting_SettingName- v1Value, ok := v1pb.Setting_SettingName_value[name]- if !ok {- return storepb.SettingName_SETTING_NAME_UNSPECIFIED, errors.Errorf("invalid setting name: %s", name)- }- v1SettingName := v1pb.Setting_SettingName(v1Value)-- // Then convert v1pb to storepb- return convertV1SettingNameToStore(v1SettingName), nil-}--// convertStoreSettingNameToV1 converts storepb.SettingName to v1pb.Setting_SettingName.-func convertStoreSettingNameToV1(storeName storepb.SettingName) v1pb.Setting_SettingName {- //exhaustive:enforce- switch storeName {- case storepb.SettingName_SETTING_NAME_UNSPECIFIED:- return v1pb.Setting_SETTING_NAME_UNSPECIFIED- case storepb.SettingName_AUTH_SECRET:- return v1pb.Setting_AUTH_SECRET- case storepb.SettingName_BRANDING_LOGO:- return v1pb.Setting_BRANDING_LOGO- case storepb.SettingName_WORKSPACE_ID:- return v1pb.Setting_WORKSPACE_ID- case storepb.SettingName_WORKSPACE_PROFILE:- return v1pb.Setting_WORKSPACE_PROFILE- case storepb.SettingName_WORKSPACE_APPROVAL:- return v1pb.Setting_WORKSPACE_APPROVAL- case storepb.SettingName_WORKSPACE_EXTERNAL_APPROVAL:- return v1pb.Setting_WORKSPACE_EXTERNAL_APPROVAL- case storepb.SettingName_ENTERPRISE_LICENSE:- return v1pb.Setting_ENTERPRISE_LICENSE- case storepb.SettingName_APP_IM:- return v1pb.Setting_APP_IM- case storepb.SettingName_WATERMARK:- return v1pb.Setting_WATERMARK- case storepb.SettingName_AI:- return v1pb.Setting_AI- case storepb.SettingName_SCHEMA_TEMPLATE:- return v1pb.Setting_SCHEMA_TEMPLATE- case storepb.SettingName_DATA_CLASSIFICATION:- return v1pb.Setting_DATA_CLASSIFICATION- case storepb.SettingName_SEMANTIC_TYPES:- return v1pb.Setting_SEMANTIC_TYPES- case storepb.SettingName_SCIM:- return v1pb.Setting_SCIM- case storepb.SettingName_PASSWORD_RESTRICTION:- return v1pb.Setting_PASSWORD_RESTRICTION- case storepb.SettingName_ENVIRONMENT:- return v1pb.Setting_ENVIRONMENT- default:- }- return v1pb.Setting_SETTING_NAME_UNSPECIFIED-}--// convertV1SettingNameToStore converts v1pb.Setting_SettingName to storepb.SettingName.-func convertV1SettingNameToStore(v1Name v1pb.Setting_SettingName) storepb.SettingName {- //exhaustive:enforce- switch v1Name {- case v1pb.Setting_SETTING_NAME_UNSPECIFIED:- return storepb.SettingName_SETTING_NAME_UNSPECIFIED- case v1pb.Setting_AUTH_SECRET:- return storepb.SettingName_AUTH_SECRET- case v1pb.Setting_BRANDING_LOGO:- return storepb.SettingName_BRANDING_LOGO- case v1pb.Setting_WORKSPACE_ID:- return storepb.SettingName_WORKSPACE_ID- case v1pb.Setting_WORKSPACE_PROFILE:- return storepb.SettingName_WORKSPACE_PROFILE- case v1pb.Setting_WORKSPACE_APPROVAL:- return storepb.SettingName_WORKSPACE_APPROVAL- case v1pb.Setting_WORKSPACE_EXTERNAL_APPROVAL:- return storepb.SettingName_WORKSPACE_EXTERNAL_APPROVAL- case v1pb.Setting_ENTERPRISE_LICENSE:- return storepb.SettingName_ENTERPRISE_LICENSE- case v1pb.Setting_APP_IM:- return storepb.SettingName_APP_IM- case v1pb.Setting_WATERMARK:- return storepb.SettingName_WATERMARK- case v1pb.Setting_AI:- return storepb.SettingName_AI- case v1pb.Setting_SCHEMA_TEMPLATE:- return storepb.SettingName_SCHEMA_TEMPLATE- case v1pb.Setting_DATA_CLASSIFICATION:- return storepb.SettingName_DATA_CLASSIFICATION- case v1pb.Setting_SEMANTIC_TYPES:- return storepb.SettingName_SEMANTIC_TYPES- case v1pb.Setting_SCIM:- return storepb.SettingName_SCIM- case v1pb.Setting_PASSWORD_RESTRICTION:- return storepb.SettingName_PASSWORD_RESTRICTION- case v1pb.Setting_ENVIRONMENT:- return storepb.SettingName_ENVIRONMENT- default:- return storepb.SettingName_SETTING_NAME_UNSPECIFIED- }-}-func validateApprovalTemplate(template *v1pb.ApprovalTemplate) error {if template.Flow == nil {return errors.Errorf("approval template cannot be nil")@@ -925,138 +677,6 @@ func validateApprovalTemplate(template *v1pb.ApprovalTemplate) error {return nil}-func convertToSchemaTemplateSetting(template *storepb.SchemaTemplateSetting) *v1pb.SchemaTemplateSetting {- v1Setting := new(v1pb.SchemaTemplateSetting)- for _, v := range template.ColumnTypes {- v1Setting.ColumnTypes = append(v1Setting.ColumnTypes, &v1pb.SchemaTemplateSetting_ColumnType{- Engine: convertToEngine(v.Engine),- Enabled: v.Enabled,- Types: v.Types,- })- }- for _, v := range template.FieldTemplates {- if v == nil {- continue- }- t := &v1pb.SchemaTemplateSetting_FieldTemplate{- Id: v.Id,- Engine: convertToEngine(v.Engine),- Category: v.Category,- }- if v.Column != nil {- t.Column = convertStoreColumnMetadata(v.Column)- }- if v.Catalog != nil {- t.Catalog = convertColumnCatalog(v.Catalog)- }- v1Setting.FieldTemplates = append(v1Setting.FieldTemplates, t)- }- for _, v := range template.TableTemplates {- if v == nil {- continue- }- t := &v1pb.SchemaTemplateSetting_TableTemplate{- Id: v.Id,- Engine: convertToEngine(v.Engine),- Category: v.Category,- }- if v.Table != nil {- t.Table = convertStoreTableMetadata(v.Table)- }- if v.Catalog != nil {- t.Catalog = convertTableCatalog(v.Catalog)- }- v1Setting.TableTemplates = append(v1Setting.TableTemplates, t)- }-- return v1Setting-}--func convertV1SchemaTemplateSetting(template *v1pb.SchemaTemplateSetting) *storepb.SchemaTemplateSetting {- v1Setting := new(storepb.SchemaTemplateSetting)- for _, v := range template.ColumnTypes {- v1Setting.ColumnTypes = append(v1Setting.ColumnTypes, &storepb.SchemaTemplateSetting_ColumnType{- Engine: convertEngine(v.Engine),- Enabled: v.Enabled,- Types: v.Types,- })- }- for _, v := range template.FieldTemplates {- if v == nil {- continue- }- t := &storepb.SchemaTemplateSetting_FieldTemplate{- Id: v.Id,- Engine: convertEngine(v.Engine),- Category: v.Category,- }- if v.Column != nil {- t.Column = convertV1ColumnMetadata(v.Column)- }- if v.Catalog != nil {- t.Catalog = convertV1ColumnCatalog(v.Catalog)- }- v1Setting.FieldTemplates = append(v1Setting.FieldTemplates, t)- }- for _, v := range template.TableTemplates {- if v == nil {- continue- }- t := &storepb.SchemaTemplateSetting_TableTemplate{- Id: v.Id,- Engine: convertEngine(v.Engine),- Category: v.Category,- }- if v.Table != nil {- t.Table = convertV1TableMetadata(v.Table)- }- if v.Catalog != nil {- t.Catalog = convertV1TableCatalog(v.Catalog)- }- v1Setting.TableTemplates = append(v1Setting.TableTemplates, t)- }-- return v1Setting-}--var domainRegexp = regexp.MustCompile(`^(?i:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,}$`)-var disallowedDomains = map[string]bool{- "gmail.com": true,- "googlemail.com": true,- "outlook.com": true,- "hotmail.com": true,- "live.com": true,- "msn.com": true,- "yahoo.com": true,- "ymail.com": true,- "rocketmail.com": true,- "icloud.com": true,- "me.com": true,- "mac.com": true,- "aol.com": true,- "zoho.com": true,- "protonmail.com": true,- "gmx.com": true,- "gmx.net": true,- "mail.com": true,- "yandex.com": true,- "yandex.ru": true,- "fastmail.com": true,- "fastmail.fm": true,- "tutanota.com": true,- "163.com": true,- "126.com": true,- "sohu.com": true,- "qq.com": true,- "sina.com": true,- "sina.cn": true,- "aliyun.com": true,- "aliyun.cn": true,- "tom.com": true,- "21cn.com": true,- "yeah.net": true,-}-func validateDomains(domains []string) error {for _, domain := range domains {if !domainRegexp.MatchString(domain) {@@ -1090,512 +710,3 @@ func (s *SettingService) validateEnvironments(envs []*v1pb.EnvironmentSetting_En}return nil}--func convertToEnvironmentSetting(value string) (*v1pb.EnvironmentSetting, error) {- var setting storepb.EnvironmentSetting- if err := common.ProtojsonUnmarshaler.Unmarshal([]byte(value), &setting); err != nil {- return nil, errors.Wrapf(err, "failed to unmarshal environment setting")- }- var environments []*v1pb.EnvironmentSetting_Environment-- for _, e := range setting.Environments {- environments = append(environments, convertToEnvironment(e))- }- return &v1pb.EnvironmentSetting{- Environments: environments,- }, nil-}--func convertToEnvironment(e *storepb.EnvironmentSetting_Environment) *v1pb.EnvironmentSetting_Environment {- return &v1pb.EnvironmentSetting_Environment{- Name: common.FormatEnvironment(e.Id),- Id: e.Id,- Title: e.Title,- Tags: e.Tags,- Color: e.Color,- }-}--func convertEnvironmentSetting(e *v1pb.EnvironmentSetting) *storepb.EnvironmentSetting {- var environments []*storepb.EnvironmentSetting_Environment- for _, env := range e.Environments {- environments = append(environments, &storepb.EnvironmentSetting_Environment{- Id: env.Id,- Title: env.Title,- Tags: env.Tags,- Color: env.Color,- })- }- return &storepb.EnvironmentSetting{- Environments: environments,- }-}--func convertWorkspaceProfileSetting(v1Setting *v1pb.WorkspaceProfileSetting) *storepb.WorkspaceProfileSetting {- if v1Setting == nil {- return nil- }-- storeSetting := &storepb.WorkspaceProfileSetting{- ExternalUrl: v1Setting.ExternalUrl,- DisallowSignup: v1Setting.DisallowSignup,- Require_2Fa: v1Setting.Require_2Fa,- TokenDuration: v1Setting.TokenDuration,- MaximumRoleExpiration: v1Setting.MaximumRoleExpiration,- Domains: v1Setting.Domains,- EnforceIdentityDomain: v1Setting.EnforceIdentityDomain,- DatabaseChangeMode: storepb.DatabaseChangeMode(v1Setting.DatabaseChangeMode),- DisallowPasswordSignin: v1Setting.DisallowPasswordSignin,- EnableMetricCollection: v1Setting.EnableMetricCollection,- }-- // Convert announcement if present- if v1Setting.Announcement != nil {- storeSetting.Announcement = &storepb.Announcement{- Text: v1Setting.Announcement.Text,- Link: v1Setting.Announcement.Link,- }- // Convert alert level- switch v1Setting.Announcement.Level {- case v1pb.Announcement_ALERT_LEVEL_UNSPECIFIED:- storeSetting.Announcement.Level = storepb.Announcement_ALERT_LEVEL_UNSPECIFIED- case v1pb.Announcement_INFO:- storeSetting.Announcement.Level = storepb.Announcement_ALERT_LEVEL_INFO- case v1pb.Announcement_WARNING:- storeSetting.Announcement.Level = storepb.Announcement_ALERT_LEVEL_WARNING- case v1pb.Announcement_CRITICAL:- storeSetting.Announcement.Level = storepb.Announcement_ALERT_LEVEL_CRITICAL- default:- }- }-- return storeSetting-}--func convertToWorkspaceProfileSetting(storeSetting *storepb.WorkspaceProfileSetting) *v1pb.WorkspaceProfileSetting {- if storeSetting == nil {- return nil- }-- v1Setting := &v1pb.WorkspaceProfileSetting{- ExternalUrl: storeSetting.ExternalUrl,- DisallowSignup: storeSetting.DisallowSignup,- Require_2Fa: storeSetting.Require_2Fa,- TokenDuration: storeSetting.TokenDuration,- MaximumRoleExpiration: storeSetting.MaximumRoleExpiration,- Domains: storeSetting.Domains,- EnforceIdentityDomain: storeSetting.EnforceIdentityDomain,- DatabaseChangeMode: v1pb.DatabaseChangeMode(storeSetting.DatabaseChangeMode),- DisallowPasswordSignin: storeSetting.DisallowPasswordSignin,- EnableMetricCollection: storeSetting.EnableMetricCollection,- }-- if storeSetting.Announcement != nil {- v1Setting.Announcement = &v1pb.Announcement{- Text: storeSetting.Announcement.Text,- Link: storeSetting.Announcement.Link,- }- switch storeSetting.Announcement.Level {- case storepb.Announcement_ALERT_LEVEL_UNSPECIFIED:- v1Setting.Announcement.Level = v1pb.Announcement_ALERT_LEVEL_UNSPECIFIED- case storepb.Announcement_ALERT_LEVEL_INFO:- v1Setting.Announcement.Level = v1pb.Announcement_INFO- case storepb.Announcement_ALERT_LEVEL_WARNING:- v1Setting.Announcement.Level = v1pb.Announcement_WARNING- case storepb.Announcement_ALERT_LEVEL_CRITICAL:- v1Setting.Announcement.Level = v1pb.Announcement_CRITICAL- default:- }- }-- return v1Setting-}--func convertApprovalFlow(v1Flow *v1pb.ApprovalFlow) *storepb.ApprovalFlow {- if v1Flow == nil {- return nil- }-- return &storepb.ApprovalFlow{- Roles: v1Flow.Roles,- }-}--func convertAppIMSetting(v1Setting *v1pb.AppIMSetting) *storepb.AppIMSetting {- if v1Setting == nil {- return nil- }-- storeSetting := &storepb.AppIMSetting{}-- if v1Setting.Slack != nil {- storeSetting.Slack = &storepb.AppIMSetting_Slack{- Enabled: v1Setting.Slack.Enabled,- Token: v1Setting.Slack.Token,- }- }- if v1Setting.Feishu != nil {- storeSetting.Feishu = &storepb.AppIMSetting_Feishu{- Enabled: v1Setting.Feishu.Enabled,- AppId: v1Setting.Feishu.AppId,- AppSecret: v1Setting.Feishu.AppSecret,- }- }- if v1Setting.Wecom != nil {- storeSetting.Wecom = &storepb.AppIMSetting_Wecom{- Enabled: v1Setting.Wecom.Enabled,- CorpId: v1Setting.Wecom.CorpId,- AgentId: v1Setting.Wecom.AgentId,- Secret: v1Setting.Wecom.Secret,- }- }- if v1Setting.Lark != nil {- storeSetting.Lark = &storepb.AppIMSetting_Lark{- Enabled: v1Setting.Lark.Enabled,- AppId: v1Setting.Lark.AppId,- AppSecret: v1Setting.Lark.AppSecret,- }- }- if v1Setting.Dingtalk != nil {- storeSetting.Dingtalk = &storepb.AppIMSetting_DingTalk{- Enabled: v1Setting.Dingtalk.Enabled,- ClientId: v1Setting.Dingtalk.ClientId,- ClientSecret: v1Setting.Dingtalk.ClientSecret,- RobotCode: v1Setting.Dingtalk.RobotCode,- }- }-- return storeSetting-}--func convertDataClassificationSetting(v1Setting *v1pb.DataClassificationSetting) *storepb.DataClassificationSetting {- if v1Setting == nil {- return nil- }-- storeSetting := &storepb.DataClassificationSetting{}- for _, config := range v1Setting.Configs {- storeConfig := convertDataClassificationSettingConfig(config)- storeSetting.Configs = append(storeSetting.Configs, storeConfig)- }- return storeSetting-}--func convertDataClassificationSettingConfig(c *v1pb.DataClassificationSetting_DataClassificationConfig) *storepb.DataClassificationSetting_DataClassificationConfig {- if c == nil {- return nil- }-- return &storepb.DataClassificationSetting_DataClassificationConfig{- Id: c.Id,- Title: c.Title,- Levels: convertDataClassificationSettingLevels(c.Levels),- Classification: convertDataClassificationSettingClassification(c.Classification),- ClassificationFromConfig: c.ClassificationFromConfig,- }-}--func convertDataClassificationSettingLevels(levels []*v1pb.DataClassificationSetting_DataClassificationConfig_Level) []*storepb.DataClassificationSetting_DataClassificationConfig_Level {- if levels == nil {- return nil- }-- storeLevels := make([]*storepb.DataClassificationSetting_DataClassificationConfig_Level, len(levels))- for i, level := range levels {- storeLevels[i] = &storepb.DataClassificationSetting_DataClassificationConfig_Level{- Id: level.Id,- Title: level.Title,- Description: level.Description,- }- }- return storeLevels-}--func convertDataClassificationSettingClassification(classification map[string]*v1pb.DataClassificationSetting_DataClassificationConfig_DataClassification) map[string]*storepb.DataClassificationSetting_DataClassificationConfig_DataClassification {- if classification == nil {- return nil- }-- storeClassification := make(map[string]*storepb.DataClassificationSetting_DataClassificationConfig_DataClassification, len(classification))- for k, v := range classification {- storeClassification[k] = &storepb.DataClassificationSetting_DataClassificationConfig_DataClassification{- Id: v.Id,- Title: v.Title,- Description: v.Description,- LevelId: v.LevelId,- }- }- return storeClassification-}--func convertToDataClassificationSetting(storeSetting *storepb.DataClassificationSetting) *v1pb.DataClassificationSetting {- if storeSetting == nil {- return nil- }-- v1Setting := &v1pb.DataClassificationSetting{}- for _, config := range storeSetting.Configs {- v1Config := convertToDataClassificationSettingConfig(config)- v1Setting.Configs = append(v1Setting.Configs, v1Config)- }- return v1Setting-}--func convertToDataClassificationSettingConfig(c *storepb.DataClassificationSetting_DataClassificationConfig) *v1pb.DataClassificationSetting_DataClassificationConfig {- if c == nil {- return nil- }-- return &v1pb.DataClassificationSetting_DataClassificationConfig{- Id: c.Id,- Title: c.Title,- Levels: convertToDataClassificationSettingLevels(c.Levels),- Classification: convertToDataClassificationSettingClassification(c.Classification),- ClassificationFromConfig: c.ClassificationFromConfig,- }-}--func convertToDataClassificationSettingLevels(levels []*storepb.DataClassificationSetting_DataClassificationConfig_Level) []*v1pb.DataClassificationSetting_DataClassificationConfig_Level {- if levels == nil {- return nil- }-- v1Levels := make([]*v1pb.DataClassificationSetting_DataClassificationConfig_Level, len(levels))- for i, level := range levels {- v1Levels[i] = &v1pb.DataClassificationSetting_DataClassificationConfig_Level{- Id: level.Id,- Title: level.Title,- Description: level.Description,- }- }- return v1Levels-}--func convertToDataClassificationSettingClassification(classification map[string]*storepb.DataClassificationSetting_DataClassificationConfig_DataClassification) map[string]*v1pb.DataClassificationSetting_DataClassificationConfig_DataClassification {- if classification == nil {- return nil- }-- v1Classification := make(map[string]*v1pb.DataClassificationSetting_DataClassificationConfig_DataClassification, len(classification))- for k, v := range classification {- v1Classification[k] = &v1pb.DataClassificationSetting_DataClassificationConfig_DataClassification{- Id: v.Id,- Title: v.Title,- Description: v.Description,- LevelId: v.LevelId,- }- }- return v1Classification-}--func convertSemanticTypeSetting(v1Setting *v1pb.SemanticTypeSetting) *storepb.SemanticTypeSetting {- if v1Setting == nil {- return nil- }-- storeSetting := &storepb.SemanticTypeSetting{}- for _, v1Type := range v1Setting.Types {- storeType := &storepb.SemanticTypeSetting_SemanticType{- Id: v1Type.Id,- Title: v1Type.Title,- Description: v1Type.Description,- Algorithm: convertAlgorithm(v1Type.Algorithm),- Icon: v1Type.Icon,- }- storeSetting.Types = append(storeSetting.Types, storeType)- }- return storeSetting-}--func convertToSemanticTypeSetting(storeSetting *storepb.SemanticTypeSetting) *v1pb.SemanticTypeSetting {- if storeSetting == nil {- return nil- }-- v1Setting := &v1pb.SemanticTypeSetting{}- for _, storeType := range storeSetting.Types {- v1Type := &v1pb.SemanticTypeSetting_SemanticType{- Id: storeType.Id,- Title: storeType.Title,- Description: storeType.Description,- Algorithm: convertToAlgorithm(storeType.Algorithm),- Icon: storeType.Icon,- }- v1Setting.Types = append(v1Setting.Types, v1Type)- }- return v1Setting-}--func convertAlgorithm(v1Algo *v1pb.Algorithm) *storepb.Algorithm {- if v1Algo == nil {- return nil- }-- storeAlgo := &storepb.Algorithm{}- switch mask := v1Algo.Mask.(type) {- case *v1pb.Algorithm_FullMask_:- storeAlgo.Mask = &storepb.Algorithm_FullMask_{- FullMask: &storepb.Algorithm_FullMask{- Substitution: mask.FullMask.Substitution,- },- }- case *v1pb.Algorithm_Md5Mask:- storeAlgo.Mask = &storepb.Algorithm_Md5Mask{- Md5Mask: &storepb.Algorithm_MD5Mask{- Salt: mask.Md5Mask.Salt,- },- }- case *v1pb.Algorithm_RangeMask_:- storeAlgo.Mask = &storepb.Algorithm_RangeMask_{- RangeMask: &storepb.Algorithm_RangeMask{- Slices: convertAlgorithmRangeMaskSlices(mask.RangeMask.Slices),- },- }- case *v1pb.Algorithm_InnerOuterMask_:- storeAlgo.Mask = &storepb.Algorithm_InnerOuterMask_{- InnerOuterMask: &storepb.Algorithm_InnerOuterMask{- PrefixLen: mask.InnerOuterMask.PrefixLen,- SuffixLen: mask.InnerOuterMask.SuffixLen,- Type: storepb.Algorithm_InnerOuterMask_MaskType(mask.InnerOuterMask.Type),- Substitution: mask.InnerOuterMask.Substitution,- },- }- }- return storeAlgo-}--func convertToAlgorithm(storeAlgo *storepb.Algorithm) *v1pb.Algorithm {- if storeAlgo == nil {- return nil- }-- v1Algo := &v1pb.Algorithm{}- switch mask := storeAlgo.Mask.(type) {- case *storepb.Algorithm_FullMask_:- v1Algo.Mask = &v1pb.Algorithm_FullMask_{- FullMask: &v1pb.Algorithm_FullMask{- Substitution: mask.FullMask.Substitution,- },- }- case *storepb.Algorithm_Md5Mask:- v1Algo.Mask = &v1pb.Algorithm_Md5Mask{- Md5Mask: &v1pb.Algorithm_MD5Mask{- Salt: mask.Md5Mask.Salt,- },- }- case *storepb.Algorithm_RangeMask_:- v1Algo.Mask = &v1pb.Algorithm_RangeMask_{- RangeMask: &v1pb.Algorithm_RangeMask{- Slices: convertToAlgorithmRangeMaskSlices(mask.RangeMask.Slices),- },- }- case *storepb.Algorithm_InnerOuterMask_:- v1Algo.Mask = &v1pb.Algorithm_InnerOuterMask_{- InnerOuterMask: &v1pb.Algorithm_InnerOuterMask{- PrefixLen: mask.InnerOuterMask.PrefixLen,- SuffixLen: mask.InnerOuterMask.SuffixLen,- Type: v1pb.Algorithm_InnerOuterMask_MaskType(mask.InnerOuterMask.Type),- Substitution: mask.InnerOuterMask.Substitution,- },- }- }- return v1Algo-}--func convertAlgorithmRangeMaskSlices(v1Slices []*v1pb.Algorithm_RangeMask_Slice) []*storepb.Algorithm_RangeMask_Slice {- var storeSlices []*storepb.Algorithm_RangeMask_Slice- for _, v1Slice := range v1Slices {- storeSlice := &storepb.Algorithm_RangeMask_Slice{- Start: v1Slice.Start,- End: v1Slice.End,- Substitution: v1Slice.Substitution,- }- storeSlices = append(storeSlices, storeSlice)- }- return storeSlices-}--func convertToAlgorithmRangeMaskSlices(storeSlices []*storepb.Algorithm_RangeMask_Slice) []*v1pb.Algorithm_RangeMask_Slice {- var v1Slices []*v1pb.Algorithm_RangeMask_Slice- for _, storeSlice := range storeSlices {- v1Slice := &v1pb.Algorithm_RangeMask_Slice{- Start: storeSlice.Start,- End: storeSlice.End,- Substitution: storeSlice.Substitution,- }- v1Slices = append(v1Slices, v1Slice)- }- return v1Slices-}--func convertPasswordRestrictionSetting(v1Setting *v1pb.PasswordRestrictionSetting) *storepb.PasswordRestrictionSetting {- if v1Setting == nil {- return nil- }-- return &storepb.PasswordRestrictionSetting{- MinLength: v1Setting.MinLength,- RequireNumber: v1Setting.RequireNumber,- RequireLetter: v1Setting.RequireLetter,- RequireUppercaseLetter: v1Setting.RequireUppercaseLetter,- RequireSpecialCharacter: v1Setting.RequireSpecialCharacter,- RequireResetPasswordForFirstLogin: v1Setting.RequireResetPasswordForFirstLogin,- PasswordRotation: v1Setting.GetPasswordRotation(),- }-}--func convertToPasswordRestrictionSetting(storeSetting *storepb.PasswordRestrictionSetting) *v1pb.PasswordRestrictionSetting {- if storeSetting == nil {- return nil- }-- return &v1pb.PasswordRestrictionSetting{- MinLength: storeSetting.MinLength,- RequireNumber: storeSetting.RequireNumber,- RequireLetter: storeSetting.RequireLetter,- RequireUppercaseLetter: storeSetting.RequireUppercaseLetter,- RequireSpecialCharacter: storeSetting.RequireSpecialCharacter,- RequireResetPasswordForFirstLogin: storeSetting.RequireResetPasswordForFirstLogin,- PasswordRotation: storeSetting.GetPasswordRotation(),- }-}--func convertAISetting(v1Setting *v1pb.AISetting) *storepb.AISetting {- if v1Setting == nil {- return nil- }-- return &storepb.AISetting{- Enabled: v1Setting.Enabled,- Provider: storepb.AISetting_Provider(v1Setting.Provider),- Endpoint: v1Setting.Endpoint,- ApiKey: v1Setting.ApiKey,- Model: v1Setting.Model,- Version: v1Setting.Version,- }-}--func convertToAISetting(storeSetting *storepb.AISetting) *v1pb.AISetting {- if storeSetting == nil {- return nil- }-- return &v1pb.AISetting{- Enabled: storeSetting.Enabled,- Provider: v1pb.AISetting_Provider(storeSetting.Provider),- Endpoint: storeSetting.Endpoint,- ApiKey: storeSetting.ApiKey,- Model: storeSetting.Model,- Version: storeSetting.Version,- }-}--func convertToSCIMSetting(storeSetting *storepb.SCIMSetting) *v1pb.SCIMSetting {- if storeSetting == nil {- return nil- }-- return &v1pb.SCIMSetting{- Token: storeSetting.Token,- }-}diff --git a/backend/api/v1/setting_service_converter.go b/backend/api/v1/setting_service_converter.gonew file mode 100644index 0000000000..da7335253a--- /dev/null+++ b/backend/api/v1/setting_service_converter.go@@ -0,0 +1,892 @@+package v1++import (+ "fmt"++ "connectrpc.com/connect"+ "github.com/pkg/errors"++ "github.com/bytebase/bytebase/backend/common"+ "github.com/bytebase/bytebase/backend/component/config"+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"+ "github.com/bytebase/bytebase/backend/store"+)++func convertToSettingMessage(setting *store.SettingMessage, profile *config.Profile) (*v1pb.Setting, error) {+ settingName := fmt.Sprintf("%s%s", common.SettingNamePrefix, convertStoreSettingNameToV1(setting.Name).String())+ switch setting.Name {+ case storepb.SettingName_APP_IM:+ storeValue := new(storepb.AppIMSetting)+ if err := common.ProtojsonUnmarshaler.Unmarshal([]byte(setting.Value), storeValue); err != nil {+ return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to unmarshal setting value for %s with error: %v", setting.Name, err))+ }+ return &v1pb.Setting{+ Name: settingName,+ Value: &v1pb.Value{+ Value: &v1pb.Value_AppImSettingValue{+ AppImSettingValue: &v1pb.AppIMSetting{+ Slack: &v1pb.AppIMSetting_Slack{+ Enabled: storeValue.GetSlack().GetEnabled(),+ },+ Feishu: &v1pb.AppIMSetting_Feishu{+ Enabled: storeValue.GetFeishu().GetEnabled(),+ },+ Wecom: &v1pb.AppIMSetting_Wecom{+ Enabled: storeValue.GetWecom().GetEnabled(),+ },+ Lark: &v1pb.AppIMSetting_Lark{+ Enabled: storeValue.GetLark().GetEnabled(),+ },+ Dingtalk: &v1pb.AppIMSetting_DingTalk{+ Enabled: storeValue.GetDingtalk().GetEnabled(),+ },+ },+ },+ },+ }, nil+ case storepb.SettingName_WORKSPACE_PROFILE:+ storeValue := new(storepb.WorkspaceProfileSetting)+ if err := common.ProtojsonUnmarshaler.Unmarshal([]byte(setting.Value), storeValue); err != nil {+ return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to unmarshal setting value for %s with error: %v", setting.Name, err))+ }+ v1Value := convertToWorkspaceProfileSetting(storeValue)+ v1Value.DisallowSignup = v1Value.DisallowSignup || profile.SaaS+ return &v1pb.Setting{+ Name: settingName,+ Value: &v1pb.Value{+ Value: &v1pb.Value_WorkspaceProfileSettingValue{+ WorkspaceProfileSettingValue: v1Value,+ },+ },+ }, nil+ case storepb.SettingName_WORKSPACE_APPROVAL:+ storeValue := new(storepb.WorkspaceApprovalSetting)+ if err := common.ProtojsonUnmarshaler.Unmarshal([]byte(setting.Value), storeValue); err != nil {+ return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to unmarshal setting value for %s with error: %v", setting.Name, err))+ }+ v1Value := &v1pb.WorkspaceApprovalSetting{}+ for _, rule := range storeValue.Rules {+ template := convertToApprovalTemplate(rule.Template)+ v1Value.Rules = append(v1Value.Rules, &v1pb.WorkspaceApprovalSetting_Rule{+ Condition: rule.Condition,+ Template: template,+ })+ }+ return &v1pb.Setting{+ Name: settingName,+ Value: &v1pb.Value{+ Value: &v1pb.Value_WorkspaceApprovalSettingValue{+ WorkspaceApprovalSettingValue: v1Value,+ },+ },+ }, nil+ case storepb.SettingName_SCHEMA_TEMPLATE:+ storeValue := new(storepb.SchemaTemplateSetting)+ if err := common.ProtojsonUnmarshaler.Unmarshal([]byte(setting.Value), storeValue); err != nil {+ return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to unmarshal setting value for %s with error: %v", setting.Name, err))+ }++ sts := convertToSchemaTemplateSetting(storeValue)+ return &v1pb.Setting{+ Name: settingName,+ Value: &v1pb.Value{+ Value: &v1pb.Value_SchemaTemplateSettingValue{+ SchemaTemplateSettingValue: sts,+ },+ },+ }, nil+ case storepb.SettingName_DATA_CLASSIFICATION:+ storeValue := new(storepb.DataClassificationSetting)+ if err := common.ProtojsonUnmarshaler.Unmarshal([]byte(setting.Value), storeValue); err != nil {+ return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to unmarshal setting value for %s with error: %v", setting.Name, err))+ }+ return &v1pb.Setting{+ Name: settingName,+ Value: &v1pb.Value{+ Value: &v1pb.Value_DataClassificationSettingValue{+ DataClassificationSettingValue: convertToDataClassificationSetting(storeValue),+ },+ },+ }, nil+ case storepb.SettingName_SEMANTIC_TYPES:+ storeValue := new(storepb.SemanticTypeSetting)+ if err := common.ProtojsonUnmarshaler.Unmarshal([]byte(setting.Value), storeValue); err != nil {+ return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to unmarshal setting value for %s with error: %v", setting.Name, err))+ }+ return &v1pb.Setting{+ Name: settingName,+ Value: &v1pb.Value{+ Value: &v1pb.Value_SemanticTypeSettingValue{+ SemanticTypeSettingValue: convertToSemanticTypeSetting(storeValue),+ },+ },+ }, nil+ case storepb.SettingName_SCIM:+ storeValue := new(storepb.SCIMSetting)+ if err := common.ProtojsonUnmarshaler.Unmarshal([]byte(setting.Value), storeValue); err != nil {+ return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to unmarshal setting value for %s with error: %v", setting.Name, err))+ }+ return &v1pb.Setting{+ Name: settingName,+ Value: &v1pb.Value{+ Value: &v1pb.Value_ScimSetting{+ ScimSetting: convertToSCIMSetting(storeValue),+ },+ },+ }, nil+ case storepb.SettingName_PASSWORD_RESTRICTION:+ storeValue := new(storepb.PasswordRestrictionSetting)+ if err := common.ProtojsonUnmarshaler.Unmarshal([]byte(setting.Value), storeValue); err != nil {+ return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to unmarshal setting value for %s with error: %v", setting.Name, err))+ }+ return &v1pb.Setting{+ Name: settingName,+ Value: &v1pb.Value{+ Value: &v1pb.Value_PasswordRestrictionSetting{+ PasswordRestrictionSetting: convertToPasswordRestrictionSetting(storeValue),+ },+ },+ }, nil+ case storepb.SettingName_AI:+ storeValue := new(storepb.AISetting)+ if err := common.ProtojsonUnmarshaler.Unmarshal([]byte(setting.Value), storeValue); err != nil {+ return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to unmarshal setting value for %s with error: %v", setting.Name, err))+ }+ // DO NOT expose the api key.+ storeValue.ApiKey = ""+ return &v1pb.Setting{+ Name: settingName,+ Value: &v1pb.Value{+ Value: &v1pb.Value_AiSetting{+ AiSetting: convertToAISetting(storeValue),+ },+ },+ }, nil+ case storepb.SettingName_ENVIRONMENT:+ storeValue, err := convertToEnvironmentSetting(setting.Value)+ if err != nil {+ return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to convert setting value for %s with error: %v", setting.Name, err))+ }+ return &v1pb.Setting{+ Name: settingName,+ Value: &v1pb.Value{+ Value: &v1pb.Value_EnvironmentSetting{+ EnvironmentSetting: storeValue,+ },+ },+ }, nil+ default:+ return &v1pb.Setting{+ Name: settingName,+ Value: &v1pb.Value{+ Value: &v1pb.Value_StringValue{+ StringValue: setting.Value,+ },+ },+ }, nil+ }+}++// convertStringToSettingName converts a string to storepb.SettingName.+// It first converts to v1pb.Setting_SettingName, then to storepb.SettingName.+func convertStringToSettingName(name string) (storepb.SettingName, error) {+ // First try to convert string to v1pb.Setting_SettingName+ v1Value, ok := v1pb.Setting_SettingName_value[name]+ if !ok {+ return storepb.SettingName_SETTING_NAME_UNSPECIFIED, errors.Errorf("invalid setting name: %s", name)+ }+ v1SettingName := v1pb.Setting_SettingName(v1Value)++ // Then convert v1pb to storepb+ return convertV1SettingNameToStore(v1SettingName), nil+}++// convertStoreSettingNameToV1 converts storepb.SettingName to v1pb.Setting_SettingName.+func convertStoreSettingNameToV1(storeName storepb.SettingName) v1pb.Setting_SettingName {+ //exhaustive:enforce+ switch storeName {+ case storepb.SettingName_SETTING_NAME_UNSPECIFIED:+ return v1pb.Setting_SETTING_NAME_UNSPECIFIED+ case storepb.SettingName_AUTH_SECRET:+ return v1pb.Setting_AUTH_SECRET+ case storepb.SettingName_BRANDING_LOGO:+ return v1pb.Setting_BRANDING_LOGO+ case storepb.SettingName_WORKSPACE_ID:+ return v1pb.Setting_WORKSPACE_ID+ case storepb.SettingName_WORKSPACE_PROFILE:+ return v1pb.Setting_WORKSPACE_PROFILE+ case storepb.SettingName_WORKSPACE_APPROVAL:+ return v1pb.Setting_WORKSPACE_APPROVAL+ case storepb.SettingName_WORKSPACE_EXTERNAL_APPROVAL:+ return v1pb.Setting_WORKSPACE_EXTERNAL_APPROVAL+ case storepb.SettingName_ENTERPRISE_LICENSE:+ return v1pb.Setting_ENTERPRISE_LICENSE+ case storepb.SettingName_APP_IM:+ return v1pb.Setting_APP_IM+ case storepb.SettingName_WATERMARK:+ return v1pb.Setting_WATERMARK+ case storepb.SettingName_AI:+ return v1pb.Setting_AI+ case storepb.SettingName_SCHEMA_TEMPLATE:+ return v1pb.Setting_SCHEMA_TEMPLATE+ case storepb.SettingName_DATA_CLASSIFICATION:+ return v1pb.Setting_DATA_CLASSIFICATION+ case storepb.SettingName_SEMANTIC_TYPES:+ return v1pb.Setting_SEMANTIC_TYPES+ case storepb.SettingName_SCIM:+ return v1pb.Setting_SCIM+ case storepb.SettingName_PASSWORD_RESTRICTION:+ return v1pb.Setting_PASSWORD_RESTRICTION+ case storepb.SettingName_ENVIRONMENT:+ return v1pb.Setting_ENVIRONMENT+ default:+ }+ return v1pb.Setting_SETTING_NAME_UNSPECIFIED+}++// convertV1SettingNameToStore converts v1pb.Setting_SettingName to storepb.SettingName.+func convertV1SettingNameToStore(v1Name v1pb.Setting_SettingName) storepb.SettingName {+ //exhaustive:enforce+ switch v1Name {+ case v1pb.Setting_SETTING_NAME_UNSPECIFIED:+ return storepb.SettingName_SETTING_NAME_UNSPECIFIED+ case v1pb.Setting_AUTH_SECRET:+ return storepb.SettingName_AUTH_SECRET+ case v1pb.Setting_BRANDING_LOGO:+ return storepb.SettingName_BRANDING_LOGO+ case v1pb.Setting_WORKSPACE_ID:+ return storepb.SettingName_WORKSPACE_ID+ case v1pb.Setting_WORKSPACE_PROFILE:+ return storepb.SettingName_WORKSPACE_PROFILE+ case v1pb.Setting_WORKSPACE_APPROVAL:+ return storepb.SettingName_WORKSPACE_APPROVAL+ case v1pb.Setting_WORKSPACE_EXTERNAL_APPROVAL:+ return storepb.SettingName_WORKSPACE_EXTERNAL_APPROVAL+ case v1pb.Setting_ENTERPRISE_LICENSE:+ return storepb.SettingName_ENTERPRISE_LICENSE+ case v1pb.Setting_APP_IM:+ return storepb.SettingName_APP_IM+ case v1pb.Setting_WATERMARK:+ return storepb.SettingName_WATERMARK+ case v1pb.Setting_AI:+ return storepb.SettingName_AI+ case v1pb.Setting_SCHEMA_TEMPLATE:+ return storepb.SettingName_SCHEMA_TEMPLATE+ case v1pb.Setting_DATA_CLASSIFICATION:+ return storepb.SettingName_DATA_CLASSIFICATION+ case v1pb.Setting_SEMANTIC_TYPES:+ return storepb.SettingName_SEMANTIC_TYPES+ case v1pb.Setting_SCIM:+ return storepb.SettingName_SCIM+ case v1pb.Setting_PASSWORD_RESTRICTION:+ return storepb.SettingName_PASSWORD_RESTRICTION+ case v1pb.Setting_ENVIRONMENT:+ return storepb.SettingName_ENVIRONMENT+ default:+ return storepb.SettingName_SETTING_NAME_UNSPECIFIED+ }+}++func convertToSchemaTemplateSetting(template *storepb.SchemaTemplateSetting) *v1pb.SchemaTemplateSetting {+ v1Setting := new(v1pb.SchemaTemplateSetting)+ for _, v := range template.ColumnTypes {+ v1Setting.ColumnTypes = append(v1Setting.ColumnTypes, &v1pb.SchemaTemplateSetting_ColumnType{+ Engine: convertToEngine(v.Engine),+ Enabled: v.Enabled,+ Types: v.Types,+ })+ }+ for _, v := range template.FieldTemplates {+ if v == nil {+ continue+ }+ t := &v1pb.SchemaTemplateSetting_FieldTemplate{+ Id: v.Id,+ Engine: convertToEngine(v.Engine),+ Category: v.Category,+ }+ if v.Column != nil {+ t.Column = convertStoreColumnMetadata(v.Column)+ }+ if v.Catalog != nil {+ t.Catalog = convertColumnCatalog(v.Catalog)+ }+ v1Setting.FieldTemplates = append(v1Setting.FieldTemplates, t)+ }+ for _, v := range template.TableTemplates {+ if v == nil {+ continue+ }+ t := &v1pb.SchemaTemplateSetting_TableTemplate{+ Id: v.Id,+ Engine: convertToEngine(v.Engine),+ Category: v.Category,+ }+ if v.Table != nil {+ t.Table = convertStoreTableMetadata(v.Table)+ }+ if v.Catalog != nil {+ t.Catalog = convertTableCatalog(v.Catalog)+ }+ v1Setting.TableTemplates = append(v1Setting.TableTemplates, t)+ }++ return v1Setting+}++func convertV1SchemaTemplateSetting(template *v1pb.SchemaTemplateSetting) *storepb.SchemaTemplateSetting {+ v1Setting := new(storepb.SchemaTemplateSetting)+ for _, v := range template.ColumnTypes {+ v1Setting.ColumnTypes = append(v1Setting.ColumnTypes, &storepb.SchemaTemplateSetting_ColumnType{+ Engine: convertEngine(v.Engine),+ Enabled: v.Enabled,+ Types: v.Types,+ })+ }+ for _, v := range template.FieldTemplates {+ if v == nil {+ continue+ }+ t := &storepb.SchemaTemplateSetting_FieldTemplate{+ Id: v.Id,+ Engine: convertEngine(v.Engine),+ Category: v.Category,+ }+ if v.Column != nil {+ t.Column = convertV1ColumnMetadata(v.Column)+ }+ if v.Catalog != nil {+ t.Catalog = convertV1ColumnCatalog(v.Catalog)+ }+ v1Setting.FieldTemplates = append(v1Setting.FieldTemplates, t)+ }+ for _, v := range template.TableTemplates {+ if v == nil {+ continue+ }+ t := &storepb.SchemaTemplateSetting_TableTemplate{+ Id: v.Id,+ Engine: convertEngine(v.Engine),+ Category: v.Category,+ }+ if v.Table != nil {+ t.Table = convertV1TableMetadata(v.Table)+ }+ if v.Catalog != nil {+ t.Catalog = convertV1TableCatalog(v.Catalog)+ }+ v1Setting.TableTemplates = append(v1Setting.TableTemplates, t)+ }++ return v1Setting+}++func convertToEnvironmentSetting(value string) (*v1pb.EnvironmentSetting, error) {+ var setting storepb.EnvironmentSetting+ if err := common.ProtojsonUnmarshaler.Unmarshal([]byte(value), &setting); err != nil {+ return nil, errors.Wrapf(err, "failed to unmarshal environment setting")+ }+ var environments []*v1pb.EnvironmentSetting_Environment++ for _, e := range setting.Environments {+ environments = append(environments, convertToEnvironment(e))+ }+ return &v1pb.EnvironmentSetting{+ Environments: environments,+ }, nil+}++func convertToEnvironment(e *storepb.EnvironmentSetting_Environment) *v1pb.EnvironmentSetting_Environment {+ return &v1pb.EnvironmentSetting_Environment{+ Name: common.FormatEnvironment(e.Id),+ Id: e.Id,+ Title: e.Title,+ Tags: e.Tags,+ Color: e.Color,+ }+}++func convertEnvironmentSetting(e *v1pb.EnvironmentSetting) *storepb.EnvironmentSetting {+ var environments []*storepb.EnvironmentSetting_Environment+ for _, env := range e.Environments {+ environments = append(environments, &storepb.EnvironmentSetting_Environment{+ Id: env.Id,+ Title: env.Title,+ Tags: env.Tags,+ Color: env.Color,+ })+ }+ return &storepb.EnvironmentSetting{+ Environments: environments,+ }+}++func convertWorkspaceProfileSetting(v1Setting *v1pb.WorkspaceProfileSetting) *storepb.WorkspaceProfileSetting {+ if v1Setting == nil {+ return nil+ }++ storeSetting := &storepb.WorkspaceProfileSetting{+ ExternalUrl: v1Setting.ExternalUrl,+ DisallowSignup: v1Setting.DisallowSignup,+ Require_2Fa: v1Setting.Require_2Fa,+ TokenDuration: v1Setting.TokenDuration,+ MaximumRoleExpiration: v1Setting.MaximumRoleExpiration,+ Domains: v1Setting.Domains,+ EnforceIdentityDomain: v1Setting.EnforceIdentityDomain,+ DatabaseChangeMode: storepb.DatabaseChangeMode(v1Setting.DatabaseChangeMode),+ DisallowPasswordSignin: v1Setting.DisallowPasswordSignin,+ EnableMetricCollection: v1Setting.EnableMetricCollection,+ }++ // Convert announcement if present+ if v1Setting.Announcement != nil {+ storeSetting.Announcement = &storepb.Announcement{+ Text: v1Setting.Announcement.Text,+ Link: v1Setting.Announcement.Link,+ }+ // Convert alert level+ switch v1Setting.Announcement.Level {+ case v1pb.Announcement_ALERT_LEVEL_UNSPECIFIED:+ storeSetting.Announcement.Level = storepb.Announcement_ALERT_LEVEL_UNSPECIFIED+ case v1pb.Announcement_INFO:+ storeSetting.Announcement.Level = storepb.Announcement_ALERT_LEVEL_INFO+ case v1pb.Announcement_WARNING:+ storeSetting.Announcement.Level = storepb.Announcement_ALERT_LEVEL_WARNING+ case v1pb.Announcement_CRITICAL:+ storeSetting.Announcement.Level = storepb.Announcement_ALERT_LEVEL_CRITICAL+ default:+ }+ }++ return storeSetting+}++func convertToWorkspaceProfileSetting(storeSetting *storepb.WorkspaceProfileSetting) *v1pb.WorkspaceProfileSetting {+ if storeSetting == nil {+ return nil+ }++ v1Setting := &v1pb.WorkspaceProfileSetting{+ ExternalUrl: storeSetting.ExternalUrl,+ DisallowSignup: storeSetting.DisallowSignup,+ Require_2Fa: storeSetting.Require_2Fa,+ TokenDuration: storeSetting.TokenDuration,+ MaximumRoleExpiration: storeSetting.MaximumRoleExpiration,+ Domains: storeSetting.Domains,+ EnforceIdentityDomain: storeSetting.EnforceIdentityDomain,+ DatabaseChangeMode: v1pb.DatabaseChangeMode(storeSetting.DatabaseChangeMode),+ DisallowPasswordSignin: storeSetting.DisallowPasswordSignin,+ EnableMetricCollection: storeSetting.EnableMetricCollection,+ }++ if storeSetting.Announcement != nil {+ v1Setting.Announcement = &v1pb.Announcement{+ Text: storeSetting.Announcement.Text,+ Link: storeSetting.Announcement.Link,+ }+ switch storeSetting.Announcement.Level {+ case storepb.Announcement_ALERT_LEVEL_UNSPECIFIED:+ v1Setting.Announcement.Level = v1pb.Announcement_ALERT_LEVEL_UNSPECIFIED+ case storepb.Announcement_ALERT_LEVEL_INFO:+ v1Setting.Announcement.Level = v1pb.Announcement_INFO+ case storepb.Announcement_ALERT_LEVEL_WARNING:+ v1Setting.Announcement.Level = v1pb.Announcement_WARNING+ case storepb.Announcement_ALERT_LEVEL_CRITICAL:+ v1Setting.Announcement.Level = v1pb.Announcement_CRITICAL+ default:+ }+ }++ return v1Setting+}++func convertApprovalFlow(v1Flow *v1pb.ApprovalFlow) *storepb.ApprovalFlow {+ if v1Flow == nil {+ return nil+ }++ return &storepb.ApprovalFlow{+ Roles: v1Flow.Roles,+ }+}++func convertAppIMSetting(v1Setting *v1pb.AppIMSetting) *storepb.AppIMSetting {+ if v1Setting == nil {+ return nil+ }++ storeSetting := &storepb.AppIMSetting{}++ if v1Setting.Slack != nil {+ storeSetting.Slack = &storepb.AppIMSetting_Slack{+ Enabled: v1Setting.Slack.Enabled,+ Token: v1Setting.Slack.Token,+ }+ }+ if v1Setting.Feishu != nil {+ storeSetting.Feishu = &storepb.AppIMSetting_Feishu{+ Enabled: v1Setting.Feishu.Enabled,+ AppId: v1Setting.Feishu.AppId,+ AppSecret: v1Setting.Feishu.AppSecret,+ }+ }+ if v1Setting.Wecom != nil {+ storeSetting.Wecom = &storepb.AppIMSetting_Wecom{+ Enabled: v1Setting.Wecom.Enabled,+ CorpId: v1Setting.Wecom.CorpId,+ AgentId: v1Setting.Wecom.AgentId,+ Secret: v1Setting.Wecom.Secret,+ }+ }+ if v1Setting.Lark != nil {+ storeSetting.Lark = &storepb.AppIMSetting_Lark{+ Enabled: v1Setting.Lark.Enabled,+ AppId: v1Setting.Lark.AppId,+ AppSecret: v1Setting.Lark.AppSecret,+ }+ }+ if v1Setting.Dingtalk != nil {+ storeSetting.Dingtalk = &storepb.AppIMSetting_DingTalk{+ Enabled: v1Setting.Dingtalk.Enabled,+ ClientId: v1Setting.Dingtalk.ClientId,+ ClientSecret: v1Setting.Dingtalk.ClientSecret,+ RobotCode: v1Setting.Dingtalk.RobotCode,+ }+ }++ return storeSetting+}++func convertDataClassificationSetting(v1Setting *v1pb.DataClassificationSetting) *storepb.DataClassificationSetting {+ if v1Setting == nil {+ return nil+ }++ storeSetting := &storepb.DataClassificationSetting{}+ for _, config := range v1Setting.Configs {+ storeConfig := convertDataClassificationSettingConfig(config)+ storeSetting.Configs = append(storeSetting.Configs, storeConfig)+ }+ return storeSetting+}++func convertDataClassificationSettingConfig(c *v1pb.DataClassificationSetting_DataClassificationConfig) *storepb.DataClassificationSetting_DataClassificationConfig {+ if c == nil {+ return nil+ }++ return &storepb.DataClassificationSetting_DataClassificationConfig{+ Id: c.Id,+ Title: c.Title,+ Levels: convertDataClassificationSettingLevels(c.Levels),+ Classification: convertDataClassificationSettingClassification(c.Classification),+ ClassificationFromConfig: c.ClassificationFromConfig,+ }+}++func convertDataClassificationSettingLevels(levels []*v1pb.DataClassificationSetting_DataClassificationConfig_Level) []*storepb.DataClassificationSetting_DataClassificationConfig_Level {+ if levels == nil {+ return nil+ }++ storeLevels := make([]*storepb.DataClassificationSetting_DataClassificationConfig_Level, len(levels))+ for i, level := range levels {+ storeLevels[i] = &storepb.DataClassificationSetting_DataClassificationConfig_Level{+ Id: level.Id,+ Title: level.Title,+ Description: level.Description,+ }+ }+ return storeLevels+}++func convertDataClassificationSettingClassification(classification map[string]*v1pb.DataClassificationSetting_DataClassificationConfig_DataClassification) map[string]*storepb.DataClassificationSetting_DataClassificationConfig_DataClassification {+ if classification == nil {+ return nil+ }++ storeClassification := make(map[string]*storepb.DataClassificationSetting_DataClassificationConfig_DataClassification, len(classification))+ for k, v := range classification {+ storeClassification[k] = &storepb.DataClassificationSetting_DataClassificationConfig_DataClassification{+ Id: v.Id,+ Title: v.Title,+ Description: v.Description,+ LevelId: v.LevelId,+ }+ }+ return storeClassification+}++func convertToDataClassificationSetting(storeSetting *storepb.DataClassificationSetting) *v1pb.DataClassificationSetting {+ if storeSetting == nil {+ return nil+ }++ v1Setting := &v1pb.DataClassificationSetting{}+ for _, config := range storeSetting.Configs {+ v1Config := convertToDataClassificationSettingConfig(config)+ v1Setting.Configs = append(v1Setting.Configs, v1Config)+ }+ return v1Setting+}++func convertToDataClassificationSettingConfig(c *storepb.DataClassificationSetting_DataClassificationConfig) *v1pb.DataClassificationSetting_DataClassificationConfig {+ if c == nil {+ return nil+ }++ return &v1pb.DataClassificationSetting_DataClassificationConfig{+ Id: c.Id,+ Title: c.Title,+ Levels: convertToDataClassificationSettingLevels(c.Levels),+ Classification: convertToDataClassificationSettingClassification(c.Classification),+ ClassificationFromConfig: c.ClassificationFromConfig,+ }+}++func convertToDataClassificationSettingLevels(levels []*storepb.DataClassificationSetting_DataClassificationConfig_Level) []*v1pb.DataClassificationSetting_DataClassificationConfig_Level {+ if levels == nil {+ return nil+ }++ v1Levels := make([]*v1pb.DataClassificationSetting_DataClassificationConfig_Level, len(levels))+ for i, level := range levels {+ v1Levels[i] = &v1pb.DataClassificationSetting_DataClassificationConfig_Level{+ Id: level.Id,+ Title: level.Title,+ Description: level.Description,+ }+ }+ return v1Levels+}++func convertToDataClassificationSettingClassification(classification map[string]*storepb.DataClassificationSetting_DataClassificationConfig_DataClassification) map[string]*v1pb.DataClassificationSetting_DataClassificationConfig_DataClassification {+ if classification == nil {+ return nil+ }++ v1Classification := make(map[string]*v1pb.DataClassificationSetting_DataClassificationConfig_DataClassification, len(classification))+ for k, v := range classification {+ v1Classification[k] = &v1pb.DataClassificationSetting_DataClassificationConfig_DataClassification{+ Id: v.Id,+ Title: v.Title,+ Description: v.Description,+ LevelId: v.LevelId,+ }+ }+ return v1Classification+}++func convertSemanticTypeSetting(v1Setting *v1pb.SemanticTypeSetting) *storepb.SemanticTypeSetting {+ if v1Setting == nil {+ return nil+ }++ storeSetting := &storepb.SemanticTypeSetting{}+ for _, v1Type := range v1Setting.Types {+ storeType := &storepb.SemanticTypeSetting_SemanticType{+ Id: v1Type.Id,+ Title: v1Type.Title,+ Description: v1Type.Description,+ Algorithm: convertAlgorithm(v1Type.Algorithm),+ Icon: v1Type.Icon,+ }+ storeSetting.Types = append(storeSetting.Types, storeType)+ }+ return storeSetting+}++func convertToSemanticTypeSetting(storeSetting *storepb.SemanticTypeSetting) *v1pb.SemanticTypeSetting {+ if storeSetting == nil {+ return nil+ }++ v1Setting := &v1pb.SemanticTypeSetting{}+ for _, storeType := range storeSetting.Types {+ v1Type := &v1pb.SemanticTypeSetting_SemanticType{+ Id: storeType.Id,+ Title: storeType.Title,+ Description: storeType.Description,+ Algorithm: convertToAlgorithm(storeType.Algorithm),+ Icon: storeType.Icon,+ }+ v1Setting.Types = append(v1Setting.Types, v1Type)+ }+ return v1Setting+}++func convertAlgorithm(v1Algo *v1pb.Algorithm) *storepb.Algorithm {+ if v1Algo == nil {+ return nil+ }++ storeAlgo := &storepb.Algorithm{}+ switch mask := v1Algo.Mask.(type) {+ case *v1pb.Algorithm_FullMask_:+ storeAlgo.Mask = &storepb.Algorithm_FullMask_{+ FullMask: &storepb.Algorithm_FullMask{+ Substitution: mask.FullMask.Substitution,+ },+ }+ case *v1pb.Algorithm_Md5Mask:+ storeAlgo.Mask = &storepb.Algorithm_Md5Mask{+ Md5Mask: &storepb.Algorithm_MD5Mask{+ Salt: mask.Md5Mask.Salt,+ },+ }+ case *v1pb.Algorithm_RangeMask_:+ storeAlgo.Mask = &storepb.Algorithm_RangeMask_{+ RangeMask: &storepb.Algorithm_RangeMask{+ Slices: convertAlgorithmRangeMaskSlices(mask.RangeMask.Slices),+ },+ }+ case *v1pb.Algorithm_InnerOuterMask_:+ storeAlgo.Mask = &storepb.Algorithm_InnerOuterMask_{+ InnerOuterMask: &storepb.Algorithm_InnerOuterMask{+ PrefixLen: mask.InnerOuterMask.PrefixLen,+ SuffixLen: mask.InnerOuterMask.SuffixLen,+ Type: storepb.Algorithm_InnerOuterMask_MaskType(mask.InnerOuterMask.Type),+ Substitution: mask.InnerOuterMask.Substitution,+ },+ }+ }+ return storeAlgo+}++func convertToAlgorithm(storeAlgo *storepb.Algorithm) *v1pb.Algorithm {+ if storeAlgo == nil {+ return nil+ }++ v1Algo := &v1pb.Algorithm{}+ switch mask := storeAlgo.Mask.(type) {+ case *storepb.Algorithm_FullMask_:+ v1Algo.Mask = &v1pb.Algorithm_FullMask_{+ FullMask: &v1pb.Algorithm_FullMask{+ Substitution: mask.FullMask.Substitution,+ },+ }+ case *storepb.Algorithm_Md5Mask:+ v1Algo.Mask = &v1pb.Algorithm_Md5Mask{+ Md5Mask: &v1pb.Algorithm_MD5Mask{+ Salt: mask.Md5Mask.Salt,+ },+ }+ case *storepb.Algorithm_RangeMask_:+ v1Algo.Mask = &v1pb.Algorithm_RangeMask_{+ RangeMask: &v1pb.Algorithm_RangeMask{+ Slices: convertToAlgorithmRangeMaskSlices(mask.RangeMask.Slices),+ },+ }+ case *storepb.Algorithm_InnerOuterMask_:+ v1Algo.Mask = &v1pb.Algorithm_InnerOuterMask_{+ InnerOuterMask: &v1pb.Algorithm_InnerOuterMask{+ PrefixLen: mask.InnerOuterMask.PrefixLen,+ SuffixLen: mask.InnerOuterMask.SuffixLen,+ Type: v1pb.Algorithm_InnerOuterMask_MaskType(mask.InnerOuterMask.Type),+ Substitution: mask.InnerOuterMask.Substitution,+ },+ }+ }+ return v1Algo+}++func convertAlgorithmRangeMaskSlices(v1Slices []*v1pb.Algorithm_RangeMask_Slice) []*storepb.Algorithm_RangeMask_Slice {+ var storeSlices []*storepb.Algorithm_RangeMask_Slice+ for _, v1Slice := range v1Slices {+ storeSlice := &storepb.Algorithm_RangeMask_Slice{+ Start: v1Slice.Start,+ End: v1Slice.End,+ Substitution: v1Slice.Substitution,+ }+ storeSlices = append(storeSlices, storeSlice)+ }+ return storeSlices+}++func convertToAlgorithmRangeMaskSlices(storeSlices []*storepb.Algorithm_RangeMask_Slice) []*v1pb.Algorithm_RangeMask_Slice {+ var v1Slices []*v1pb.Algorithm_RangeMask_Slice+ for _, storeSlice := range storeSlices {+ v1Slice := &v1pb.Algorithm_RangeMask_Slice{+ Start: storeSlice.Start,+ End: storeSlice.End,+ Substitution: storeSlice.Substitution,+ }+ v1Slices = append(v1Slices, v1Slice)+ }+ return v1Slices+}++func convertPasswordRestrictionSetting(v1Setting *v1pb.PasswordRestrictionSetting) *storepb.PasswordRestrictionSetting {+ if v1Setting == nil {+ return nil+ }++ return &storepb.PasswordRestrictionSetting{+ MinLength: v1Setting.MinLength,+ RequireNumber: v1Setting.RequireNumber,+ RequireLetter: v1Setting.RequireLetter,+ RequireUppercaseLetter: v1Setting.RequireUppercaseLetter,+ RequireSpecialCharacter: v1Setting.RequireSpecialCharacter,+ RequireResetPasswordForFirstLogin: v1Setting.RequireResetPasswordForFirstLogin,+ PasswordRotation: v1Setting.GetPasswordRotation(),+ }+}++func convertToPasswordRestrictionSetting(storeSetting *storepb.PasswordRestrictionSetting) *v1pb.PasswordRestrictionSetting {+ if storeSetting == nil {+ return nil+ }++ return &v1pb.PasswordRestrictionSetting{+ MinLength: storeSetting.MinLength,+ RequireNumber: storeSetting.RequireNumber,+ RequireLetter: storeSetting.RequireLetter,+ RequireUppercaseLetter: storeSetting.RequireUppercaseLetter,+ RequireSpecialCharacter: storeSetting.RequireSpecialCharacter,+ RequireResetPasswordForFirstLogin: storeSetting.RequireResetPasswordForFirstLogin,+ PasswordRotation: storeSetting.GetPasswordRotation(),+ }+}++func convertAISetting(v1Setting *v1pb.AISetting) *storepb.AISetting {+ if v1Setting == nil {+ return nil+ }++ return &storepb.AISetting{+ Enabled: v1Setting.Enabled,+ Provider: storepb.AISetting_Provider(v1Setting.Provider),+ Endpoint: v1Setting.Endpoint,+ ApiKey: v1Setting.ApiKey,+ Model: v1Setting.Model,+ Version: v1Setting.Version,+ }+}++func convertToAISetting(storeSetting *storepb.AISetting) *v1pb.AISetting {+ if storeSetting == nil {+ return nil+ }++ return &v1pb.AISetting{+ Enabled: storeSetting.Enabled,+ Provider: v1pb.AISetting_Provider(storeSetting.Provider),+ Endpoint: storeSetting.Endpoint,+ ApiKey: storeSetting.ApiKey,+ Model: storeSetting.Model,+ Version: storeSetting.Version,+ }+}++func convertToSCIMSetting(storeSetting *storepb.SCIMSetting) *v1pb.SCIMSetting {+ if storeSetting == nil {+ return nil+ }++ return &v1pb.SCIMSetting{+ Token: storeSetting.Token,+ }+}diff --git a/backend/api/v1/sql_service.go b/backend/api/v1/sql_service.goindex d0cd9f38f2..31542cb069 100644--- a/backend/api/v1/sql_service.go+++ b/backend/api/v1/sql_service.go@@ -21,7 +21,6 @@ import (celoverloads "github.com/google/cel-go/common/overloads""github.com/pkg/errors""google.golang.org/protobuf/types/known/durationpb"- "google.golang.org/protobuf/types/known/timestamppb""github.com/bytebase/bytebase/backend/common""github.com/bytebase/bytebase/backend/common/log"@@ -37,7 +36,6 @@ import ("github.com/bytebase/bytebase/backend/plugin/advisor/catalog""github.com/bytebase/bytebase/backend/plugin/db"parserbase "github.com/bytebase/bytebase/backend/plugin/parser/base"- "github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/transform""github.com/bytebase/bytebase/backend/plugin/schema""github.com/bytebase/bytebase/backend/runner/plancheck""github.com/bytebase/bytebase/backend/runner/schemasync"@@ -1257,36 +1255,6 @@ func (s *SQLService) SearchQueryHistories(ctx context.Context, req *connect.Requreturn connect.NewResponse(resp), nil}-func (s *SQLService) convertToV1QueryHistory(ctx context.Context, history *store.QueryHistoryMessage) (*v1pb.QueryHistory, error) {- user, err := s.store.GetUserByID(ctx, history.CreatorUID)- if err != nil {- return nil, err- }- if user == nil {- return nil, errors.Errorf("cannot found user with id %d", history.CreatorUID)- }-- historyType := v1pb.QueryHistory_TYPE_UNSPECIFIED- switch history.Type {- case store.QueryHistoryTypeExport:- historyType = v1pb.QueryHistory_EXPORT- case store.QueryHistoryTypeQuery:- historyType = v1pb.QueryHistory_QUERY- default:- }-- return &v1pb.QueryHistory{- Name: fmt.Sprintf("queryHistories/%d", history.UID),- Statement: history.Statement,- Error: history.Payload.Error,- Database: history.Database,- Creator: common.FormatUserEmail(user.Email),- CreateTime: timestamppb.New(history.CreatedAt),- Duration: history.Payload.Duration,- Type: historyType,- }, nil-}-func BuildGetLinkedDatabaseMetadataFunc(storeInstance *store.Store, engine storepb.Engine) parserbase.GetLinkedDatabaseMetadataFunc {if engine != storepb.Engine_ORACLE {return nil@@ -1814,30 +1782,6 @@ func getUseDatabaseOwner(ctx context.Context, stores *store.Store, instance *storeturn project.Setting.PostgresDatabaseTenantMode, nil}-func convertToV1Advice(advice *storepb.Advice) *v1pb.Advice {- return &v1pb.Advice{- Status: convertAdviceStatus(advice.Status),- Code: int32(advice.Code),- Title: advice.Title,- Content: advice.Content,- StartPosition: convertToPosition(advice.StartPosition),- EndPosition: convertToPosition(advice.EndPosition),- }-}--func convertAdviceStatus(status storepb.Advice_Status) v1pb.Advice_Level {- switch status {- case storepb.Advice_SUCCESS:- return v1pb.Advice_SUCCESS- case storepb.Advice_WARNING:- return v1pb.Advice_WARNING- case storepb.Advice_ERROR:- return v1pb.Advice_ERROR- default:- return v1pb.Advice_ADVICE_LEVEL_UNSPECIFIED- }-}-func (*SQLService) DiffMetadata(_ context.Context, req *connect.Request[v1pb.DiffMetadataRequest]) (*connect.Response[v1pb.DiffMetadataResponse], error) {request := req.Msgswitch request.Engine {@@ -1905,32 +1849,6 @@ func sanitizeCommentForSchemaMetadata(dbSchema *storepb.DatabaseSchemaMetadata,}}-// Pretty returns pretty format SDL.-func (*SQLService) Pretty(_ context.Context, req *connect.Request[v1pb.PrettyRequest]) (*connect.Response[v1pb.PrettyResponse], error) {- request := req.Msg- engine := convertEngine(request.Engine)- if _, err := transform.CheckFormat(engine, request.ExpectedSchema); err != nil {- return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("User SDL is not SDL format: %s", err.Error()))- }- if _, err := transform.CheckFormat(engine, request.CurrentSchema); err != nil {- return nil, connect.NewError(connect.CodeInvalidArgument, errors.Errorf("Dumped SDL is not SDL format: %s", err.Error()))- }-- prettyExpectedSchema, err := transform.SchemaTransform(engine, request.ExpectedSchema)- if err != nil {- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to transform user SDL: %s", err.Error()))- }- prettyCurrentSchema, err := transform.Normalize(engine, request.CurrentSchema, prettyExpectedSchema)- if err != nil {- return nil, connect.NewError(connect.CodeInternal, errors.Errorf("failed to normalize dumped SDL: %s", err.Error()))- }-- return connect.NewResponse(&v1pb.PrettyResponse{- CurrentSchema: prettyCurrentSchema,- ExpectedSchema: prettyExpectedSchema,- }), nil-}-// GetQueriableDataSource try to returns the RO data source, and will returns the admin data source if not exist the RO data source.func GetQueriableDataSource(instance *store.InstanceMessage) *storepb.DataSource {if len(instance.Metadata.GetDataSources()) == 0 {diff --git a/backend/api/v1/sql_service_converter.go b/backend/api/v1/sql_service_converter.gonew file mode 100644index 0000000000..55146bcab1--- /dev/null+++ b/backend/api/v1/sql_service_converter.go@@ -0,0 +1,83 @@+package v1++import (+ "context"+ "fmt"++ "github.com/pkg/errors"+ "google.golang.org/protobuf/types/known/timestamppb"++ "github.com/bytebase/bytebase/backend/common"+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+ v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"+ "github.com/bytebase/bytebase/backend/store"+)++func convertChangeType(t v1pb.CheckRequest_ChangeType) storepb.PlanCheckRunConfig_ChangeDatabaseType {+ switch t {+ case v1pb.CheckRequest_DDL:+ return storepb.PlanCheckRunConfig_DDL+ case v1pb.CheckRequest_DDL_GHOST:+ return storepb.PlanCheckRunConfig_DDL_GHOST+ case v1pb.CheckRequest_DML:+ return storepb.PlanCheckRunConfig_DML+ case v1pb.CheckRequest_SQL_EDITOR:+ return storepb.PlanCheckRunConfig_SQL_EDITOR+ default:+ return storepb.PlanCheckRunConfig_CHANGE_DATABASE_TYPE_UNSPECIFIED+ }+}++func convertToV1Advice(advice *storepb.Advice) *v1pb.Advice {+ return &v1pb.Advice{+ Status: convertAdviceStatus(advice.Status),+ Code: int32(advice.Code),+ Title: advice.Title,+ Content: advice.Content,+ StartPosition: convertToPosition(advice.StartPosition),+ EndPosition: convertToPosition(advice.EndPosition),+ }+}++func convertAdviceStatus(status storepb.Advice_Status) v1pb.Advice_Level {+ switch status {+ case storepb.Advice_SUCCESS:+ return v1pb.Advice_SUCCESS+ case storepb.Advice_WARNING:+ return v1pb.Advice_WARNING+ case storepb.Advice_ERROR:+ return v1pb.Advice_ERROR+ default:+ return v1pb.Advice_ADVICE_LEVEL_UNSPECIFIED+ }+}++func (s *SQLService) convertToV1QueryHistory(ctx context.Context, history *store.QueryHistoryMessage) (*v1pb.QueryHistory, error) {+ user, err := s.store.GetUserByID(ctx, history.CreatorUID)+ if err != nil {+ return nil, err+ }+ if user == nil {+ return nil, errors.Errorf("cannot found user with id %d", history.CreatorUID)+ }++ historyType := v1pb.QueryHistory_TYPE_UNSPECIFIED+ switch history.Type {+ case store.QueryHistoryTypeExport:+ historyType = v1pb.QueryHistory_EXPORT+ case store.QueryHistoryTypeQuery:+ historyType = v1pb.QueryHistory_QUERY+ default:+ }++ return &v1pb.QueryHistory{+ Name: fmt.Sprintf("queryHistories/%d", history.UID),+ Statement: history.Statement,+ Error: history.Payload.Error,+ Database: history.Database,+ Creator: common.FormatUserEmail(user.Email),+ CreateTime: timestamppb.New(history.CreatedAt),+ Duration: history.Payload.Duration,+ Type: historyType,+ }, nil+}diff --git a/backend/api/v1/sql_service_utils.go b/backend/api/v1/sql_service_utils.godeleted file mode 100644index 4961a3c699..0000000000--- a/backend/api/v1/sql_service_utils.go+++ /dev/null@@ -1,21 +0,0 @@-package v1--import (- storepb "github.com/bytebase/bytebase/backend/generated-go/store"- v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"-)--func convertChangeType(t v1pb.CheckRequest_ChangeType) storepb.PlanCheckRunConfig_ChangeDatabaseType {- switch t {- case v1pb.CheckRequest_DDL:- return storepb.PlanCheckRunConfig_DDL- case v1pb.CheckRequest_DDL_GHOST:- return storepb.PlanCheckRunConfig_DDL_GHOST- case v1pb.CheckRequest_DML:- return storepb.PlanCheckRunConfig_DML- case v1pb.CheckRequest_SQL_EDITOR:- return storepb.PlanCheckRunConfig_SQL_EDITOR- default:- return storepb.PlanCheckRunConfig_CHANGE_DATABASE_TYPE_UNSPECIFIED- }-}diff --git a/backend/common/position.go b/backend/common/position.goindex 8d20a17552..2bab5ee28d 100644--- a/backend/common/position.go+++ b/backend/common/position.go@@ -2,7 +2,6 @@package commonimport (- "strings""unicode/utf8"lsp "github.com/bytebase/lsp-protocol"@@ -10,12 +9,6 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store")-var (- FirstLinePosition = &storepb.Position{- Line: 0,- }-)-// ANTLRPosition is a position in a text expressed as one-based line and// zero-based column character (code point) offset integrated with ANTLR4.type ANTLRPosition struct {@@ -25,49 +18,6 @@ type ANTLRPosition struct {Column int32}-// ConvertPositionToANTLRPosition converts a Position to an ANTLRPosition in a given text.-// Returns the end ANTLRPosition if the Position is out of the end of text,-// returns the previous ANTLRPosition if the Position is in the middle of a character,-// returns the previous ANTLRPosition if the Position is out of the end of a line.-func ConvertPositionToANTLRPosition(p *storepb.Position, text string) *ANTLRPosition {- bs := []byte(text)- line := int32(0)- byteOffset := int32(0)- characterOffset := int32(0)-- for bi := 0; bi < len(bs); {- if line < p.Line {- if bs[bi] == '\n' {- line++- }- bi++- continue- }-- if byteOffset >= p.Column || bs[bi] == '\n' {- break- }-- r, sz := utf8.DecodeRune(bs[bi:])- if r == utf8.RuneError {- break- }- // Avoid endless loop.- if sz == 0 {- break- }-- byteOffset += int32(sz)- bi += sz- characterOffset++- }-- return &ANTLRPosition{- Line: line + 1,- Column: characterOffset,- }-}-// ConvertANTLRPositionToPosition converts an ANTLRPosition to a Position in a given text.// Returns the end Position if the ANTLRPosition is out of the end of text,// returns the previous Position if the ANTLRPosition is in the middle of a character,@@ -112,60 +62,18 @@ func ConvertANTLRPositionToPosition(a *ANTLRPosition, text string) *storepb.Posi}func ConvertANTLRLineToPosition(line int) *storepb.Position {- pLine := ConvertANTLRLineToPositionLine(line)- return &storepb.Position{- Line: int32(pLine),- }-}--func ConvertANTLRLineToPositionLine(line int) int {positionLine := line - 1if line == 0 {positionLine = 0}- return positionLine+ return &storepb.Position{+ Line: int32(positionLine),+ }}// UTF16Position is a position in a text expressed as zero-based line and zero-based column counted in UTF-16 code units.type UTF16Position = lsp.Position-// ConvertPositionToUTF16Position converts a Position to a UTF16Position in a given text.-// If the Position is nil, it returns a UTF16Position with line and character set to 0.-// If the line in Position is out of the end of text, replace it with the last line.-// If the column in Position is out of the end of line, replace it with the last column.-func ConvertPositionToUTF16Position(p *storepb.Position, text string) *UTF16Position {- if p == nil {- return &UTF16Position{- Line: 0,- Character: 0,- }- }- lines := strings.Split(text, "\n")- lineNumber := p.Line- if lineNumber >= int32(len(lines)) {- lineNumber = int32(len(lines)) - 1- }- u16CodeUnits := 0- byteOffset := 0- line := lines[lineNumber]- for _, r := range line {- if byteOffset >= int(p.Column) {- break- }- byteOffset += len(string(r))- u16CodeUnits++- if r > 0xFFFF {- // Need surrogate pair.- u16CodeUnits++- }- }-- return &UTF16Position{- Line: uint32(lineNumber),- Character: uint32(u16CodeUnits),- }-}-func ConvertTiDBParserErrorPositionToPosition(line, column int) *storepb.Position {if line < 1 {line = 1@@ -203,17 +111,3 @@ func ConvertPGParserErrorCursorPosToPosition(cursorPos int, text string) *storepColumn: int32(column),}}--func ConvertLineToActionLine(line int) int {- if line < 0 {- return 1- }- return line + 1-}--func ConvertPGParserLineToPosition(line int) *storepb.Position {- return &storepb.Position{- Line: int32(line),- Column: 0,- }-}diff --git a/backend/common/position_test.go b/backend/common/position_test.goindex 9264f92fd1..050462ceb3 100644--- a/backend/common/position_test.go+++ b/backend/common/position_test.go@@ -9,40 +9,6 @@ import (storepb "github.com/bytebase/bytebase/backend/generated-go/store")-func TestConvertPositionToANTLRPosition(t *testing.T) {- testCases := []struct {- description string- text string- position *storepb.Position- want *ANTLRPosition- }{- {- description: "empty text",- text: "",- position: &storepb.Position{Line: 0, Column: 0},- want: &ANTLRPosition{Line: 1, Column: 0},- },- {- description: "ascii",- text: "hello, world",- position: &storepb.Position{Line: 0, Column: 6},- want: &ANTLRPosition{Line: 1, Column: 6},- },- {- description: "multi-bytes characters",- text: "你好\n世界",- position: &storepb.Position{Line: 1, Column: 3},- want: &ANTLRPosition{Line: 2, Column: 1},- },- }-- a := require.New(t)- for _, tc := range testCases {- got := ConvertPositionToANTLRPosition(tc.position, tc.text)- a.Equalf(tc.want, got, "Test case: %s", tc.description)- }-}-func TestConvertANTLRPositionToPosition(t *testing.T) {testCases := []struct {description string@@ -76,41 +42,3 @@ func TestConvertANTLRPositionToPosition(t *testing.T) {a.Equalf(tc.want, got, "Test case: %s", tc.description)}}--func TestConvertPositionToUTF16Position(t *testing.T) {- testCases := []struct {- description string- text string- position *storepb.Position- want *UTF16Position- }{- {- description: "empty text",- text: "",- position: &storepb.Position{Line: 0, Column: 0},- want: &UTF16Position{Line: 0, Character: 0},- },- {- description: "ascii",- text: "hello, world",- position: &storepb.Position{Line: 0, Column: 6},- want: &UTF16Position{Line: 0, Character: 6},- },- {- description: "surrogate pairs",- // 𝄞 encoded in utf16 with 2 code units, and 4 code units in utf8.- text: "abc𝄞def",- position: &storepb.Position{Line: 0, Column: 7},- want: &UTF16Position{- Line: 0,- Character: 5,- },- },- }-- a := require.New(t)- for _, tc := range testCases {- got := ConvertPositionToUTF16Position(tc.position, tc.text)- a.Equalf(tc.want, got, "Test case: %s", tc.description)- }-}diff --git a/backend/component/sheet/sheet.go b/backend/component/sheet/sheet.goindex 73fbc65b6d..354d6543b9 100644--- a/backend/component/sheet/sheet.go+++ b/backend/component/sheet/sheet.go@@ -253,7 +253,7 @@ func syntaxCheck(dbType storepb.Engine, statement string) (any, []*storepb.AdvicCode: InternalErrorCode,Title: "Unsupported database type",Content: fmt.Sprintf("Unsupported database type %s", dbType),- StartPosition: common.FirstLinePosition,+ StartPosition: nil,},}}@@ -278,7 +278,7 @@ func dorisSyntaxCheck(statement string) (any, []*storepb.Advice) {Code: InternalErrorCode,Title: "Parse error",Content: err.Error(),- StartPosition: common.FirstLinePosition,+ StartPosition: nil,},}}@@ -298,7 +298,7 @@ func cockroachdbSyntaxCheck(statement string) (any, []*storepb.Advice) {Code: InternalErrorCode,Title: "Parse error",Content: err.Error(),- StartPosition: common.FirstLinePosition,+ StartPosition: nil,},}}@@ -329,7 +329,7 @@ func partiqlSyntaxCheck(statement string) (any, []*storepb.Advice) {Code: InternalErrorCode,Title: "Parse error",Content: err.Error(),- StartPosition: common.FirstLinePosition,+ StartPosition: nil,},}}@@ -360,7 +360,7 @@ func mssqlSyntaxCheck(statement string) (any, []*storepb.Advice) {Code: InternalErrorCode,Title: "Parse error",Content: err.Error(),- StartPosition: common.FirstLinePosition,+ StartPosition: nil,},}}@@ -391,7 +391,7 @@ func snowflakeSyntaxCheck(statement string) (any, []*storepb.Advice) {Code: InternalErrorCode,Title: "Parse error",Content: err.Error(),- StartPosition: common.FirstLinePosition,+ StartPosition: nil,},}}@@ -421,7 +421,7 @@ func oracleSyntaxCheck(statement string) (any, []*storepb.Advice) {Code: InternalErrorCode,Title: "Parse error",Content: err.Error(),- StartPosition: common.FirstLinePosition,+ StartPosition: nil,},}}@@ -486,7 +486,7 @@ func redshiftSyntaxCheck(statement string) (any, []*storepb.Advice) {Code: InternalErrorCode,Title: "Parse error",Content: err.Error(),- StartPosition: common.FirstLinePosition,+ StartPosition: nil,},}}@@ -542,7 +542,7 @@ func mysqlSyntaxCheck(statement string) (any, []*storepb.Advice) {Code: InternalErrorCode,Title: "Parse error",Content: err.Error(),- StartPosition: common.FirstLinePosition,+ StartPosition: nil,},}}@@ -577,7 +577,7 @@ func tidbSyntaxCheck(statement string) (any, []*storepb.Advice) {Code: InternalErrorCode,Title: "Syntax error",Content: err.Error(),- StartPosition: common.FirstLinePosition,+ StartPosition: nil,},}}diff --git a/backend/generated-go/v1/database_service.pb.go b/backend/generated-go/v1/database_service.pb.goindex 4852f4e6f2..55fca61f5a 100644--- a/backend/generated-go/v1/database_service.pb.go+++ b/backend/generated-go/v1/database_service.pb.go@@ -1374,9 +1374,7 @@ type GetDatabaseSchemaRequest struct {state protoimpl.MessageState `protogen:"open.v1"`// The name of the database to retrieve schema.// Format: instances/{instance}/databases/{database}/schema- Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`- // Format the schema dump into SDL format.- SdlFormat bool `protobuf:"varint,2,opt,name=sdl_format,json=sdlFormat,proto3" json:"sdl_format,omitempty"`+ Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`unknownFields protoimpl.UnknownFieldssizeCache protoimpl.SizeCache}@@ -1418,13 +1416,6 @@ func (x *GetDatabaseSchemaRequest) GetName() string {return ""}-func (x *GetDatabaseSchemaRequest) GetSdlFormat() bool {- if x != nil {- return x.SdlFormat- }- return false-}-type DiffSchemaRequest struct {state protoimpl.MessageState `protogen:"open.v1"`// The name of the database or changelog.@@ -1436,9 +1427,7 @@ type DiffSchemaRequest struct {//// *DiffSchemaRequest_Schema// *DiffSchemaRequest_Changelog- Target isDiffSchemaRequest_Target `protobuf_oneof:"target"`- // Format the schema dump into SDL format.- SdlFormat bool `protobuf:"varint,4,opt,name=sdl_format,json=sdlFormat,proto3" json:"sdl_format,omitempty"`+ Target isDiffSchemaRequest_Target `protobuf_oneof:"target"`unknownFields protoimpl.UnknownFieldssizeCache protoimpl.SizeCache}@@ -1505,13 +1494,6 @@ func (x *DiffSchemaRequest) GetChangelog() string {return ""}-func (x *DiffSchemaRequest) GetSdlFormat() bool {- if x != nil {- return x.SdlFormat- }- return false-}-type isDiffSchemaRequest_Target interface {isDiffSchemaRequest_Target()}@@ -5623,10 +5605,8 @@ type GetChangelogRequest struct {state protoimpl.MessageState `protogen:"open.v1"`// The name of the changelog to retrieve.// Format: instances/{instance}/databases/{database}/changelogs/{changelog}- Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`- View ChangelogView `protobuf:"varint,2,opt,name=view,proto3,enum=bytebase.v1.ChangelogView" json:"view,omitempty"`- // Format the schema dump into SDL format.- SdlFormat bool `protobuf:"varint,3,opt,name=sdl_format,json=sdlFormat,proto3" json:"sdl_format,omitempty"`+ Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`+ View ChangelogView `protobuf:"varint,2,opt,name=view,proto3,enum=bytebase.v1.ChangelogView" json:"view,omitempty"`unknownFields protoimpl.UnknownFieldssizeCache protoimpl.SizeCache}@@ -5675,13 +5655,6 @@ func (x *GetChangelogRequest) GetView() ChangelogView {return ChangelogView_CHANGELOG_VIEW_UNSPECIFIED}-func (x *GetChangelogRequest) GetSdlFormat() bool {- if x != nil {- return x.SdlFormat- }- return false-}-type Changelog struct {state protoimpl.MessageState `protogen:"open.v1"`// Format: instances/{instance}/databases/{database}/changelogs/{changelog}@@ -6036,19 +6009,15 @@ const file_v1_database_service_proto_rawDesc = "" +"\x04name\x18\x01 \x01(\tB%\xe0A\x02\xfaA\x1f\n" +"\x1dbytebase.com/DatabaseMetadataR\x04name\x12\x16\n" +"\x06filter\x18\x02 \x01(\tR\x06filter\x12\x14\n" +- "\x05limit\x18\x03 \x01(\x05R\x05limit\"r\n" ++ "\x05limit\x18\x03 \x01(\x05R\x05limit\"S\n" +"\x18GetDatabaseSchemaRequest\x127\n" +"\x04name\x18\x01 \x01(\tB#\xe0A\x02\xfaA\x1d\n" +- "\x1bbytebase.com/DatabaseSchemaR\x04name\x12\x1d\n" +- "\n" +- "sdl_format\x18\x02 \x01(\bR\tsdlFormat\"\xa9\x01\n" ++ "\x1bbytebase.com/DatabaseSchemaR\x04name\"\x8a\x01\n" +"\x11DiffSchemaRequest\x121\n" +"\x04name\x18\x01 \x01(\tB\x1d\xe0A\x02\xfaA\x17\n" +"\x15bytebase.com/DatabaseR\x04name\x12\x18\n" +"\x06schema\x18\x02 \x01(\tH\x00R\x06schema\x12\x1e\n" +- "\tchangelog\x18\x03 \x01(\tH\x00R\tchangelog\x12\x1d\n" +- "\n" +- "sdl_format\x18\x04 \x01(\bR\tsdlFormatB\b\n" ++ "\tchangelog\x18\x03 \x01(\tH\x00R\tchangelogB\b\n" +"\x06target\"(\n" +"\x12DiffSchemaResponse\x12\x12\n" +"\x04diff\x18\x01 \x01(\tR\x04diff\"\xde\x05\n" +@@ -6473,13 +6442,11 @@ const file_v1_database_service_proto_rawDesc = "" +"\n" +"changelogs\x18\x01 \x03(\v2\x16.bytebase.v1.ChangelogR\n" +"changelogs\x12&\n" +- "\x0fnext_page_token\x18\x02 \x01(\tR\rnextPageToken\"\xa0\x01\n" ++ "\x0fnext_page_token\x18\x02 \x01(\tR\rnextPageToken\"\x81\x01\n" +"\x13GetChangelogRequest\x12:\n" +"\x04name\x18\x01 \x01(\tB&\xe0A\x02\xfaA \n" +"\x1ebytebase.com/DatabaseChangelogR\x04name\x12.\n" +- "\x04view\x18\x02 \x01(\x0e2\x1a.bytebase.v1.ChangelogViewR\x04view\x12\x1d\n" +- "\n" +- "sdl_format\x18\x03 \x01(\bR\tsdlFormat\"\xf2\a\n" ++ "\x04view\x18\x02 \x01(\x0e2\x1a.bytebase.v1.ChangelogViewR\x04view\"\xf2\a\n" +"\tChangelog\x12\x12\n" +"\x04name\x18\x01 \x01(\tR\x04name\x12;\n" +"\vcreate_time\x18\x03 \x01(\v2\x1a.google.protobuf.TimestampR\n" +diff --git a/backend/generated-go/v1/database_service.pb.gw.go b/backend/generated-go/v1/database_service.pb.gw.goindex e1fbad4186..4926681217 100644--- a/backend/generated-go/v1/database_service.pb.gw.go+++ b/backend/generated-go/v1/database_service.pb.gw.go@@ -608,8 +608,6 @@ func local_request_DatabaseService_GetDatabaseMetadata_0(ctx context.Context, mareturn msg, metadata, err}-var filter_DatabaseService_GetDatabaseSchema_0 = &utilities.DoubleArray{Encoding: map[string]int{"name": 0}, Base: []int{1, 1, 0}, Check: []int{0, 1, 2}}-func request_DatabaseService_GetDatabaseSchema_0(ctx context.Context, marshaler runtime.Marshaler, client DatabaseServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {var (protoReq GetDatabaseSchemaRequest@@ -627,12 +625,6 @@ func request_DatabaseService_GetDatabaseSchema_0(ctx context.Context, marshalerif err != nil {return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "name", err)}- if err := req.ParseForm(); err != nil {- return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)- }- if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_DatabaseService_GetDatabaseSchema_0); err != nil {- return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)- }msg, err := client.GetDatabaseSchema(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))return msg, metadata, err}@@ -651,12 +643,6 @@ func local_request_DatabaseService_GetDatabaseSchema_0(ctx context.Context, marsif err != nil {return nil, metadata, status.Errorf(codes.InvalidArgument, "type mismatch, parameter: %s, error: %v", "name", err)}- if err := req.ParseForm(); err != nil {- return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)- }- if err := runtime.PopulateQueryParameters(&protoReq, req.Form, filter_DatabaseService_GetDatabaseSchema_0); err != nil {- return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)- }msg, err := server.GetDatabaseSchema(ctx, &protoReq)return msg, metadata, err}diff --git a/backend/generated-go/v1/database_service_equal.pb.go b/backend/generated-go/v1/database_service_equal.pb.goindex 2e50faef7b..a54838e047 100644--- a/backend/generated-go/v1/database_service_equal.pb.go+++ b/backend/generated-go/v1/database_service_equal.pb.go@@ -252,9 +252,6 @@ func (x *GetDatabaseSchemaRequest) Equal(y *GetDatabaseSchemaRequest) bool {if x.Name != y.Name {return false}- if x.SdlFormat != y.SdlFormat {- return false- }return true}@@ -274,9 +271,6 @@ func (x *DiffSchemaRequest) Equal(y *DiffSchemaRequest) bool {if x.GetChangelog() != y.GetChangelog() {return false}- if x.SdlFormat != y.SdlFormat {- return false- }return true}@@ -1815,9 +1809,6 @@ func (x *GetChangelogRequest) Equal(y *GetChangelogRequest) bool {if x.View != y.View {return false}- if x.SdlFormat != y.SdlFormat {- return false- }return true}diff --git a/backend/generated-go/v1/sql_service.pb.go b/backend/generated-go/v1/sql_service.pb.goindex f6d9a6c297..2fd3ac47ea 100644--- a/backend/generated-go/v1/sql_service.pb.go+++ b/backend/generated-go/v1/sql_service.pb.go@@ -254,7 +254,7 @@ func (x CheckRequest_ChangeType) Number() protoreflect.EnumNumber {// Deprecated: Use CheckRequest_ChangeType.Descriptor instead.func (CheckRequest_ChangeType) EnumDescriptor() ([]byte, []int) {- return file_v1_sql_service_proto_rawDescGZIP(), []int{14, 0}+ return file_v1_sql_service_proto_rawDescGZIP(), []int{12, 0}}type QueryHistory_Type int32@@ -306,7 +306,7 @@ func (x QueryHistory_Type) Number() protoreflect.EnumNumber {// Deprecated: Use QueryHistory_Type.Descriptor instead.func (QueryHistory_Type) EnumDescriptor() ([]byte, []int) {- return file_v1_sql_service_proto_rawDescGZIP(), []int{20, 0}+ return file_v1_sql_service_proto_rawDescGZIP(), []int{18, 0}}type AdminExecuteRequest struct {@@ -1458,125 +1458,6 @@ func (x *ExportResponse) GetContent() []byte {return nil}-type PrettyRequest struct {- state protoimpl.MessageState `protogen:"open.v1"`- Engine Engine `protobuf:"varint,1,opt,name=engine,proto3,enum=bytebase.v1.Engine" json:"engine,omitempty"`- // The SDL format SQL schema information that was dumped from a database- // engine. This information will be sorted to match the order of statements in- // the userSchema.- CurrentSchema string `protobuf:"bytes,2,opt,name=current_schema,json=currentSchema,proto3" json:"current_schema,omitempty"`- // The expected SDL schema. This schema will be checked for correctness and- // normalized.- ExpectedSchema string `protobuf:"bytes,3,opt,name=expected_schema,json=expectedSchema,proto3" json:"expected_schema,omitempty"`- unknownFields protoimpl.UnknownFields- sizeCache protoimpl.SizeCache-}--func (x *PrettyRequest) Reset() {- *x = PrettyRequest{}- mi := &file_v1_sql_service_proto_msgTypes[12]- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))- ms.StoreMessageInfo(mi)-}--func (x *PrettyRequest) String() string {- return protoimpl.X.MessageStringOf(x)-}--func (*PrettyRequest) ProtoMessage() {}--func (x *PrettyRequest) ProtoReflect() protoreflect.Message {- mi := &file_v1_sql_service_proto_msgTypes[12]- if x != nil {- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))- if ms.LoadMessageInfo() == nil {- ms.StoreMessageInfo(mi)- }- return ms- }- return mi.MessageOf(x)-}--// Deprecated: Use PrettyRequest.ProtoReflect.Descriptor instead.-func (*PrettyRequest) Descriptor() ([]byte, []int) {- return file_v1_sql_service_proto_rawDescGZIP(), []int{12}-}--func (x *PrettyRequest) GetEngine() Engine {- if x != nil {- return x.Engine- }- return Engine_ENGINE_UNSPECIFIED-}--func (x *PrettyRequest) GetCurrentSchema() string {- if x != nil {- return x.CurrentSchema- }- return ""-}--func (x *PrettyRequest) GetExpectedSchema() string {- if x != nil {- return x.ExpectedSchema- }- return ""-}--type PrettyResponse struct {- state protoimpl.MessageState `protogen:"open.v1"`- // The pretty-formatted version of current schema.- CurrentSchema string `protobuf:"bytes,1,opt,name=current_schema,json=currentSchema,proto3" json:"current_schema,omitempty"`- // The expected SDL schema after normalizing.- ExpectedSchema string `protobuf:"bytes,2,opt,name=expected_schema,json=expectedSchema,proto3" json:"expected_schema,omitempty"`- unknownFields protoimpl.UnknownFields- sizeCache protoimpl.SizeCache-}--func (x *PrettyResponse) Reset() {- *x = PrettyResponse{}- mi := &file_v1_sql_service_proto_msgTypes[13]- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))- ms.StoreMessageInfo(mi)-}--func (x *PrettyResponse) String() string {- return protoimpl.X.MessageStringOf(x)-}--func (*PrettyResponse) ProtoMessage() {}--func (x *PrettyResponse) ProtoReflect() protoreflect.Message {- mi := &file_v1_sql_service_proto_msgTypes[13]- if x != nil {- ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))- if ms.LoadMessageInfo() == nil {- ms.StoreMessageInfo(mi)- }- return ms- }- return mi.MessageOf(x)-}--// Deprecated: Use PrettyResponse.ProtoReflect.Descriptor instead.-func (*PrettyResponse) Descriptor() ([]byte, []int) {- return file_v1_sql_service_proto_rawDescGZIP(), []int{13}-}--func (x *PrettyResponse) GetCurrentSchema() string {- if x != nil {- return x.CurrentSchema- }- return ""-}--func (x *PrettyResponse) GetExpectedSchema() string {- if x != nil {- return x.ExpectedSchema- }- return ""-}-type CheckRequest struct {state protoimpl.MessageState `protogen:"open.v1"`// The database name to check against.@@ -1590,7 +1471,7 @@ type CheckRequest struct {func (x *CheckRequest) Reset() {*x = CheckRequest{}- mi := &file_v1_sql_service_proto_msgTypes[14]+ mi := &file_v1_sql_service_proto_msgTypes[12]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -1602,7 +1483,7 @@ func (x *CheckRequest) String() string {func (*CheckRequest) ProtoMessage() {}func (x *CheckRequest) ProtoReflect() protoreflect.Message {- mi := &file_v1_sql_service_proto_msgTypes[14]+ mi := &file_v1_sql_service_proto_msgTypes[12]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -1615,7 +1496,7 @@ func (x *CheckRequest) ProtoReflect() protoreflect.Message {// Deprecated: Use CheckRequest.ProtoReflect.Descriptor instead.func (*CheckRequest) Descriptor() ([]byte, []int) {- return file_v1_sql_service_proto_rawDescGZIP(), []int{14}+ return file_v1_sql_service_proto_rawDescGZIP(), []int{12}}func (x *CheckRequest) GetName() string {@@ -1650,7 +1531,7 @@ type CheckResponse struct {func (x *CheckResponse) Reset() {*x = CheckResponse{}- mi := &file_v1_sql_service_proto_msgTypes[15]+ mi := &file_v1_sql_service_proto_msgTypes[13]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -1662,7 +1543,7 @@ func (x *CheckResponse) String() string {func (*CheckResponse) ProtoMessage() {}func (x *CheckResponse) ProtoReflect() protoreflect.Message {- mi := &file_v1_sql_service_proto_msgTypes[15]+ mi := &file_v1_sql_service_proto_msgTypes[13]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -1675,7 +1556,7 @@ func (x *CheckResponse) ProtoReflect() protoreflect.Message {// Deprecated: Use CheckResponse.ProtoReflect.Descriptor instead.func (*CheckResponse) Descriptor() ([]byte, []int) {- return file_v1_sql_service_proto_rawDescGZIP(), []int{15}+ return file_v1_sql_service_proto_rawDescGZIP(), []int{13}}func (x *CheckResponse) GetAdvices() []*Advice {@@ -1711,7 +1592,7 @@ type DiffMetadataRequest struct {func (x *DiffMetadataRequest) Reset() {*x = DiffMetadataRequest{}- mi := &file_v1_sql_service_proto_msgTypes[16]+ mi := &file_v1_sql_service_proto_msgTypes[14]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -1723,7 +1604,7 @@ func (x *DiffMetadataRequest) String() string {func (*DiffMetadataRequest) ProtoMessage() {}func (x *DiffMetadataRequest) ProtoReflect() protoreflect.Message {- mi := &file_v1_sql_service_proto_msgTypes[16]+ mi := &file_v1_sql_service_proto_msgTypes[14]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -1736,7 +1617,7 @@ func (x *DiffMetadataRequest) ProtoReflect() protoreflect.Message {// Deprecated: Use DiffMetadataRequest.ProtoReflect.Descriptor instead.func (*DiffMetadataRequest) Descriptor() ([]byte, []int) {- return file_v1_sql_service_proto_rawDescGZIP(), []int{16}+ return file_v1_sql_service_proto_rawDescGZIP(), []int{14}}func (x *DiffMetadataRequest) GetSourceMetadata() *DatabaseMetadata {@@ -1791,7 +1672,7 @@ type DiffMetadataResponse struct {func (x *DiffMetadataResponse) Reset() {*x = DiffMetadataResponse{}- mi := &file_v1_sql_service_proto_msgTypes[17]+ mi := &file_v1_sql_service_proto_msgTypes[15]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -1803,7 +1684,7 @@ func (x *DiffMetadataResponse) String() string {func (*DiffMetadataResponse) ProtoMessage() {}func (x *DiffMetadataResponse) ProtoReflect() protoreflect.Message {- mi := &file_v1_sql_service_proto_msgTypes[17]+ mi := &file_v1_sql_service_proto_msgTypes[15]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -1816,7 +1697,7 @@ func (x *DiffMetadataResponse) ProtoReflect() protoreflect.Message {// Deprecated: Use DiffMetadataResponse.ProtoReflect.Descriptor instead.func (*DiffMetadataResponse) Descriptor() ([]byte, []int) {- return file_v1_sql_service_proto_rawDescGZIP(), []int{17}+ return file_v1_sql_service_proto_rawDescGZIP(), []int{15}}func (x *DiffMetadataResponse) GetDiff() string {@@ -1861,7 +1742,7 @@ type SearchQueryHistoriesRequest struct {func (x *SearchQueryHistoriesRequest) Reset() {*x = SearchQueryHistoriesRequest{}- mi := &file_v1_sql_service_proto_msgTypes[18]+ mi := &file_v1_sql_service_proto_msgTypes[16]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -1873,7 +1754,7 @@ func (x *SearchQueryHistoriesRequest) String() string {func (*SearchQueryHistoriesRequest) ProtoMessage() {}func (x *SearchQueryHistoriesRequest) ProtoReflect() protoreflect.Message {- mi := &file_v1_sql_service_proto_msgTypes[18]+ mi := &file_v1_sql_service_proto_msgTypes[16]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -1886,7 +1767,7 @@ func (x *SearchQueryHistoriesRequest) ProtoReflect() protoreflect.Message {// Deprecated: Use SearchQueryHistoriesRequest.ProtoReflect.Descriptor instead.func (*SearchQueryHistoriesRequest) Descriptor() ([]byte, []int) {- return file_v1_sql_service_proto_rawDescGZIP(), []int{18}+ return file_v1_sql_service_proto_rawDescGZIP(), []int{16}}func (x *SearchQueryHistoriesRequest) GetPageSize() int32 {@@ -1924,7 +1805,7 @@ type SearchQueryHistoriesResponse struct {func (x *SearchQueryHistoriesResponse) Reset() {*x = SearchQueryHistoriesResponse{}- mi := &file_v1_sql_service_proto_msgTypes[19]+ mi := &file_v1_sql_service_proto_msgTypes[17]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -1936,7 +1817,7 @@ func (x *SearchQueryHistoriesResponse) String() string {func (*SearchQueryHistoriesResponse) ProtoMessage() {}func (x *SearchQueryHistoriesResponse) ProtoReflect() protoreflect.Message {- mi := &file_v1_sql_service_proto_msgTypes[19]+ mi := &file_v1_sql_service_proto_msgTypes[17]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -1949,7 +1830,7 @@ func (x *SearchQueryHistoriesResponse) ProtoReflect() protoreflect.Message {// Deprecated: Use SearchQueryHistoriesResponse.ProtoReflect.Descriptor instead.func (*SearchQueryHistoriesResponse) Descriptor() ([]byte, []int) {- return file_v1_sql_service_proto_rawDescGZIP(), []int{19}+ return file_v1_sql_service_proto_rawDescGZIP(), []int{17}}func (x *SearchQueryHistoriesResponse) GetQueryHistories() []*QueryHistory {@@ -1986,7 +1867,7 @@ type QueryHistory struct {func (x *QueryHistory) Reset() {*x = QueryHistory{}- mi := &file_v1_sql_service_proto_msgTypes[20]+ mi := &file_v1_sql_service_proto_msgTypes[18]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -1998,7 +1879,7 @@ func (x *QueryHistory) String() string {func (*QueryHistory) ProtoMessage() {}func (x *QueryHistory) ProtoReflect() protoreflect.Message {- mi := &file_v1_sql_service_proto_msgTypes[20]+ mi := &file_v1_sql_service_proto_msgTypes[18]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -2011,7 +1892,7 @@ func (x *QueryHistory) ProtoReflect() protoreflect.Message {// Deprecated: Use QueryHistory.ProtoReflect.Descriptor instead.func (*QueryHistory) Descriptor() ([]byte, []int) {- return file_v1_sql_service_proto_rawDescGZIP(), []int{20}+ return file_v1_sql_service_proto_rawDescGZIP(), []int{18}}func (x *QueryHistory) GetName() string {@@ -2079,7 +1960,7 @@ type AICompletionRequest struct {func (x *AICompletionRequest) Reset() {*x = AICompletionRequest{}- mi := &file_v1_sql_service_proto_msgTypes[21]+ mi := &file_v1_sql_service_proto_msgTypes[19]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -2091,7 +1972,7 @@ func (x *AICompletionRequest) String() string {func (*AICompletionRequest) ProtoMessage() {}func (x *AICompletionRequest) ProtoReflect() protoreflect.Message {- mi := &file_v1_sql_service_proto_msgTypes[21]+ mi := &file_v1_sql_service_proto_msgTypes[19]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -2104,7 +1985,7 @@ func (x *AICompletionRequest) ProtoReflect() protoreflect.Message {// Deprecated: Use AICompletionRequest.ProtoReflect.Descriptor instead.func (*AICompletionRequest) Descriptor() ([]byte, []int) {- return file_v1_sql_service_proto_rawDescGZIP(), []int{21}+ return file_v1_sql_service_proto_rawDescGZIP(), []int{19}}func (x *AICompletionRequest) GetMessages() []*AICompletionRequest_Message {@@ -2125,7 +2006,7 @@ type AICompletionResponse struct {func (x *AICompletionResponse) Reset() {*x = AICompletionResponse{}- mi := &file_v1_sql_service_proto_msgTypes[22]+ mi := &file_v1_sql_service_proto_msgTypes[20]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -2137,7 +2018,7 @@ func (x *AICompletionResponse) String() string {func (*AICompletionResponse) ProtoMessage() {}func (x *AICompletionResponse) ProtoReflect() protoreflect.Message {- mi := &file_v1_sql_service_proto_msgTypes[22]+ mi := &file_v1_sql_service_proto_msgTypes[20]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -2150,7 +2031,7 @@ func (x *AICompletionResponse) ProtoReflect() protoreflect.Message {// Deprecated: Use AICompletionResponse.ProtoReflect.Descriptor instead.func (*AICompletionResponse) Descriptor() ([]byte, []int) {- return file_v1_sql_service_proto_rawDescGZIP(), []int{22}+ return file_v1_sql_service_proto_rawDescGZIP(), []int{20}}func (x *AICompletionResponse) GetCandidates() []*AICompletionResponse_Candidate {@@ -2187,7 +2068,7 @@ type QueryResult_PostgresError struct {func (x *QueryResult_PostgresError) Reset() {*x = QueryResult_PostgresError{}- mi := &file_v1_sql_service_proto_msgTypes[23]+ mi := &file_v1_sql_service_proto_msgTypes[21]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -2199,7 +2080,7 @@ func (x *QueryResult_PostgresError) String() string {func (*QueryResult_PostgresError) ProtoMessage() {}func (x *QueryResult_PostgresError) ProtoReflect() protoreflect.Message {- mi := &file_v1_sql_service_proto_msgTypes[23]+ mi := &file_v1_sql_service_proto_msgTypes[21]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -2344,7 +2225,7 @@ type QueryResult_Message struct {func (x *QueryResult_Message) Reset() {*x = QueryResult_Message{}- mi := &file_v1_sql_service_proto_msgTypes[24]+ mi := &file_v1_sql_service_proto_msgTypes[22]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -2356,7 +2237,7 @@ func (x *QueryResult_Message) String() string {func (*QueryResult_Message) ProtoMessage() {}func (x *QueryResult_Message) ProtoReflect() protoreflect.Message {- mi := &file_v1_sql_service_proto_msgTypes[24]+ mi := &file_v1_sql_service_proto_msgTypes[22]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -2397,7 +2278,7 @@ type RowValue_Timestamp struct {func (x *RowValue_Timestamp) Reset() {*x = RowValue_Timestamp{}- mi := &file_v1_sql_service_proto_msgTypes[25]+ mi := &file_v1_sql_service_proto_msgTypes[23]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -2409,7 +2290,7 @@ func (x *RowValue_Timestamp) String() string {func (*RowValue_Timestamp) ProtoMessage() {}func (x *RowValue_Timestamp) ProtoReflect() protoreflect.Message {- mi := &file_v1_sql_service_proto_msgTypes[25]+ mi := &file_v1_sql_service_proto_msgTypes[23]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -2458,7 +2339,7 @@ type RowValue_TimestampTZ struct {func (x *RowValue_TimestampTZ) Reset() {*x = RowValue_TimestampTZ{}- mi := &file_v1_sql_service_proto_msgTypes[26]+ mi := &file_v1_sql_service_proto_msgTypes[24]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -2470,7 +2351,7 @@ func (x *RowValue_TimestampTZ) String() string {func (*RowValue_TimestampTZ) ProtoMessage() {}func (x *RowValue_TimestampTZ) ProtoReflect() protoreflect.Message {- mi := &file_v1_sql_service_proto_msgTypes[26]+ mi := &file_v1_sql_service_proto_msgTypes[24]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -2524,7 +2405,7 @@ type AICompletionRequest_Message struct {func (x *AICompletionRequest_Message) Reset() {*x = AICompletionRequest_Message{}- mi := &file_v1_sql_service_proto_msgTypes[27]+ mi := &file_v1_sql_service_proto_msgTypes[25]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -2536,7 +2417,7 @@ func (x *AICompletionRequest_Message) String() string {func (*AICompletionRequest_Message) ProtoMessage() {}func (x *AICompletionRequest_Message) ProtoReflect() protoreflect.Message {- mi := &file_v1_sql_service_proto_msgTypes[27]+ mi := &file_v1_sql_service_proto_msgTypes[25]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -2549,7 +2430,7 @@ func (x *AICompletionRequest_Message) ProtoReflect() protoreflect.Message {// Deprecated: Use AICompletionRequest_Message.ProtoReflect.Descriptor instead.func (*AICompletionRequest_Message) Descriptor() ([]byte, []int) {- return file_v1_sql_service_proto_rawDescGZIP(), []int{21, 0}+ return file_v1_sql_service_proto_rawDescGZIP(), []int{19, 0}}func (x *AICompletionRequest_Message) GetRole() string {@@ -2575,7 +2456,7 @@ type AICompletionResponse_Candidate struct {func (x *AICompletionResponse_Candidate) Reset() {*x = AICompletionResponse_Candidate{}- mi := &file_v1_sql_service_proto_msgTypes[28]+ mi := &file_v1_sql_service_proto_msgTypes[26]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -2587,7 +2468,7 @@ func (x *AICompletionResponse_Candidate) String() string {func (*AICompletionResponse_Candidate) ProtoMessage() {}func (x *AICompletionResponse_Candidate) ProtoReflect() protoreflect.Message {- mi := &file_v1_sql_service_proto_msgTypes[28]+ mi := &file_v1_sql_service_proto_msgTypes[26]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -2600,7 +2481,7 @@ func (x *AICompletionResponse_Candidate) ProtoReflect() protoreflect.Message {// Deprecated: Use AICompletionResponse_Candidate.ProtoReflect.Descriptor instead.func (*AICompletionResponse_Candidate) Descriptor() ([]byte, []int) {- return file_v1_sql_service_proto_rawDescGZIP(), []int{22, 0}+ return file_v1_sql_service_proto_rawDescGZIP(), []int{20, 0}}func (x *AICompletionResponse_Candidate) GetContent() *AICompletionResponse_Candidate_Content {@@ -2620,7 +2501,7 @@ type AICompletionResponse_Candidate_Content struct {func (x *AICompletionResponse_Candidate_Content) Reset() {*x = AICompletionResponse_Candidate_Content{}- mi := &file_v1_sql_service_proto_msgTypes[29]+ mi := &file_v1_sql_service_proto_msgTypes[27]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -2632,7 +2513,7 @@ func (x *AICompletionResponse_Candidate_Content) String() string {func (*AICompletionResponse_Candidate_Content) ProtoMessage() {}func (x *AICompletionResponse_Candidate_Content) ProtoReflect() protoreflect.Message {- mi := &file_v1_sql_service_proto_msgTypes[29]+ mi := &file_v1_sql_service_proto_msgTypes[27]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -2645,7 +2526,7 @@ func (x *AICompletionResponse_Candidate_Content) ProtoReflect() protoreflect.Mes// Deprecated: Use AICompletionResponse_Candidate_Content.ProtoReflect.Descriptor instead.func (*AICompletionResponse_Candidate_Content) Descriptor() ([]byte, []int) {- return file_v1_sql_service_proto_rawDescGZIP(), []int{22, 0, 0}+ return file_v1_sql_service_proto_rawDescGZIP(), []int{20, 0, 0}}func (x *AICompletionResponse_Candidate_Content) GetParts() []*AICompletionResponse_Candidate_Content_Part {@@ -2664,7 +2545,7 @@ type AICompletionResponse_Candidate_Content_Part struct {func (x *AICompletionResponse_Candidate_Content_Part) Reset() {*x = AICompletionResponse_Candidate_Content_Part{}- mi := &file_v1_sql_service_proto_msgTypes[30]+ mi := &file_v1_sql_service_proto_msgTypes[28]ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))ms.StoreMessageInfo(mi)}@@ -2676,7 +2557,7 @@ func (x *AICompletionResponse_Candidate_Content_Part) String() string {func (*AICompletionResponse_Candidate_Content_Part) ProtoMessage() {}func (x *AICompletionResponse_Candidate_Content_Part) ProtoReflect() protoreflect.Message {- mi := &file_v1_sql_service_proto_msgTypes[30]+ mi := &file_v1_sql_service_proto_msgTypes[28]if x != nil {ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))if ms.LoadMessageInfo() == nil {@@ -2689,7 +2570,7 @@ func (x *AICompletionResponse_Candidate_Content_Part) ProtoReflect() protoreflec// Deprecated: Use AICompletionResponse_Candidate_Content_Part.ProtoReflect.Descriptor instead.func (*AICompletionResponse_Candidate_Content_Part) Descriptor() ([]byte, []int) {- return file_v1_sql_service_proto_rawDescGZIP(), []int{22, 0, 0, 0}+ return file_v1_sql_service_proto_rawDescGZIP(), []int{20, 0, 0, 0}}func (x *AICompletionResponse_Candidate_Content_Part) GetText() string {@@ -2852,14 +2733,7 @@ const file_v1_sql_service_proto_rawDesc = "" +"\x06schema\x18\t \x01(\tH\x00R\x06schema\x88\x01\x01B\t\n" +"\a_schemaJ\x04\b\x02\x10\x03\"*\n" +"\x0eExportResponse\x12\x18\n" +- "\acontent\x18\x01 \x01(\fR\acontent\"\x8c\x01\n" +- "\rPrettyRequest\x12+\n" +- "\x06engine\x18\x01 \x01(\x0e2\x13.bytebase.v1.EngineR\x06engine\x12%\n" +- "\x0ecurrent_schema\x18\x02 \x01(\tR\rcurrentSchema\x12'\n" +- "\x0fexpected_schema\x18\x03 \x01(\tR\x0eexpectedSchema\"`\n" +- "\x0ePrettyResponse\x12%\n" +- "\x0ecurrent_schema\x18\x01 \x01(\tR\rcurrentSchema\x12'\n" +- "\x0fexpected_schema\x18\x02 \x01(\tR\x0eexpectedSchema\"\x82\x02\n" ++ "\acontent\x18\x01 \x01(\fR\acontent\"\x82\x02\n" +"\fCheckRequest\x121\n" +"\x04name\x18\x02 \x01(\tB\x1d\xe0A\x02\xfaA\x17\n" +"\x15bytebase.com/DatabaseR\x04name\x12\x1c\n" +@@ -2924,15 +2798,14 @@ const file_v1_sql_service_proto_rawDesc = "" +"\aContent\x12N\n" +"\x05parts\x18\x01 \x03(\v28.bytebase.v1.AICompletionResponse.Candidate.Content.PartR\x05parts\x1a\x1a\n" +"\x04Part\x12\x12\n" +- "\x04text\x18\x01 \x01(\tR\x04text2\x93\t\n" ++ "\x04text\x18\x01 \x01(\tR\x04text2\xb1\b\n" +"\n" +"SQLService\x12\x8f\x01\n" +"\x05Query\x12\x19.bytebase.v1.QueryRequest\x1a\x1a.bytebase.v1.QueryResponse\"O\x8a\xea0\x10bb.databases.get\x90\xea0\x01\x98\xea0\x01\x82\xd3\xe4\x93\x02-:\x01*\"(/v1/{name=instances/*/databases/*}:query\x12\x89\x01\n" +"\fAdminExecute\x12 .bytebase.v1.AdminExecuteRequest\x1a!.bytebase.v1.AdminExecuteResponse\"0\x8a\xea0\fbb.sql.admin\x90\xea0\x01\x98\xea0\x01\x82\xd3\xe4\x93\x02\x12\x12\x10/v1:adminExecute(\x010\x01\x12\x95\x01\n" +"\x14SearchQueryHistories\x12(.bytebase.v1.SearchQueryHistoriesRequest\x1a).bytebase.v1.SearchQueryHistoriesResponse\"(\x90\xea0\x02\x82\xd3\xe4\x93\x02\x1e:\x01*\"\x19/v1/queryHistories:search\x12\xfa\x01\n" +"\x06Export\x12\x1a.bytebase.v1.ExportRequest\x1a\x1b.bytebase.v1.ExportResponse\"\xb6\x01\x8a\xea0\x10bb.databases.get\x90\xea0\x01\x98\xea0\x01\x82\xd3\xe4\x93\x02\x93\x01:\x01*Z,:\x01*\"'/v1/{name=projects/*/rollouts/*}:exportZ5:\x01*\"0/v1/{name=projects/*/rollouts/*/stages/*}:export\")/v1/{name=instances/*/databases/*}:export\x12r\n" +- "\x05Check\x12\x19.bytebase.v1.CheckRequest\x1a\x1a.bytebase.v1.CheckResponse\"2\x8a\xea0\x12bb.databases.check\x90\xea0\x01\x82\xd3\xe4\x93\x02\x12:\x01*\"\r/v1/sql/check\x12`\n" +- "\x06Pretty\x12\x1a.bytebase.v1.PrettyRequest\x1a\x1b.bytebase.v1.PrettyResponse\"\x1d\x80\xea0\x01\x82\xd3\xe4\x93\x02\x13:\x01*\"\x0e/v1/sql/pretty\x12\x81\x01\n" ++ "\x05Check\x12\x19.bytebase.v1.CheckRequest\x1a\x1a.bytebase.v1.CheckResponse\"2\x8a\xea0\x12bb.databases.check\x90\xea0\x01\x82\xd3\xe4\x93\x02\x12:\x01*\"\r/v1/sql/check\x12\x81\x01\n" +"\fDiffMetadata\x12 .bytebase.v1.DiffMetadataRequest\x1a!.bytebase.v1.DiffMetadataResponse\",\x80\xea0\x01\x82\xd3\xe4\x93\x02\":\x01*\"\x1d/v1/schemaDesign:diffMetadata\x12x\n" +"\fAICompletion\x12 .bytebase.v1.AICompletionRequest\x1a!.bytebase.v1.AICompletionResponse\"#\x90\xea0\x02\x82\xd3\xe4\x93\x02\x19:\x01*\"\x14/v1/sql/aiCompletionB6Z4github.com/bytebase/bytebase/backend/generated-go/v1b\x06proto3"@@ -2949,7 +2822,7 @@ func file_v1_sql_service_proto_rawDescGZIP() []byte {}var file_v1_sql_service_proto_enumTypes = make([]protoimpl.EnumInfo, 5)-var file_v1_sql_service_proto_msgTypes = make([]protoimpl.MessageInfo, 31)+var file_v1_sql_service_proto_msgTypes = make([]protoimpl.MessageInfo, 29)var file_v1_sql_service_proto_goTypes = []any{(QueryOption_RedisRunCommandsOn)(0), // 0: bytebase.v1.QueryOption.RedisRunCommandsOn(QueryResult_Message_Level)(0), // 1: bytebase.v1.QueryResult.Message.Level@@ -2968,34 +2841,32 @@ var file_v1_sql_service_proto_goTypes = []any{(*Advice)(nil), // 14: bytebase.v1.Advice(*ExportRequest)(nil), // 15: bytebase.v1.ExportRequest(*ExportResponse)(nil), // 16: bytebase.v1.ExportResponse- (*PrettyRequest)(nil), // 17: bytebase.v1.PrettyRequest- (*PrettyResponse)(nil), // 18: bytebase.v1.PrettyResponse- (*CheckRequest)(nil), // 19: bytebase.v1.CheckRequest- (*CheckResponse)(nil), // 20: bytebase.v1.CheckResponse- (*DiffMetadataRequest)(nil), // 21: bytebase.v1.DiffMetadataRequest- (*DiffMetadataResponse)(nil), // 22: bytebase.v1.DiffMetadataResponse- (*SearchQueryHistoriesRequest)(nil), // 23: bytebase.v1.SearchQueryHistoriesRequest- (*SearchQueryHistoriesResponse)(nil), // 24: bytebase.v1.SearchQueryHistoriesResponse- (*QueryHistory)(nil), // 25: bytebase.v1.QueryHistory- (*AICompletionRequest)(nil), // 26: bytebase.v1.AICompletionRequest- (*AICompletionResponse)(nil), // 27: bytebase.v1.AICompletionResponse- (*QueryResult_PostgresError)(nil), // 28: bytebase.v1.QueryResult.PostgresError- (*QueryResult_Message)(nil), // 29: bytebase.v1.QueryResult.Message- (*RowValue_Timestamp)(nil), // 30: bytebase.v1.RowValue.Timestamp- (*RowValue_TimestampTZ)(nil), // 31: bytebase.v1.RowValue.TimestampTZ- (*AICompletionRequest_Message)(nil), // 32: bytebase.v1.AICompletionRequest.Message- (*AICompletionResponse_Candidate)(nil), // 33: bytebase.v1.AICompletionResponse.Candidate- (*AICompletionResponse_Candidate_Content)(nil), // 34: bytebase.v1.AICompletionResponse.Candidate.Content- (*AICompletionResponse_Candidate_Content_Part)(nil), // 35: bytebase.v1.AICompletionResponse.Candidate.Content.Part- (*durationpb.Duration)(nil), // 36: google.protobuf.Duration- (structpb.NullValue)(0), // 37: google.protobuf.NullValue- (*structpb.Value)(nil), // 38: google.protobuf.Value- (*Position)(nil), // 39: bytebase.v1.Position- (ExportFormat)(0), // 40: bytebase.v1.ExportFormat+ (*CheckRequest)(nil), // 17: bytebase.v1.CheckRequest+ (*CheckResponse)(nil), // 18: bytebase.v1.CheckResponse+ (*DiffMetadataRequest)(nil), // 19: bytebase.v1.DiffMetadataRequest+ (*DiffMetadataResponse)(nil), // 20: bytebase.v1.DiffMetadataResponse+ (*SearchQueryHistoriesRequest)(nil), // 21: bytebase.v1.SearchQueryHistoriesRequest+ (*SearchQueryHistoriesResponse)(nil), // 22: bytebase.v1.SearchQueryHistoriesResponse+ (*QueryHistory)(nil), // 23: bytebase.v1.QueryHistory+ (*AICompletionRequest)(nil), // 24: bytebase.v1.AICompletionRequest+ (*AICompletionResponse)(nil), // 25: bytebase.v1.AICompletionResponse+ (*QueryResult_PostgresError)(nil), // 26: bytebase.v1.QueryResult.PostgresError+ (*QueryResult_Message)(nil), // 27: bytebase.v1.QueryResult.Message+ (*RowValue_Timestamp)(nil), // 28: bytebase.v1.RowValue.Timestamp+ (*RowValue_TimestampTZ)(nil), // 29: bytebase.v1.RowValue.TimestampTZ+ (*AICompletionRequest_Message)(nil), // 30: bytebase.v1.AICompletionRequest.Message+ (*AICompletionResponse_Candidate)(nil), // 31: bytebase.v1.AICompletionResponse.Candidate+ (*AICompletionResponse_Candidate_Content)(nil), // 32: bytebase.v1.AICompletionResponse.Candidate.Content+ (*AICompletionResponse_Candidate_Content_Part)(nil), // 33: bytebase.v1.AICompletionResponse.Candidate.Content.Part+ (*durationpb.Duration)(nil), // 34: google.protobuf.Duration+ (structpb.NullValue)(0), // 35: google.protobuf.NullValue+ (*structpb.Value)(nil), // 36: google.protobuf.Value+ (*Position)(nil), // 37: bytebase.v1.Position+ (ExportFormat)(0), // 38: bytebase.v1.ExportFormat+ (*DatabaseMetadata)(nil), // 39: bytebase.v1.DatabaseMetadata+ (*DatabaseCatalog)(nil), // 40: bytebase.v1.DatabaseCatalog(Engine)(0), // 41: bytebase.v1.Engine- (*DatabaseMetadata)(nil), // 42: bytebase.v1.DatabaseMetadata- (*DatabaseCatalog)(nil), // 43: bytebase.v1.DatabaseCatalog- (*timestamppb.Timestamp)(nil), // 44: google.protobuf.Timestamp+ (*timestamppb.Timestamp)(nil), // 42: google.protobuf.Timestamp}var file_v1_sql_service_proto_depIdxs = []int32{10, // 0: bytebase.v1.AdminExecuteResponse.results:type_name -> bytebase.v1.QueryResult@@ -3003,59 +2874,56 @@ var file_v1_sql_service_proto_depIdxs = []int32{10, // 2: bytebase.v1.QueryResponse.results:type_name -> bytebase.v1.QueryResult0, // 3: bytebase.v1.QueryOption.redis_run_commands_on:type_name -> bytebase.v1.QueryOption.RedisRunCommandsOn12, // 4: bytebase.v1.QueryResult.rows:type_name -> bytebase.v1.QueryRow- 36, // 5: bytebase.v1.QueryResult.latency:type_name -> google.protobuf.Duration- 28, // 6: bytebase.v1.QueryResult.postgres_error:type_name -> bytebase.v1.QueryResult.PostgresError- 29, // 7: bytebase.v1.QueryResult.messages:type_name -> bytebase.v1.QueryResult.Message+ 34, // 5: bytebase.v1.QueryResult.latency:type_name -> google.protobuf.Duration+ 26, // 6: bytebase.v1.QueryResult.postgres_error:type_name -> bytebase.v1.QueryResult.PostgresError+ 27, // 7: bytebase.v1.QueryResult.messages:type_name -> bytebase.v1.QueryResult.Message11, // 8: bytebase.v1.QueryResult.masked:type_name -> bytebase.v1.MaskingReason13, // 9: bytebase.v1.QueryRow.values:type_name -> bytebase.v1.RowValue- 37, // 10: bytebase.v1.RowValue.null_value:type_name -> google.protobuf.NullValue- 38, // 11: bytebase.v1.RowValue.value_value:type_name -> google.protobuf.Value- 30, // 12: bytebase.v1.RowValue.timestamp_value:type_name -> bytebase.v1.RowValue.Timestamp- 31, // 13: bytebase.v1.RowValue.timestamp_tz_value:type_name -> bytebase.v1.RowValue.TimestampTZ+ 35, // 10: bytebase.v1.RowValue.null_value:type_name -> google.protobuf.NullValue+ 36, // 11: bytebase.v1.RowValue.value_value:type_name -> google.protobuf.Value+ 28, // 12: bytebase.v1.RowValue.timestamp_value:type_name -> bytebase.v1.RowValue.Timestamp+ 29, // 13: bytebase.v1.RowValue.timestamp_tz_value:type_name -> bytebase.v1.RowValue.TimestampTZ2, // 14: bytebase.v1.Advice.status:type_name -> bytebase.v1.Advice.Level- 39, // 15: bytebase.v1.Advice.start_position:type_name -> bytebase.v1.Position- 39, // 16: bytebase.v1.Advice.end_position:type_name -> bytebase.v1.Position- 40, // 17: bytebase.v1.ExportRequest.format:type_name -> bytebase.v1.ExportFormat- 41, // 18: bytebase.v1.PrettyRequest.engine:type_name -> bytebase.v1.Engine- 3, // 19: bytebase.v1.CheckRequest.change_type:type_name -> bytebase.v1.CheckRequest.ChangeType- 14, // 20: bytebase.v1.CheckResponse.advices:type_name -> bytebase.v1.Advice- 42, // 21: bytebase.v1.DiffMetadataRequest.source_metadata:type_name -> bytebase.v1.DatabaseMetadata- 42, // 22: bytebase.v1.DiffMetadataRequest.target_metadata:type_name -> bytebase.v1.DatabaseMetadata- 43, // 23: bytebase.v1.DiffMetadataRequest.source_catalog:type_name -> bytebase.v1.DatabaseCatalog- 43, // 24: bytebase.v1.DiffMetadataRequest.target_catalog:type_name -> bytebase.v1.DatabaseCatalog- 41, // 25: bytebase.v1.DiffMetadataRequest.engine:type_name -> bytebase.v1.Engine- 25, // 26: bytebase.v1.SearchQueryHistoriesResponse.query_histories:type_name -> bytebase.v1.QueryHistory- 44, // 27: bytebase.v1.QueryHistory.create_time:type_name -> google.protobuf.Timestamp- 36, // 28: bytebase.v1.QueryHistory.duration:type_name -> google.protobuf.Duration- 4, // 29: bytebase.v1.QueryHistory.type:type_name -> bytebase.v1.QueryHistory.Type- 32, // 30: bytebase.v1.AICompletionRequest.messages:type_name -> bytebase.v1.AICompletionRequest.Message- 33, // 31: bytebase.v1.AICompletionResponse.candidates:type_name -> bytebase.v1.AICompletionResponse.Candidate- 1, // 32: bytebase.v1.QueryResult.Message.level:type_name -> bytebase.v1.QueryResult.Message.Level- 44, // 33: bytebase.v1.RowValue.Timestamp.google_timestamp:type_name -> google.protobuf.Timestamp- 44, // 34: bytebase.v1.RowValue.TimestampTZ.google_timestamp:type_name -> google.protobuf.Timestamp- 34, // 35: bytebase.v1.AICompletionResponse.Candidate.content:type_name -> bytebase.v1.AICompletionResponse.Candidate.Content- 35, // 36: bytebase.v1.AICompletionResponse.Candidate.Content.parts:type_name -> bytebase.v1.AICompletionResponse.Candidate.Content.Part- 7, // 37: bytebase.v1.SQLService.Query:input_type -> bytebase.v1.QueryRequest- 5, // 38: bytebase.v1.SQLService.AdminExecute:input_type -> bytebase.v1.AdminExecuteRequest- 23, // 39: bytebase.v1.SQLService.SearchQueryHistories:input_type -> bytebase.v1.SearchQueryHistoriesRequest- 15, // 40: bytebase.v1.SQLService.Export:input_type -> bytebase.v1.ExportRequest- 19, // 41: bytebase.v1.SQLService.Check:input_type -> bytebase.v1.CheckRequest- 17, // 42: bytebase.v1.SQLService.Pretty:input_type -> bytebase.v1.PrettyRequest- 21, // 43: bytebase.v1.SQLService.DiffMetadata:input_type -> bytebase.v1.DiffMetadataRequest- 26, // 44: bytebase.v1.SQLService.AICompletion:input_type -> bytebase.v1.AICompletionRequest- 8, // 45: bytebase.v1.SQLService.Query:output_type -> bytebase.v1.QueryResponse- 6, // 46: bytebase.v1.SQLService.AdminExecute:output_type -> bytebase.v1.AdminExecuteResponse- 24, // 47: bytebase.v1.SQLService.SearchQueryHistories:output_type -> bytebase.v1.SearchQueryHistoriesResponse- 16, // 48: bytebase.v1.SQLService.Export:output_type -> bytebase.v1.ExportResponse- 20, // 49: bytebase.v1.SQLService.Check:output_type -> bytebase.v1.CheckResponse- 18, // 50: bytebase.v1.SQLService.Pretty:output_type -> bytebase.v1.PrettyResponse- 22, // 51: bytebase.v1.SQLService.DiffMetadata:output_type -> bytebase.v1.DiffMetadataResponse- 27, // 52: bytebase.v1.SQLService.AICompletion:output_type -> bytebase.v1.AICompletionResponse- 45, // [45:53] is the sub-list for method output_type- 37, // [37:45] is the sub-list for method input_type- 37, // [37:37] is the sub-list for extension type_name- 37, // [37:37] is the sub-list for extension extendee- 0, // [0:37] is the sub-list for field type_name+ 37, // 15: bytebase.v1.Advice.start_position:type_name -> bytebase.v1.Position+ 37, // 16: bytebase.v1.Advice.end_position:type_name -> bytebase.v1.Position+ 38, // 17: bytebase.v1.ExportRequest.format:type_name -> bytebase.v1.ExportFormat+ 3, // 18: bytebase.v1.CheckRequest.change_type:type_name -> bytebase.v1.CheckRequest.ChangeType+ 14, // 19: bytebase.v1.CheckResponse.advices:type_name -> bytebase.v1.Advice+ 39, // 20: bytebase.v1.DiffMetadataRequest.source_metadata:type_name -> bytebase.v1.DatabaseMetadata+ 39, // 21: bytebase.v1.DiffMetadataRequest.target_metadata:type_name -> bytebase.v1.DatabaseMetadata+ 40, // 22: bytebase.v1.DiffMetadataRequest.source_catalog:type_name -> bytebase.v1.DatabaseCatalog+ 40, // 23: bytebase.v1.DiffMetadataRequest.target_catalog:type_name -> bytebase.v1.DatabaseCatalog+ 41, // 24: bytebase.v1.DiffMetadataRequest.engine:type_name -> bytebase.v1.Engine+ 23, // 25: bytebase.v1.SearchQueryHistoriesResponse.query_histories:type_name -> bytebase.v1.QueryHistory+ 42, // 26: bytebase.v1.QueryHistory.create_time:type_name -> google.protobuf.Timestamp+ 34, // 27: bytebase.v1.QueryHistory.duration:type_name -> google.protobuf.Duration+ 4, // 28: bytebase.v1.QueryHistory.type:type_name -> bytebase.v1.QueryHistory.Type+ 30, // 29: bytebase.v1.AICompletionRequest.messages:type_name -> bytebase.v1.AICompletionRequest.Message+ 31, // 30: bytebase.v1.AICompletionResponse.candidates:type_name -> bytebase.v1.AICompletionResponse.Candidate+ 1, // 31: bytebase.v1.QueryResult.Message.level:type_name -> bytebase.v1.QueryResult.Message.Level+ 42, // 32: bytebase.v1.RowValue.Timestamp.google_timestamp:type_name -> google.protobuf.Timestamp+ 42, // 33: bytebase.v1.RowValue.TimestampTZ.google_timestamp:type_name -> google.protobuf.Timestamp+ 32, // 34: bytebase.v1.AICompletionResponse.Candidate.content:type_name -> bytebase.v1.AICompletionResponse.Candidate.Content+ 33, // 35: bytebase.v1.AICompletionResponse.Candidate.Content.parts:type_name -> bytebase.v1.AICompletionResponse.Candidate.Content.Part+ 7, // 36: bytebase.v1.SQLService.Query:input_type -> bytebase.v1.QueryRequest+ 5, // 37: bytebase.v1.SQLService.AdminExecute:input_type -> bytebase.v1.AdminExecuteRequest+ 21, // 38: bytebase.v1.SQLService.SearchQueryHistories:input_type -> bytebase.v1.SearchQueryHistoriesRequest+ 15, // 39: bytebase.v1.SQLService.Export:input_type -> bytebase.v1.ExportRequest+ 17, // 40: bytebase.v1.SQLService.Check:input_type -> bytebase.v1.CheckRequest+ 19, // 41: bytebase.v1.SQLService.DiffMetadata:input_type -> bytebase.v1.DiffMetadataRequest+ 24, // 42: bytebase.v1.SQLService.AICompletion:input_type -> bytebase.v1.AICompletionRequest+ 8, // 43: bytebase.v1.SQLService.Query:output_type -> bytebase.v1.QueryResponse+ 6, // 44: bytebase.v1.SQLService.AdminExecute:output_type -> bytebase.v1.AdminExecuteResponse+ 22, // 45: bytebase.v1.SQLService.SearchQueryHistories:output_type -> bytebase.v1.SearchQueryHistoriesResponse+ 16, // 46: bytebase.v1.SQLService.Export:output_type -> bytebase.v1.ExportResponse+ 18, // 47: bytebase.v1.SQLService.Check:output_type -> bytebase.v1.CheckResponse+ 20, // 48: bytebase.v1.SQLService.DiffMetadata:output_type -> bytebase.v1.DiffMetadataResponse+ 25, // 49: bytebase.v1.SQLService.AICompletion:output_type -> bytebase.v1.AICompletionResponse+ 43, // [43:50] is the sub-list for method output_type+ 36, // [36:43] is the sub-list for method input_type+ 36, // [36:36] is the sub-list for extension type_name+ 36, // [36:36] is the sub-list for extension extendee+ 0, // [0:36] is the sub-list for field type_name}func init() { file_v1_sql_service_proto_init() }@@ -3088,14 +2956,14 @@ func file_v1_sql_service_proto_init() {(*RowValue_TimestampTzValue)(nil),}file_v1_sql_service_proto_msgTypes[10].OneofWrappers = []any{}- file_v1_sql_service_proto_msgTypes[20].OneofWrappers = []any{}+ file_v1_sql_service_proto_msgTypes[18].OneofWrappers = []any{}type x struct{}out := protoimpl.TypeBuilder{File: protoimpl.DescBuilder{GoPackagePath: reflect.TypeOf(x{}).PkgPath(),RawDescriptor: unsafe.Slice(unsafe.StringData(file_v1_sql_service_proto_rawDesc), len(file_v1_sql_service_proto_rawDesc)),NumEnums: 5,- NumMessages: 31,+ NumMessages: 29,NumExtensions: 0,NumServices: 1,},diff --git a/backend/generated-go/v1/sql_service.pb.gw.go b/backend/generated-go/v1/sql_service.pb.gw.goindex 3e5d1d1b78..678d72b237 100644--- a/backend/generated-go/v1/sql_service.pb.gw.go+++ b/backend/generated-go/v1/sql_service.pb.gw.go@@ -312,33 +312,6 @@ func local_request_SQLService_Check_0(ctx context.Context, marshaler runtime.Marreturn msg, metadata, err}-func request_SQLService_Pretty_0(ctx context.Context, marshaler runtime.Marshaler, client SQLServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {- var (- protoReq PrettyRequest- metadata runtime.ServerMetadata- )- if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {- return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)- }- if req.Body != nil {- _, _ = io.Copy(io.Discard, req.Body)- }- msg, err := client.Pretty(ctx, &protoReq, grpc.Header(&metadata.HeaderMD), grpc.Trailer(&metadata.TrailerMD))- return msg, metadata, err-}--func local_request_SQLService_Pretty_0(ctx context.Context, marshaler runtime.Marshaler, server SQLServiceServer, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {- var (- protoReq PrettyRequest- metadata runtime.ServerMetadata- )- if err := marshaler.NewDecoder(req.Body).Decode(&protoReq); err != nil && !errors.Is(err, io.EOF) {- return nil, metadata, status.Errorf(codes.InvalidArgument, "%v", err)- }- msg, err := server.Pretty(ctx, &protoReq)- return msg, metadata, err-}-func request_SQLService_DiffMetadata_0(ctx context.Context, marshaler runtime.Marshaler, client SQLServiceClient, req *http.Request, pathParams map[string]string) (proto.Message, runtime.ServerMetadata, error) {var (protoReq DiffMetadataRequest@@ -526,26 +499,6 @@ func RegisterSQLServiceHandlerServer(ctx context.Context, mux *runtime.ServeMux,}forward_SQLService_Check_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)})- mux.Handle(http.MethodPost, pattern_SQLService_Pretty_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {- ctx, cancel := context.WithCancel(req.Context())- defer cancel()- var stream runtime.ServerTransportStream- ctx = grpc.NewContextWithServerTransportStream(ctx, &stream)- inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)- annotatedContext, err := runtime.AnnotateIncomingContext(ctx, mux, req, "/bytebase.v1.SQLService/Pretty", runtime.WithHTTPPathPattern("/v1/sql/pretty"))- if err != nil {- runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)- return- }- resp, md, err := local_request_SQLService_Pretty_0(annotatedContext, inboundMarshaler, server, req, pathParams)- md.HeaderMD, md.TrailerMD = metadata.Join(md.HeaderMD, stream.Header()), metadata.Join(md.TrailerMD, stream.Trailer())- annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)- if err != nil {- runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)- return- }- forward_SQLService_Pretty_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)- })mux.Handle(http.MethodPost, pattern_SQLService_DiffMetadata_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {ctx, cancel := context.WithCancel(req.Context())defer cancel()@@ -745,23 +698,6 @@ func RegisterSQLServiceHandlerClient(ctx context.Context, mux *runtime.ServeMux,}forward_SQLService_Check_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)})- mux.Handle(http.MethodPost, pattern_SQLService_Pretty_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {- ctx, cancel := context.WithCancel(req.Context())- defer cancel()- inboundMarshaler, outboundMarshaler := runtime.MarshalerForRequest(mux, req)- annotatedContext, err := runtime.AnnotateContext(ctx, mux, req, "/bytebase.v1.SQLService/Pretty", runtime.WithHTTPPathPattern("/v1/sql/pretty"))- if err != nil {- runtime.HTTPError(ctx, mux, outboundMarshaler, w, req, err)- return- }- resp, md, err := request_SQLService_Pretty_0(annotatedContext, inboundMarshaler, client, req, pathParams)- annotatedContext = runtime.NewServerMetadataContext(annotatedContext, md)- if err != nil {- runtime.HTTPError(annotatedContext, mux, outboundMarshaler, w, req, err)- return- }- forward_SQLService_Pretty_0(annotatedContext, mux, outboundMarshaler, w, req, resp, mux.GetForwardResponseOptions()...)- })mux.Handle(http.MethodPost, pattern_SQLService_DiffMetadata_0, func(w http.ResponseWriter, req *http.Request, pathParams map[string]string) {ctx, cancel := context.WithCancel(req.Context())defer cancel()@@ -807,7 +743,6 @@ var (pattern_SQLService_Export_1 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 2, 2, 1, 0, 4, 4, 5, 3}, []string{"v1", "projects", "rollouts", "name"}, "export"))pattern_SQLService_Export_2 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 1, 0, 2, 2, 1, 0, 2, 3, 1, 0, 4, 6, 5, 4}, []string{"v1", "projects", "rollouts", "stages", "name"}, "export"))pattern_SQLService_Check_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "sql", "check"}, ""))- pattern_SQLService_Pretty_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "sql", "pretty"}, ""))pattern_SQLService_DiffMetadata_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1}, []string{"v1", "schemaDesign"}, "diffMetadata"))pattern_SQLService_AICompletion_0 = runtime.MustPattern(runtime.NewPattern(1, []int{2, 0, 2, 1, 2, 2}, []string{"v1", "sql", "aiCompletion"}, "")))@@ -820,7 +755,6 @@ var (forward_SQLService_Export_1 = runtime.ForwardResponseMessageforward_SQLService_Export_2 = runtime.ForwardResponseMessageforward_SQLService_Check_0 = runtime.ForwardResponseMessage- forward_SQLService_Pretty_0 = runtime.ForwardResponseMessageforward_SQLService_DiffMetadata_0 = runtime.ForwardResponseMessageforward_SQLService_AICompletion_0 = runtime.ForwardResponseMessage)diff --git a/backend/generated-go/v1/sql_service_equal.pb.go b/backend/generated-go/v1/sql_service_equal.pb.goindex 734c168d8e..59a2dd45bb 100644--- a/backend/generated-go/v1/sql_service_equal.pb.go+++ b/backend/generated-go/v1/sql_service_equal.pb.go@@ -475,41 +475,6 @@ func (x *ExportResponse) Equal(y *ExportResponse) bool {return true}-func (x *PrettyRequest) Equal(y *PrettyRequest) bool {- if x == y {- return true- }- if x == nil || y == nil {- return x == nil && y == nil- }- if x.Engine != y.Engine {- return false- }- if x.CurrentSchema != y.CurrentSchema {- return false- }- if x.ExpectedSchema != y.ExpectedSchema {- return false- }- return true-}--func (x *PrettyResponse) Equal(y *PrettyResponse) bool {- if x == y {- return true- }- if x == nil || y == nil {- return x == nil && y == nil- }- if x.CurrentSchema != y.CurrentSchema {- return false- }- if x.ExpectedSchema != y.ExpectedSchema {- return false- }- return true-}-func (x *CheckRequest) Equal(y *CheckRequest) bool {if x == y {return truediff --git a/backend/generated-go/v1/sql_service_grpc.pb.go b/backend/generated-go/v1/sql_service_grpc.pb.goindex ba612530c9..ed616d6b43 100644--- a/backend/generated-go/v1/sql_service_grpc.pb.go+++ b/backend/generated-go/v1/sql_service_grpc.pb.go@@ -24,7 +24,6 @@ const (SQLService_SearchQueryHistories_FullMethodName = "/bytebase.v1.SQLService/SearchQueryHistories"SQLService_Export_FullMethodName = "/bytebase.v1.SQLService/Export"SQLService_Check_FullMethodName = "/bytebase.v1.SQLService/Check"- SQLService_Pretty_FullMethodName = "/bytebase.v1.SQLService/Pretty"SQLService_DiffMetadata_FullMethodName = "/bytebase.v1.SQLService/DiffMetadata"SQLService_AICompletion_FullMethodName = "/bytebase.v1.SQLService/AICompletion")@@ -50,9 +49,6 @@ type SQLServiceClient interface {// Validates SQL statements against review rules.// Permissions required: bb.databases.checkCheck(ctx context.Context, in *CheckRequest, opts ...grpc.CallOption) (*CheckResponse, error)- // Formats and normalizes SQL schema definitions.- // Permissions required: None- Pretty(ctx context.Context, in *PrettyRequest, opts ...grpc.CallOption) (*PrettyResponse, error)// Computes schema differences between two database metadata.// Permissions required: NoneDiffMetadata(ctx context.Context, in *DiffMetadataRequest, opts ...grpc.CallOption) (*DiffMetadataResponse, error)@@ -122,16 +118,6 @@ func (c *sQLServiceClient) Check(ctx context.Context, in *CheckRequest, opts ...return out, nil}-func (c *sQLServiceClient) Pretty(ctx context.Context, in *PrettyRequest, opts ...grpc.CallOption) (*PrettyResponse, error) {- cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)- out := new(PrettyResponse)- err := c.cc.Invoke(ctx, SQLService_Pretty_FullMethodName, in, out, cOpts...)- if err != nil {- return nil, err- }- return out, nil-}-func (c *sQLServiceClient) DiffMetadata(ctx context.Context, in *DiffMetadataRequest, opts ...grpc.CallOption) (*DiffMetadataResponse, error) {cOpts := append([]grpc.CallOption{grpc.StaticMethod()}, opts...)out := new(DiffMetadataResponse)@@ -173,9 +159,6 @@ type SQLServiceServer interface {// Validates SQL statements against review rules.// Permissions required: bb.databases.checkCheck(context.Context, *CheckRequest) (*CheckResponse, error)- // Formats and normalizes SQL schema definitions.- // Permissions required: None- Pretty(context.Context, *PrettyRequest) (*PrettyResponse, error)// Computes schema differences between two database metadata.// Permissions required: NoneDiffMetadata(context.Context, *DiffMetadataRequest) (*DiffMetadataResponse, error)@@ -207,9 +190,6 @@ func (UnimplementedSQLServiceServer) Export(context.Context, *ExportRequest) (*Efunc (UnimplementedSQLServiceServer) Check(context.Context, *CheckRequest) (*CheckResponse, error) {return nil, status.Errorf(codes.Unimplemented, "method Check not implemented")}-func (UnimplementedSQLServiceServer) Pretty(context.Context, *PrettyRequest) (*PrettyResponse, error) {- return nil, status.Errorf(codes.Unimplemented, "method Pretty not implemented")-}func (UnimplementedSQLServiceServer) DiffMetadata(context.Context, *DiffMetadataRequest) (*DiffMetadataResponse, error) {return nil, status.Errorf(codes.Unimplemented, "method DiffMetadata not implemented")}@@ -316,24 +296,6 @@ func _SQLService_Check_Handler(srv interface{}, ctx context.Context, dec func(inreturn interceptor(ctx, in, info, handler)}-func _SQLService_Pretty_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {- in := new(PrettyRequest)- if err := dec(in); err != nil {- return nil, err- }- if interceptor == nil {- return srv.(SQLServiceServer).Pretty(ctx, in)- }- info := &grpc.UnaryServerInfo{- Server: srv,- FullMethod: SQLService_Pretty_FullMethodName,- }- handler := func(ctx context.Context, req interface{}) (interface{}, error) {- return srv.(SQLServiceServer).Pretty(ctx, req.(*PrettyRequest))- }- return interceptor(ctx, in, info, handler)-}-func _SQLService_DiffMetadata_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {in := new(DiffMetadataRequest)if err := dec(in); err != nil {@@ -393,10 +355,6 @@ var SQLService_ServiceDesc = grpc.ServiceDesc{MethodName: "Check",Handler: _SQLService_Check_Handler,},- {- MethodName: "Pretty",- Handler: _SQLService_Pretty_Handler,- },{MethodName: "DiffMetadata",Handler: _SQLService_DiffMetadata_Handler,diff --git a/backend/generated-go/v1/v1connect/sql_service.connect.go b/backend/generated-go/v1/v1connect/sql_service.connect.goindex f2027d11e3..8f9978bd62 100644--- a/backend/generated-go/v1/v1connect/sql_service.connect.go+++ b/backend/generated-go/v1/v1connect/sql_service.connect.go@@ -44,8 +44,6 @@ const (SQLServiceExportProcedure = "/bytebase.v1.SQLService/Export"// SQLServiceCheckProcedure is the fully-qualified name of the SQLService's Check RPC.SQLServiceCheckProcedure = "/bytebase.v1.SQLService/Check"- // SQLServicePrettyProcedure is the fully-qualified name of the SQLService's Pretty RPC.- SQLServicePrettyProcedure = "/bytebase.v1.SQLService/Pretty"// SQLServiceDiffMetadataProcedure is the fully-qualified name of the SQLService's DiffMetadata RPC.SQLServiceDiffMetadataProcedure = "/bytebase.v1.SQLService/DiffMetadata"// SQLServiceAICompletionProcedure is the fully-qualified name of the SQLService's AICompletion RPC.@@ -69,9 +67,6 @@ type SQLServiceClient interface {// Validates SQL statements against review rules.// Permissions required: bb.databases.checkCheck(context.Context, *connect.Request[v1.CheckRequest]) (*connect.Response[v1.CheckResponse], error)- // Formats and normalizes SQL schema definitions.- // Permissions required: None- Pretty(context.Context, *connect.Request[v1.PrettyRequest]) (*connect.Response[v1.PrettyResponse], error)// Computes schema differences between two database metadata.// Permissions required: NoneDiffMetadata(context.Context, *connect.Request[v1.DiffMetadataRequest]) (*connect.Response[v1.DiffMetadataResponse], error)@@ -121,12 +116,6 @@ func NewSQLServiceClient(httpClient connect.HTTPClient, baseURL string, opts ...connect.WithSchema(sQLServiceMethods.ByName("Check")),connect.WithClientOptions(opts...),),- pretty: connect.NewClient[v1.PrettyRequest, v1.PrettyResponse](- httpClient,- baseURL+SQLServicePrettyProcedure,- connect.WithSchema(sQLServiceMethods.ByName("Pretty")),- connect.WithClientOptions(opts...),- ),diffMetadata: connect.NewClient[v1.DiffMetadataRequest, v1.DiffMetadataResponse](httpClient,baseURL+SQLServiceDiffMetadataProcedure,@@ -149,7 +138,6 @@ type sQLServiceClient struct {searchQueryHistories *connect.Client[v1.SearchQueryHistoriesRequest, v1.SearchQueryHistoriesResponse]export *connect.Client[v1.ExportRequest, v1.ExportResponse]check *connect.Client[v1.CheckRequest, v1.CheckResponse]- pretty *connect.Client[v1.PrettyRequest, v1.PrettyResponse]diffMetadata *connect.Client[v1.DiffMetadataRequest, v1.DiffMetadataResponse]aICompletion *connect.Client[v1.AICompletionRequest, v1.AICompletionResponse]}@@ -179,11 +167,6 @@ func (c *sQLServiceClient) Check(ctx context.Context, req *connect.Request[v1.Chreturn c.check.CallUnary(ctx, req)}-// Pretty calls bytebase.v1.SQLService.Pretty.-func (c *sQLServiceClient) Pretty(ctx context.Context, req *connect.Request[v1.PrettyRequest]) (*connect.Response[v1.PrettyResponse], error) {- return c.pretty.CallUnary(ctx, req)-}-// DiffMetadata calls bytebase.v1.SQLService.DiffMetadata.func (c *sQLServiceClient) DiffMetadata(ctx context.Context, req *connect.Request[v1.DiffMetadataRequest]) (*connect.Response[v1.DiffMetadataResponse], error) {return c.diffMetadata.CallUnary(ctx, req)@@ -211,9 +194,6 @@ type SQLServiceHandler interface {// Validates SQL statements against review rules.// Permissions required: bb.databases.checkCheck(context.Context, *connect.Request[v1.CheckRequest]) (*connect.Response[v1.CheckResponse], error)- // Formats and normalizes SQL schema definitions.- // Permissions required: None- Pretty(context.Context, *connect.Request[v1.PrettyRequest]) (*connect.Response[v1.PrettyResponse], error)// Computes schema differences between two database metadata.// Permissions required: NoneDiffMetadata(context.Context, *connect.Request[v1.DiffMetadataRequest]) (*connect.Response[v1.DiffMetadataResponse], error)@@ -259,12 +239,6 @@ func NewSQLServiceHandler(svc SQLServiceHandler, opts ...connect.HandlerOption)connect.WithSchema(sQLServiceMethods.ByName("Check")),connect.WithHandlerOptions(opts...),)- sQLServicePrettyHandler := connect.NewUnaryHandler(- SQLServicePrettyProcedure,- svc.Pretty,- connect.WithSchema(sQLServiceMethods.ByName("Pretty")),- connect.WithHandlerOptions(opts...),- )sQLServiceDiffMetadataHandler := connect.NewUnaryHandler(SQLServiceDiffMetadataProcedure,svc.DiffMetadata,@@ -289,8 +263,6 @@ func NewSQLServiceHandler(svc SQLServiceHandler, opts ...connect.HandlerOption)sQLServiceExportHandler.ServeHTTP(w, r)case SQLServiceCheckProcedure:sQLServiceCheckHandler.ServeHTTP(w, r)- case SQLServicePrettyProcedure:- sQLServicePrettyHandler.ServeHTTP(w, r)case SQLServiceDiffMetadataProcedure:sQLServiceDiffMetadataHandler.ServeHTTP(w, r)case SQLServiceAICompletionProcedure:@@ -324,10 +296,6 @@ func (UnimplementedSQLServiceHandler) Check(context.Context, *connect.Request[v1return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bytebase.v1.SQLService.Check is not implemented"))}-func (UnimplementedSQLServiceHandler) Pretty(context.Context, *connect.Request[v1.PrettyRequest]) (*connect.Response[v1.PrettyResponse], error) {- return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bytebase.v1.SQLService.Pretty is not implemented"))-}-func (UnimplementedSQLServiceHandler) DiffMetadata(context.Context, *connect.Request[v1.DiffMetadataRequest]) (*connect.Response[v1.DiffMetadataResponse], error) {return nil, connect.NewError(connect.CodeUnimplemented, errors.New("bytebase.v1.SQLService.DiffMetadata is not implemented"))}diff --git a/backend/plugin/advisor/mysql/rule_builtin_prior_backup_check.go b/backend/plugin/advisor/mysql/rule_builtin_prior_backup_check.goindex 4844b333cd..b6ca49e484 100644--- a/backend/plugin/advisor/mysql/rule_builtin_prior_backup_check.go+++ b/backend/plugin/advisor/mysql/rule_builtin_prior_backup_check.go@@ -47,7 +47,7 @@ func (*StatementPriorBackupCheckAdvisor) Check(ctx context.Context, checkCtx advTitle: title,Content: fmt.Sprintf("The size of the SQL statements exceeds the maximum limit of %d bytes for backup", common.MaxSheetCheckSize),Code: advisor.BuiltinPriorBackupCheck.Int32(),- StartPosition: common.FirstLinePosition,+ StartPosition: nil,})}@@ -73,7 +73,7 @@ func (*StatementPriorBackupCheckAdvisor) Check(ctx context.Context, checkCtx advTitle: title,Content: fmt.Sprintf("Need database %q to do prior backup but it does not exist", databaseName),Code: advisor.DatabaseNotExists.Int32(),- StartPosition: common.FirstLinePosition,+ StartPosition: nil,})}@@ -99,7 +99,7 @@ func (*StatementPriorBackupCheckAdvisor) Check(ctx context.Context, checkCtx advTitle: title,Content: fmt.Sprintf("Prior backup cannot handle mixed DML statements on the same table %q", key),Code: advisor.BuiltinPriorBackupCheck.Int32(),- StartPosition: common.FirstLinePosition,+ StartPosition: nil,})break}diff --git a/backend/plugin/advisor/mysql/rule_online_migration.go b/backend/plugin/advisor/mysql/rule_online_migration.goindex ba9d00ab0e..7c5ae02736 100644--- a/backend/plugin/advisor/mysql/rule_online_migration.go+++ b/backend/plugin/advisor/mysql/rule_online_migration.go@@ -62,7 +62,7 @@ func (*OnlineMigrationAdvisor) Check(ctx context.Context, checkCtx advisor.ConteTitle: title,Content: fmt.Sprintf("Needs database %q to save temporary data for online migration but it does not exist", ghostDatabaseName),Code: advisor.DatabaseNotExists.Int32(),- StartPosition: common.FirstLinePosition,+ StartPosition: nil,},}, nil}diff --git a/backend/plugin/advisor/oracle/rule_builtin_prior_backup_check.go b/backend/plugin/advisor/oracle/rule_builtin_prior_backup_check.goindex 016156c1ea..ebae5f6b1c 100644--- a/backend/plugin/advisor/oracle/rule_builtin_prior_backup_check.go+++ b/backend/plugin/advisor/oracle/rule_builtin_prior_backup_check.go@@ -241,7 +241,7 @@ func (r *StatementPriorBackupCheckRule) handleSQLScriptExit() {Title: r.title,Content: fmt.Sprintf("The size of the SQL statements exceeds the maximum limit of %d bytes for backup", common.MaxSheetCheckSize),Code: advisor.BuiltinPriorBackupCheck.Int32(),- StartPosition: common.FirstLinePosition,+ StartPosition: nil,})}@@ -252,7 +252,7 @@ func (r *StatementPriorBackupCheckRule) handleSQLScriptExit() {Title: r.title,Content: fmt.Sprintf("Need database %q to do prior backup but it does not exist", databaseName),Code: advisor.DatabaseNotExists.Int32(),- StartPosition: common.FirstLinePosition,+ StartPosition: nil,})r.adviceList = append(r.adviceList, adviceList...)return@@ -264,7 +264,7 @@ func (r *StatementPriorBackupCheckRule) handleSQLScriptExit() {Title: r.title,Content: "Prior backup cannot deal with mixed DDL and DML statements",Code: int32(advisor.BuiltinPriorBackupCheck),- StartPosition: common.FirstLinePosition,+ StartPosition: nil,})}@@ -292,7 +292,7 @@ func (r *StatementPriorBackupCheckRule) handleSQLScriptExit() {Title: r.title,Content: fmt.Sprintf("Prior backup cannot handle mixed DML statements on the same table %q", key),Code: advisor.BuiltinPriorBackupCheck.Int32(),- StartPosition: common.FirstLinePosition,+ StartPosition: nil,})break}diff --git a/backend/plugin/advisor/pg/advisor_builtin_prior_backup_check.go b/backend/plugin/advisor/pg/advisor_builtin_prior_backup_check.goindex f68b27d356..6478d3a528 100644--- a/backend/plugin/advisor/pg/advisor_builtin_prior_backup_check.go+++ b/backend/plugin/advisor/pg/advisor_builtin_prior_backup_check.go@@ -60,7 +60,7 @@ func (*BuiltinPriorBackupCheckAdvisor) Check(_ context.Context, checkCtx advisorTitle: title,Content: fmt.Sprintf("Data change can only run DML, \"%s\" is not DML", stmt.Text()),Code: advisor.BuiltinPriorBackupCheck.Int32(),- StartPosition: common.ConvertPGParserLineToPosition(stmt.LastLine()),+ StartPosition: newPositionAtLineStart(stmt.LastLine()),})}}@@ -72,7 +72,7 @@ func (*BuiltinPriorBackupCheckAdvisor) Check(_ context.Context, checkCtx advisorTitle: title,Content: fmt.Sprintf("Need schema %q to do prior backup but it does not exist", schemaName),Code: advisor.SchemaNotExists.Int32(),- StartPosition: common.FirstLinePosition,+ StartPosition: nil,})}@@ -100,7 +100,7 @@ func (*BuiltinPriorBackupCheckAdvisor) Check(_ context.Context, checkCtx advisorTitle: title,Content: fmt.Sprintf("The statement type is not the same for all statements on the same table %q", key),Code: advisor.BuiltinPriorBackupCheck.Int32(),- StartPosition: common.FirstLinePosition,+ StartPosition: nil,})break}diff --git a/backend/plugin/advisor/pg/advisor_collation_allowlist.go b/backend/plugin/advisor/pg/advisor_collation_allowlist.goindex 4de54daa08..d9d86ba002 100644--- a/backend/plugin/advisor/pg/advisor_collation_allowlist.go+++ b/backend/plugin/advisor/pg/advisor_collation_allowlist.go@@ -8,7 +8,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/ast"@@ -121,7 +120,7 @@ func (checker *collationAllowlistChecker) Visit(in ast.Node) ast.Visitor {Code: code.Int32(),Title: checker.title,Content: fmt.Sprintf("Use disabled collation \"%s\", related statement \"%s\"", disabledCollation, checker.text),- StartPosition: common.ConvertPGParserLineToPosition(line),+ StartPosition: newPositionAtLineStart(line),})}diff --git a/backend/plugin/advisor/pg/advisor_column_comment_convention.go b/backend/plugin/advisor/pg/advisor_column_comment_convention.goindex 0652ffbcff..73fd336f3a 100644--- a/backend/plugin/advisor/pg/advisor_column_comment_convention.go+++ b/backend/plugin/advisor/pg/advisor_column_comment_convention.go@@ -69,7 +69,7 @@ func (*ColumnCommentConventionAdvisor) Check(_ context.Context, checkCtx advisorCode: advisor.CommentEmpty.Int32(),Title: checker.title,Content: fmt.Sprintf("Comment is required for column `%s`", stringifyColumnNameDef(columnName)),- StartPosition: common.ConvertPGParserLineToPosition(columnName.LastLine()),+ StartPosition: newPositionAtLineStart(columnName.LastLine()),})}} else {@@ -80,7 +80,7 @@ func (*ColumnCommentConventionAdvisor) Check(_ context.Context, checkCtx advisorCode: advisor.CommentTooLong.Int32(),Title: checker.title,Content: fmt.Sprintf("Column `%s` comment is too long. The length of comment should be within %d characters", stringifyColumnNameDef(columnName), checker.payload.MaxLength),- StartPosition: common.ConvertPGParserLineToPosition(commentStmt.LastLine()),+ StartPosition: newPositionAtLineStart(commentStmt.LastLine()),})}if checker.payload.RequiredClassification {@@ -90,7 +90,7 @@ func (*ColumnCommentConventionAdvisor) Check(_ context.Context, checkCtx advisorCode: advisor.CommentMissingClassification.Int32(),Title: checker.title,Content: fmt.Sprintf("Column `%s` comment requires classification", stringifyColumnNameDef(columnName)),- StartPosition: common.ConvertPGParserLineToPosition(commentStmt.LastLine()),+ StartPosition: newPositionAtLineStart(commentStmt.LastLine()),})}}diff --git a/backend/plugin/advisor/pg/advisor_column_default_disallow_volatile.go b/backend/plugin/advisor/pg/advisor_column_default_disallow_volatile.goindex 6677233a38..2c58c97611 100644--- a/backend/plugin/advisor/pg/advisor_column_default_disallow_volatile.go+++ b/backend/plugin/advisor/pg/advisor_column_default_disallow_volatile.go@@ -9,7 +9,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/catalog"@@ -85,7 +84,7 @@ func (checker *columnDefaultDisallowVolatileChecker) generateAdvice() []*storepbCode: advisor.NoDefault.Int32(),Title: checker.title,Content: fmt.Sprintf("Column %q.%q in schema %q has volatile DEFAULT", column.table, column.name, column.schema),- StartPosition: common.ConvertPGParserLineToPosition(column.line),+ StartPosition: newPositionAtLineStart(column.line),})}diff --git a/backend/plugin/advisor/pg/advisor_column_disallow_changing_type.go b/backend/plugin/advisor/pg/advisor_column_disallow_changing_type.goindex 9cb86b39a6..805f614bdc 100644--- a/backend/plugin/advisor/pg/advisor_column_disallow_changing_type.go+++ b/backend/plugin/advisor/pg/advisor_column_disallow_changing_type.go@@ -8,7 +8,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/ast"@@ -73,7 +72,7 @@ func (checker *columnDisallowChangingTypeChecker) Visit(in ast.Node) ast.VisitorCode: code.Int32(),Title: checker.title,Content: fmt.Sprintf("The statement \"%s\" changes column type", checker.text),- StartPosition: common.ConvertPGParserLineToPosition(checker.line),+ StartPosition: newPositionAtLineStart(checker.line),})}diff --git a/backend/plugin/advisor/pg/advisor_column_maximum_character_length.go b/backend/plugin/advisor/pg/advisor_column_maximum_character_length.goindex cbb9d962c1..8e5fa090ce 100644--- a/backend/plugin/advisor/pg/advisor_column_maximum_character_length.go+++ b/backend/plugin/advisor/pg/advisor_column_maximum_character_length.go@@ -8,7 +8,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/ast"@@ -112,7 +111,7 @@ func (checker *columnMaximumCharacterLengthChecker) Visit(in ast.Node) ast.VisitCode: advisor.CharLengthExceedsLimit.Int32(),Title: checker.title,Content: fmt.Sprintf(`The length of the CHAR column %q in table %s is bigger than %d, please use VARCHAR instead`, columnName, tableName, checker.maximum),- StartPosition: common.ConvertPGParserLineToPosition(line),+ StartPosition: newPositionAtLineStart(line),})}diff --git a/backend/plugin/advisor/pg/advisor_column_no_null.go b/backend/plugin/advisor/pg/advisor_column_no_null.goindex d0990a7532..a68fa6f292 100644--- a/backend/plugin/advisor/pg/advisor_column_no_null.go+++ b/backend/plugin/advisor/pg/advisor_column_no_null.go@@ -7,7 +7,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/catalog"@@ -96,7 +95,7 @@ func (checker *columnNoNullChecker) generateAdviceList() []*storepb.Advice {Code: advisor.ColumnCannotNull.Int32(),Title: checker.title,Content: fmt.Sprintf(`Column "%s" in %s cannot have NULL value`, column.column, column.normalizeTableName()),- StartPosition: common.ConvertPGParserLineToPosition(checker.nullableColumns[column]),+ StartPosition: newPositionAtLineStart(checker.nullableColumns[column]),})}diff --git a/backend/plugin/advisor/pg/advisor_column_require_default.go b/backend/plugin/advisor/pg/advisor_column_require_default.goindex 538f36d553..a239057dda 100644--- a/backend/plugin/advisor/pg/advisor_column_require_default.go+++ b/backend/plugin/advisor/pg/advisor_column_require_default.go@@ -9,7 +9,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/catalog"@@ -98,7 +97,7 @@ func (checker *columnRequireDefaultChecker) generateAdvice() []*storepb.Advice {Code: advisor.NoDefault.Int32(),Title: checker.title,Content: fmt.Sprintf("Column %q.%q in schema %q doesn't have DEFAULT", column.table, column.name, column.schema),- StartPosition: common.ConvertPGParserLineToPosition(column.line),+ StartPosition: newPositionAtLineStart(column.line),})}}diff --git a/backend/plugin/advisor/pg/advisor_column_required.go b/backend/plugin/advisor/pg/advisor_column_required.goindex 9108976189..a471ff6d27 100644--- a/backend/plugin/advisor/pg/advisor_column_required.go+++ b/backend/plugin/advisor/pg/advisor_column_required.go@@ -8,7 +8,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/ast"@@ -107,7 +106,7 @@ func (checker *columnRequirementChecker) Visit(node ast.Node) ast.Visitor {Code: advisor.NoRequiredColumn.Int32(),Title: checker.title,Content: fmt.Sprintf("Table %q requires columns: %s", table.Name, strings.Join(missingColumns, ", ")),- StartPosition: common.ConvertPGParserLineToPosition(node.LastLine()),+ StartPosition: newPositionAtLineStart(node.LastLine()),})}diff --git a/backend/plugin/advisor/pg/advisor_column_type_disallow_list.go b/backend/plugin/advisor/pg/advisor_column_type_disallow_list.goindex f1c7e2b3f2..e9669104e2 100644--- a/backend/plugin/advisor/pg/advisor_column_type_disallow_list.go+++ b/backend/plugin/advisor/pg/advisor_column_type_disallow_list.go@@ -7,7 +7,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/ast"@@ -142,7 +141,7 @@ func (checker *columnTypeDisallowListChecker) Visit(in ast.Node) ast.Visitor {Code: advisor.DisabledColumnType.Int32(),Title: checker.title,Content: fmt.Sprintf("Disallow column type %s but column \"%s\".\"%s\" is", column.tp, column.table, column.column),- StartPosition: common.ConvertPGParserLineToPosition(column.line),+ StartPosition: newPositionAtLineStart(column.line),})}return checkerdiff --git a/backend/plugin/advisor/pg/advisor_comment_convention.go b/backend/plugin/advisor/pg/advisor_comment_convention.goindex 53d1d08cf8..4e2218ed75 100644--- a/backend/plugin/advisor/pg/advisor_comment_convention.go+++ b/backend/plugin/advisor/pg/advisor_comment_convention.go@@ -8,7 +8,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/ast"@@ -83,7 +82,7 @@ func (checker *commentConventionChecker) Visit(node ast.Node) ast.Visitor {Code: advisor.CommentTooLong.Int32(),Title: checker.title,Content: fmt.Sprintf("The length of comment should be within %d characters", checker.maxLength),- StartPosition: common.ConvertPGParserLineToPosition(comment.line),+ StartPosition: newPositionAtLineStart(comment.line),})}diff --git a/backend/plugin/advisor/pg/advisor_encoding_allowlist.go b/backend/plugin/advisor/pg/advisor_encoding_allowlist.goindex 668a0855b3..02da03d830 100644--- a/backend/plugin/advisor/pg/advisor_encoding_allowlist.go+++ b/backend/plugin/advisor/pg/advisor_encoding_allowlist.go@@ -7,7 +7,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/ast"@@ -90,7 +89,7 @@ func (checker *encodingAllowlistChecker) Visit(in ast.Node) ast.Visitor {Code: code.Int32(),Title: checker.title,Content: fmt.Sprintf("\"%s\" used disabled encoding '%s'", checker.text, disabledEncoding),- StartPosition: common.ConvertPGParserLineToPosition(line),+ StartPosition: newPositionAtLineStart(line),})}diff --git a/backend/plugin/advisor/pg/advisor_index_create_concurrently.go b/backend/plugin/advisor/pg/advisor_index_create_concurrently.goindex 0df7ebd37e..33a1b7b32b 100644--- a/backend/plugin/advisor/pg/advisor_index_create_concurrently.go+++ b/backend/plugin/advisor/pg/advisor_index_create_concurrently.go@@ -7,7 +7,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/ast"@@ -86,7 +85,7 @@ func (checker *indexCreateConcurrentlyChecker) Visit(in ast.Node) ast.Visitor {Code: advisor.CreateIndexUnconcurrently.Int32(),Title: checker.title,Content: "Creating indexes will block writes on the table, unless use CONCURRENTLY",- StartPosition: common.ConvertPGParserLineToPosition(in.LastLine()),+ StartPosition: newPositionAtLineStart(in.LastLine()),})}case *ast.DropIndexStmt:@@ -96,7 +95,7 @@ func (checker *indexCreateConcurrentlyChecker) Visit(in ast.Node) ast.Visitor {Code: advisor.DropIndexUnconcurrently.Int32(),Title: checker.title,Content: "Droping indexes will block writes on the table, unless use CONCURRENTLY",- StartPosition: common.ConvertPGParserLineToPosition(in.LastLine()),+ StartPosition: newPositionAtLineStart(in.LastLine()),})}}diff --git a/backend/plugin/advisor/pg/advisor_index_key_number_limit.go b/backend/plugin/advisor/pg/advisor_index_key_number_limit.goindex fd78a91649..608fa9e7fc 100644--- a/backend/plugin/advisor/pg/advisor_index_key_number_limit.go+++ b/backend/plugin/advisor/pg/advisor_index_key_number_limit.go@@ -6,7 +6,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/ast"@@ -105,7 +104,7 @@ func (checker *indexKeyNumberLimitChecker) Visit(node ast.Node) ast.Visitor {Code: advisor.IndexKeyNumberExceedsLimit.Int32(),Title: checker.title,Content: fmt.Sprintf("The number of keys of index %q in table %q should be not greater than %d", index.indexName, index.tableName, checker.max),- StartPosition: common.ConvertPGParserLineToPosition(index.line),+ StartPosition: newPositionAtLineStart(index.line),})}return checkerdiff --git a/backend/plugin/advisor/pg/advisor_index_no_duplicate_column.go b/backend/plugin/advisor/pg/advisor_index_no_duplicate_column.goindex 35bd205bc4..177db7125f 100644--- a/backend/plugin/advisor/pg/advisor_index_no_duplicate_column.go+++ b/backend/plugin/advisor/pg/advisor_index_no_duplicate_column.go@@ -6,7 +6,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/ast"@@ -129,7 +128,7 @@ func (checker *indexNoDuplicateColumnChecker) Visit(node ast.Node) ast.Visitor {Code: advisor.DuplicateColumnInIndex.Int32(),Title: checker.title,Content: fmt.Sprintf("%s \"%s\" has duplicate column \"%s\".\"%s\"", column.constraintType, column.index, column.table, column.column),- StartPosition: common.ConvertPGParserLineToPosition(column.line),+ StartPosition: newPositionAtLineStart(column.line),})}diff --git a/backend/plugin/advisor/pg/advisor_index_primary_key_type_allowlist.go b/backend/plugin/advisor/pg/advisor_index_primary_key_type_allowlist.goindex e5b4b54dd3..c51310e0d0 100644--- a/backend/plugin/advisor/pg/advisor_index_primary_key_type_allowlist.go+++ b/backend/plugin/advisor/pg/advisor_index_primary_key_type_allowlist.go@@ -9,7 +9,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"pgrawparser "github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy"@@ -100,7 +99,7 @@ func (checker *indexPrimaryKeyTypeAllowlistChecker) Visit(in ast.Node) ast.VisitCode: advisor.IndexPKType.Int32(),Title: checker.title,Content: fmt.Sprintf(`The column "%s" is one of the primary key, but its type "%s" is not in allowlist`, column.ColumnName, typeText),- StartPosition: common.ConvertPGParserLineToPosition(column.LastLine()),+ StartPosition: newPositionAtLineStart(column.LastLine()),})}}diff --git a/backend/plugin/advisor/pg/advisor_index_total_number_limit.go b/backend/plugin/advisor/pg/advisor_index_total_number_limit.goindex ba14cae219..12e67e22c8 100644--- a/backend/plugin/advisor/pg/advisor_index_total_number_limit.go+++ b/backend/plugin/advisor/pg/advisor_index_total_number_limit.go@@ -9,7 +9,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/catalog"@@ -115,7 +114,7 @@ func (checker *indexTotalNumberLimitChecker) generateAdvice() []*storepb.AdviceCode: advisor.IndexCountExceedsLimit.Int32(),Title: checker.title,Content: fmt.Sprintf("The count of index in table %q.%q should be no more than %d, but found %d", table.schema, table.table, checker.max, tableInfo.CountIndex()),- StartPosition: common.ConvertPGParserLineToPosition(table.line),+ StartPosition: newPositionAtLineStart(table.line),})}}diff --git a/backend/plugin/advisor/pg/advisor_insert_disallow_order_by_rand.go b/backend/plugin/advisor/pg/advisor_insert_disallow_order_by_rand.goindex 8bc9736e24..a60d026cf6 100644--- a/backend/plugin/advisor/pg/advisor_insert_disallow_order_by_rand.go+++ b/backend/plugin/advisor/pg/advisor_insert_disallow_order_by_rand.go@@ -9,7 +9,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/ast"@@ -78,7 +77,7 @@ func (checker *insertDisallowOrderByRandChecker) Visit(in ast.Node) ast.VisitorCode: code.Int32(),Title: checker.title,Content: fmt.Sprintf("The INSERT statement uses ORDER BY random() or random_between(), related statement \"%s\"", checker.text),- StartPosition: common.ConvertPGParserLineToPosition(in.LastLine()),+ StartPosition: newPositionAtLineStart(in.LastLine()),})}diff --git a/backend/plugin/advisor/pg/advisor_insert_must_specify_column.go b/backend/plugin/advisor/pg/advisor_insert_must_specify_column.goindex fd28a0d4f4..cc6858a951 100644--- a/backend/plugin/advisor/pg/advisor_insert_must_specify_column.go+++ b/backend/plugin/advisor/pg/advisor_insert_must_specify_column.go@@ -8,7 +8,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/ast"@@ -66,7 +65,7 @@ func (checker *insertMustSpecifyColumnChecker) Visit(in ast.Node) ast.Visitor {Code: advisor.InsertNotSpecifyColumn.Int32(),Title: checker.title,Content: fmt.Sprintf("The INSERT statement must specify columns but \"%s\" does not", checker.text),- StartPosition: common.ConvertPGParserLineToPosition(node.LastLine()),+ StartPosition: newPositionAtLineStart(node.LastLine()),})}diff --git a/backend/plugin/advisor/pg/advisor_insert_row_limit.go b/backend/plugin/advisor/pg/advisor_insert_row_limit.goindex 897a48961a..748d34ea8a 100644--- a/backend/plugin/advisor/pg/advisor_insert_row_limit.go+++ b/backend/plugin/advisor/pg/advisor_insert_row_limit.go@@ -110,7 +110,7 @@ func (checker *insertRowLimitChecker) Visit(node ast.Node) ast.Visitor {Code: advisor.InsertTooManyRows.Int32(),Title: checker.title,Content: fmt.Sprintf("\"%s\" dry runs failed: %s", checker.text, err.Error()),- StartPosition: common.ConvertPGParserLineToPosition(checker.line),+ StartPosition: newPositionAtLineStart(checker.line),})} else {rowCount, err := getAffectedRows(res)@@ -120,7 +120,7 @@ func (checker *insertRowLimitChecker) Visit(node ast.Node) ast.Visitor {Code: advisor.Internal.Int32(),Title: checker.title,Content: fmt.Sprintf("failed to get row count for \"%s\": %s", checker.text, err.Error()),- StartPosition: common.ConvertPGParserLineToPosition(checker.line),+ StartPosition: newPositionAtLineStart(checker.line),})} else if rowCount > int64(checker.maxRow) {code = advisor.InsertTooManyRows@@ -136,7 +136,7 @@ func (checker *insertRowLimitChecker) Visit(node ast.Node) ast.Visitor {Code: code.Int32(),Title: checker.title,Content: fmt.Sprintf("The statement \"%s\" inserts %d rows. The count exceeds %d.", checker.text, rows, checker.maxRow),- StartPosition: common.ConvertPGParserLineToPosition(checker.line),+ StartPosition: newPositionAtLineStart(checker.line),})}return checkerdiff --git a/backend/plugin/advisor/pg/advisor_migration_compatibility.go b/backend/plugin/advisor/pg/advisor_migration_compatibility.goindex d643a54669..b26904cdcb 100644--- a/backend/plugin/advisor/pg/advisor_migration_compatibility.go+++ b/backend/plugin/advisor/pg/advisor_migration_compatibility.go@@ -6,7 +6,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/ast"@@ -124,7 +123,7 @@ func (checker *compatibilityChecker) Visit(node ast.Node) ast.Visitor {Code: code.Int32(),Title: checker.title,Content: fmt.Sprintf("\"%s\" may cause incompatibility with the existing data and code", checker.text),- StartPosition: common.ConvertPGParserLineToPosition(node.LastLine()),+ StartPosition: newPositionAtLineStart(node.LastLine()),})}return checkerdiff --git a/backend/plugin/advisor/pg/advisor_naming_column.go b/backend/plugin/advisor/pg/advisor_naming_column.goindex 78720a2653..99a6a43e53 100644--- a/backend/plugin/advisor/pg/advisor_naming_column.go+++ b/backend/plugin/advisor/pg/advisor_naming_column.go@@ -7,7 +7,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/ast"@@ -108,7 +107,7 @@ func (checker *namingColumnConventionChecker) Visit(node ast.Node) ast.Visitor {Code: advisor.NamingColumnConventionMismatch.Int32(),Title: checker.title,Content: fmt.Sprintf("\"%s\".\"%s\" mismatches column naming convention, naming format should be %q", tableName, column.name, checker.format),- StartPosition: common.ConvertPGParserLineToPosition(column.line),+ StartPosition: newPositionAtLineStart(column.line),})}@@ -118,7 +117,7 @@ func (checker *namingColumnConventionChecker) Visit(node ast.Node) ast.Visitor {Code: advisor.NamingColumnConventionMismatch.Int32(),Title: checker.title,Content: fmt.Sprintf("\"%s\".\"%s\" mismatches column naming convention, its length should be within %d characters", tableName, column.name, checker.maxLength),- StartPosition: common.ConvertPGParserLineToPosition(column.line),+ StartPosition: newPositionAtLineStart(column.line),})}}diff --git a/backend/plugin/advisor/pg/advisor_naming_foreign_key_convention.go b/backend/plugin/advisor/pg/advisor_naming_foreign_key_convention.goindex 979ae59031..e7c1b91fd2 100644--- a/backend/plugin/advisor/pg/advisor_naming_foreign_key_convention.go+++ b/backend/plugin/advisor/pg/advisor_naming_foreign_key_convention.go@@ -8,7 +8,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/ast"@@ -96,7 +95,7 @@ func (checker *namingFKConventionChecker) Visit(in ast.Node) ast.Visitor {Code: advisor.NamingFKConventionMismatch.Int32(),Title: checker.title,Content: fmt.Sprintf(`Foreign key in table "%s" mismatches the naming convention, expect %q but found "%s"`, indexData.tableName, regex, indexData.indexName),- StartPosition: common.ConvertPGParserLineToPosition(indexData.line),+ StartPosition: newPositionAtLineStart(indexData.line),})}if checker.maxLength > 0 && len(indexData.indexName) > checker.maxLength {@@ -105,7 +104,7 @@ func (checker *namingFKConventionChecker) Visit(in ast.Node) ast.Visitor {Code: advisor.NamingFKConventionMismatch.Int32(),Title: checker.title,Content: fmt.Sprintf(`Foreign key "%s" in table "%s" mismatches the naming convention, its length should be within %d characters`, indexData.indexName, indexData.tableName, checker.maxLength),- StartPosition: common.ConvertPGParserLineToPosition(indexData.line),+ StartPosition: newPositionAtLineStart(indexData.line),})}}diff --git a/backend/plugin/advisor/pg/advisor_naming_fully_qualified.go b/backend/plugin/advisor/pg/advisor_naming_fully_qualified.goindex 7a92e02216..fb255df844 100644--- a/backend/plugin/advisor/pg/advisor_naming_fully_qualified.go+++ b/backend/plugin/advisor/pg/advisor_naming_fully_qualified.go@@ -10,7 +10,6 @@ import (pgquery "github.com/pganalyze/pg_query_go/v6""github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/parser/base"@@ -170,7 +169,7 @@ func (checker *FullyQualifiedObjectNameChecker) appendAdviceByObjName(objName stCode: advisor.NamingNotFullyQualifiedName,Title: checker.title,Content: fmt.Sprintf("unqualified object name: '%s'", objName),- StartPosition: common.ConvertPGParserLineToPosition(checker.line),+ StartPosition: newPositionAtLineStart(checker.line),})}}diff --git a/backend/plugin/advisor/pg/advisor_naming_index_convention.go b/backend/plugin/advisor/pg/advisor_naming_index_convention.goindex c3294fe2b0..882f850935 100644--- a/backend/plugin/advisor/pg/advisor_naming_index_convention.go+++ b/backend/plugin/advisor/pg/advisor_naming_index_convention.go@@ -7,7 +7,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/catalog"@@ -90,7 +89,7 @@ func (checker *namingIndexConventionChecker) Visit(node ast.Node) ast.Visitor {Code: advisor.NamingIndexConventionMismatch.Int32(),Title: checker.title,Content: fmt.Sprintf("Index in table %q mismatches the naming convention, expect %q but found %q", indexData.tableName, regex, indexData.indexName),- StartPosition: common.ConvertPGParserLineToPosition(node.LastLine()),+ StartPosition: newPositionAtLineStart(node.LastLine()),})}if checker.maxLength > 0 && len(indexData.indexName) > checker.maxLength {@@ -99,7 +98,7 @@ func (checker *namingIndexConventionChecker) Visit(node ast.Node) ast.Visitor {Code: advisor.NamingIndexConventionMismatch.Int32(),Title: checker.title,Content: fmt.Sprintf("Index %q in table %q mismatches the naming convention, its length should be within %d characters", indexData.indexName, indexData.tableName, checker.maxLength),- StartPosition: common.ConvertPGParserLineToPosition(node.LastLine()),+ StartPosition: newPositionAtLineStart(node.LastLine()),})}}diff --git a/backend/plugin/advisor/pg/advisor_naming_primary_key_convention.go b/backend/plugin/advisor/pg/advisor_naming_primary_key_convention.goindex bdeea038b9..f9f405a55c 100644--- a/backend/plugin/advisor/pg/advisor_naming_primary_key_convention.go+++ b/backend/plugin/advisor/pg/advisor_naming_primary_key_convention.go@@ -7,7 +7,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/catalog"@@ -91,7 +90,7 @@ func (checker *namingPKConventionChecker) Visit(in ast.Node) ast.Visitor {Code: advisor.NamingPKConventionMismatch.Int32(),Title: checker.title,Content: fmt.Sprintf(`Primary key in table "%s" mismatches the naming convention, expect %q but found "%s"`, indexData.tableName, regex, indexData.indexName),- StartPosition: common.ConvertPGParserLineToPosition(indexData.line),+ StartPosition: newPositionAtLineStart(indexData.line),})}if checker.maxLength > 0 && len(indexData.indexName) > checker.maxLength {@@ -100,7 +99,7 @@ func (checker *namingPKConventionChecker) Visit(in ast.Node) ast.Visitor {Code: advisor.NamingPKConventionMismatch.Int32(),Title: checker.title,Content: fmt.Sprintf(`Primary key "%s" in table "%s" mismatches the naming convention, its length should be within %d characters`, indexData.indexName, indexData.tableName, checker.maxLength),- StartPosition: common.ConvertPGParserLineToPosition(indexData.line),+ StartPosition: newPositionAtLineStart(indexData.line),})}}diff --git a/backend/plugin/advisor/pg/advisor_naming_table.go b/backend/plugin/advisor/pg/advisor_naming_table.goindex 4eaf8ca18a..f60d6538cf 100644--- a/backend/plugin/advisor/pg/advisor_naming_table.go+++ b/backend/plugin/advisor/pg/advisor_naming_table.go@@ -7,7 +7,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/ast"@@ -84,7 +83,7 @@ func (checker *namingTableConventionChecker) Visit(node ast.Node) ast.Visitor {Code: advisor.NamingTableConventionMismatch.Int32(),Title: checker.title,Content: fmt.Sprintf(`"%s" mismatches table naming convention, naming format should be %q`, tableName, checker.format),- StartPosition: common.ConvertPGParserLineToPosition(node.LastLine()),+ StartPosition: newPositionAtLineStart(node.LastLine()),})}if checker.maxLength > 0 && len(tableName) > checker.maxLength {@@ -93,7 +92,7 @@ func (checker *namingTableConventionChecker) Visit(node ast.Node) ast.Visitor {Code: advisor.NamingTableConventionMismatch.Int32(),Title: checker.title,Content: fmt.Sprintf("\"%s\" mismatches table naming convention, its length should be within %d characters", tableName, checker.maxLength),- StartPosition: common.ConvertPGParserLineToPosition(node.LastLine()),+ StartPosition: newPositionAtLineStart(node.LastLine()),})}}diff --git a/backend/plugin/advisor/pg/advisor_naming_unique_key_convention.go b/backend/plugin/advisor/pg/advisor_naming_unique_key_convention.goindex 4944258616..8c8edce571 100644--- a/backend/plugin/advisor/pg/advisor_naming_unique_key_convention.go+++ b/backend/plugin/advisor/pg/advisor_naming_unique_key_convention.go@@ -7,7 +7,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/catalog"@@ -91,7 +90,7 @@ func (checker *namingUKConventionChecker) Visit(in ast.Node) ast.Visitor {Code: advisor.NamingUKConventionMismatch.Int32(),Title: checker.title,Content: fmt.Sprintf(`Unique key in table "%s" mismatches the naming convention, expect %q but found "%s"`, indexData.tableName, regex, indexData.indexName),- StartPosition: common.ConvertPGParserLineToPosition(indexData.line),+ StartPosition: newPositionAtLineStart(indexData.line),})}if checker.maxLength > 0 && len(indexData.indexName) > checker.maxLength {@@ -100,7 +99,7 @@ func (checker *namingUKConventionChecker) Visit(in ast.Node) ast.Visitor {Code: advisor.NamingUKConventionMismatch.Int32(),Title: checker.title,Content: fmt.Sprintf(`Unique key "%s" in table "%s" mismatches the naming convention, its length should be within %d characters`, indexData.indexName, indexData.tableName, checker.maxLength),- StartPosition: common.ConvertPGParserLineToPosition(indexData.line),+ StartPosition: newPositionAtLineStart(indexData.line),})}}diff --git a/backend/plugin/advisor/pg/advisor_statement_add_check_not_valid.go b/backend/plugin/advisor/pg/advisor_statement_add_check_not_valid.goindex 178b3e601c..f59b8cbc88 100644--- a/backend/plugin/advisor/pg/advisor_statement_add_check_not_valid.go+++ b/backend/plugin/advisor/pg/advisor_statement_add_check_not_valid.go@@ -7,7 +7,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/ast"@@ -66,7 +65,7 @@ func (checker *statementAddCheckNotValidChecker) Visit(in ast.Node) ast.VisitorCode: advisor.StatementAddCheckWithValidation.Int32(),Title: checker.title,Content: "Adding check constraints with validation will block reads and writes. You can add check constraints not valid and then validate separately",- StartPosition: common.ConvertPGParserLineToPosition(checker.line),+ StartPosition: newPositionAtLineStart(checker.line),})}}diff --git a/backend/plugin/advisor/pg/advisor_statement_add_fk_not_valid.go b/backend/plugin/advisor/pg/advisor_statement_add_fk_not_valid.goindex fc30a2c61b..f336ce5090 100644--- a/backend/plugin/advisor/pg/advisor_statement_add_fk_not_valid.go+++ b/backend/plugin/advisor/pg/advisor_statement_add_fk_not_valid.go@@ -7,7 +7,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/ast"@@ -66,7 +65,7 @@ func (checker *statementAddFKNotValidChecker) Visit(in ast.Node) ast.Visitor {Code: advisor.StatementAddFKWithValidation.Int32(),Title: checker.title,Content: "Adding foreign keys with validation will block reads and writes. You can add check foreign keys not valid and then validate separately",- StartPosition: common.ConvertPGParserLineToPosition(checker.line),+ StartPosition: newPositionAtLineStart(checker.line),})}}diff --git a/backend/plugin/advisor/pg/advisor_statement_affected_row_limit.go b/backend/plugin/advisor/pg/advisor_statement_affected_row_limit.goindex b0fcfe83b2..0935c95897 100644--- a/backend/plugin/advisor/pg/advisor_statement_affected_row_limit.go+++ b/backend/plugin/advisor/pg/advisor_statement_affected_row_limit.go@@ -99,7 +99,7 @@ func (checker *statementAffectedRowLimitChecker) Visit(in ast.Node) ast.VisitorCode: advisor.InsertTooManyRows.Int32(),Title: checker.title,Content: fmt.Sprintf("\"%s\" dry runs failed: %s", checker.text, err.Error()),- StartPosition: common.ConvertPGParserLineToPosition(node.LastLine()),+ StartPosition: newPositionAtLineStart(node.LastLine()),})} else {rowCount, err := getAffectedRows(res)@@ -109,7 +109,7 @@ func (checker *statementAffectedRowLimitChecker) Visit(in ast.Node) ast.VisitorCode: advisor.Internal.Int32(),Title: checker.title,Content: fmt.Sprintf("failed to get row count for \"%s\": %s", checker.text, err.Error()),- StartPosition: common.ConvertPGParserLineToPosition(node.LastLine()),+ StartPosition: newPositionAtLineStart(node.LastLine()),})} else if rowCount > int64(checker.maxRow) {code = advisor.StatementAffectedRowExceedsLimit@@ -124,7 +124,7 @@ func (checker *statementAffectedRowLimitChecker) Visit(in ast.Node) ast.VisitorCode: code.Int32(),Title: checker.title,Content: fmt.Sprintf("The statement \"%s\" affected %d rows (estimated). The count exceeds %d.", checker.text, rows, checker.maxRow),- StartPosition: common.ConvertPGParserLineToPosition(in.LastLine()),+ StartPosition: newPositionAtLineStart(in.LastLine()),})}return checkerdiff --git a/backend/plugin/advisor/pg/advisor_statement_check_set_role_variable.go b/backend/plugin/advisor/pg/advisor_statement_check_set_role_variable.goindex 4781374fac..7402056704 100644--- a/backend/plugin/advisor/pg/advisor_statement_check_set_role_variable.go+++ b/backend/plugin/advisor/pg/advisor_statement_check_set_role_variable.go@@ -5,7 +5,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/ast"@@ -54,7 +53,7 @@ func (*StatementCheckSetRoleVariable) Check(_ context.Context, checkCtx advisor.Code: advisor.StatementCheckSetRoleVariable.Int32(),Title: string(checkCtx.Rule.Type),Content: "No SET ROLE statement found.",- StartPosition: common.FirstLinePosition,+ StartPosition: nil,}}, nil}diff --git a/backend/plugin/advisor/pg/advisor_statement_create_specify_schema.go b/backend/plugin/advisor/pg/advisor_statement_create_specify_schema.goindex 35c5339a2e..ff26f3e8a6 100644--- a/backend/plugin/advisor/pg/advisor_statement_create_specify_schema.go+++ b/backend/plugin/advisor/pg/advisor_statement_create_specify_schema.go@@ -5,7 +5,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/ast"@@ -60,7 +59,7 @@ func (c *statementCreateSpecifySchemaChecker) Visit(node ast.Node) ast.Visitor {Code: advisor.StatementCreateWithoutSchemaName.Int32(),Title: c.title,Content: "Table schema should be specified.",- StartPosition: common.ConvertPGParserLineToPosition(node.LastLine()),+ StartPosition: newPositionAtLineStart(node.LastLine()),})}case *ast.CreateExtensionStmt:@@ -70,7 +69,7 @@ func (c *statementCreateSpecifySchemaChecker) Visit(node ast.Node) ast.Visitor {Code: advisor.StatementCreateWithoutSchemaName.Int32(),Title: c.title,Content: "Extension schema should be specified.",- StartPosition: common.ConvertPGParserLineToPosition(node.LastLine()),+ StartPosition: newPositionAtLineStart(node.LastLine()),})}case *ast.CreateFunctionStmt:@@ -80,7 +79,7 @@ func (c *statementCreateSpecifySchemaChecker) Visit(node ast.Node) ast.Visitor {Code: advisor.StatementCreateWithoutSchemaName.Int32(),Title: c.title,Content: "Function schema should be specified.",- StartPosition: common.ConvertPGParserLineToPosition(node.LastLine()),+ StartPosition: newPositionAtLineStart(node.LastLine()),})}case *ast.CreateIndexStmt:@@ -90,7 +89,7 @@ func (c *statementCreateSpecifySchemaChecker) Visit(node ast.Node) ast.Visitor {Code: advisor.StatementCreateWithoutSchemaName.Int32(),Title: c.title,Content: "Table schema for index should be specified.",- StartPosition: common.ConvertPGParserLineToPosition(node.LastLine()),+ StartPosition: newPositionAtLineStart(node.LastLine()),})}case *ast.CreateSequenceStmt:@@ -100,7 +99,7 @@ func (c *statementCreateSpecifySchemaChecker) Visit(node ast.Node) ast.Visitor {Code: advisor.StatementCreateWithoutSchemaName.Int32(),Title: c.title,Content: "Sequence schema should be specified.",- StartPosition: common.ConvertPGParserLineToPosition(node.LastLine()),+ StartPosition: newPositionAtLineStart(node.LastLine()),})}case *ast.CreateTriggerStmt:@@ -110,7 +109,7 @@ func (c *statementCreateSpecifySchemaChecker) Visit(node ast.Node) ast.Visitor {Code: advisor.StatementCreateWithoutSchemaName.Int32(),Title: c.title,Content: "Table schema for trigger should be specified.",- StartPosition: common.ConvertPGParserLineToPosition(node.LastLine()),+ StartPosition: newPositionAtLineStart(node.LastLine()),})}}diff --git a/backend/plugin/advisor/pg/advisor_statement_disallow_add_column_with_default.go b/backend/plugin/advisor/pg/advisor_statement_disallow_add_column_with_default.goindex e492c16f14..5e6d0b3a3f 100644--- a/backend/plugin/advisor/pg/advisor_statement_disallow_add_column_with_default.go+++ b/backend/plugin/advisor/pg/advisor_statement_disallow_add_column_with_default.go@@ -7,7 +7,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/ast"@@ -67,7 +66,7 @@ func (checker *statementDisallowAddColumnWithDefaultChecker) Visit(in ast.Node)Code: advisor.StatementAddColumnWithDefault.Int32(),Title: checker.title,Content: "Adding column with DEFAULT will locked the whole table and rewriting each rows",- StartPosition: common.ConvertPGParserLineToPosition(checker.line),+ StartPosition: newPositionAtLineStart(checker.line),})}}diff --git a/backend/plugin/advisor/pg/advisor_statement_disallow_add_not_null.go b/backend/plugin/advisor/pg/advisor_statement_disallow_add_not_null.goindex 5b6413984f..933609769d 100644--- a/backend/plugin/advisor/pg/advisor_statement_disallow_add_not_null.go+++ b/backend/plugin/advisor/pg/advisor_statement_disallow_add_not_null.go@@ -8,7 +8,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/ast"@@ -66,7 +65,7 @@ func (checker *statementDisallowAddNotNullChecker) Visit(in ast.Node) ast.VisitoCode: advisor.StatementAddNotNull.Int32(),Title: checker.title,Content: fmt.Sprintf("Setting NOT NULL will block reads and writes. You can use CHECK (%q IS NOT NULL) instead", node.ColumnName),- StartPosition: common.ConvertPGParserLineToPosition(checker.line),+ StartPosition: newPositionAtLineStart(checker.line),})}diff --git a/backend/plugin/advisor/pg/advisor_statement_disallow_commit.go b/backend/plugin/advisor/pg/advisor_statement_disallow_commit.goindex 1a9af2a3ab..fb8c297a02 100644--- a/backend/plugin/advisor/pg/advisor_statement_disallow_commit.go+++ b/backend/plugin/advisor/pg/advisor_statement_disallow_commit.go@@ -8,7 +8,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/ast"@@ -64,7 +63,7 @@ func (checker *statementDisallowCommitChecker) Visit(in ast.Node) ast.Visitor {Code: advisor.StatementDisallowCommit.Int32(),Title: checker.title,Content: fmt.Sprintf("Commit is not allowed, related statement: \"%s\"", in.Text()),- StartPosition: common.ConvertPGParserLineToPosition(in.LastLine()),+ StartPosition: newPositionAtLineStart(in.LastLine()),})}diff --git a/backend/plugin/advisor/pg/advisor_statement_disallow_mix_in_ddl.go b/backend/plugin/advisor/pg/advisor_statement_disallow_mix_in_ddl.goindex 45a7dcbf8f..add82fd8bd 100644--- a/backend/plugin/advisor/pg/advisor_statement_disallow_mix_in_ddl.go+++ b/backend/plugin/advisor/pg/advisor_statement_disallow_mix_in_ddl.go@@ -8,7 +8,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/ast"@@ -52,7 +51,7 @@ func (*StatementDisallowMixInDDLAdvisor) Check(_ context.Context, checkCtx advisTitle: title,Content: fmt.Sprintf("Alter schema can only run DDL, \"%s\" is not DDL", stmt.Text()),Code: advisor.StatementDisallowMixDDLDML.Int32(),- StartPosition: common.ConvertPGParserLineToPosition(stmt.LastLine()),+ StartPosition: newPositionAtLineStart(stmt.LastLine()),})}}diff --git a/backend/plugin/advisor/pg/advisor_statement_disallow_mix_in_dml.go b/backend/plugin/advisor/pg/advisor_statement_disallow_mix_in_dml.goindex 8f8755e941..39c74d2537 100644--- a/backend/plugin/advisor/pg/advisor_statement_disallow_mix_in_dml.go+++ b/backend/plugin/advisor/pg/advisor_statement_disallow_mix_in_dml.go@@ -8,7 +8,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/ast"@@ -52,7 +51,7 @@ func (*StatementDisallowMixInDMLAdvisor) Check(_ context.Context, checkCtx advisTitle: title,Content: fmt.Sprintf("Data change can only run DML, \"%s\" is not DML", stmt.Text()),Code: advisor.StatementDisallowMixDDLDML.Int32(),- StartPosition: common.ConvertPGParserLineToPosition(stmt.LastLine()),+ StartPosition: newPositionAtLineStart(stmt.LastLine()),})}}diff --git a/backend/plugin/advisor/pg/advisor_statement_dml_dry_run.go b/backend/plugin/advisor/pg/advisor_statement_dml_dry_run.goindex 5f3875b79b..cd5b7b458c 100644--- a/backend/plugin/advisor/pg/advisor_statement_dml_dry_run.go+++ b/backend/plugin/advisor/pg/advisor_statement_dml_dry_run.go@@ -88,7 +88,7 @@ func (checker *statementDmlDryRunChecker) Visit(in ast.Node) ast.Visitor {Code: advisor.StatementDMLDryRunFailed.Int32(),Title: checker.title,Content: fmt.Sprintf("\"%s\" dry runs failed: %s", node.Text(), err.Error()),- StartPosition: common.ConvertPGParserLineToPosition(node.LastLine()),+ StartPosition: newPositionAtLineStart(node.LastLine()),})}}diff --git a/backend/plugin/advisor/pg/advisor_statement_maximum_limit_value.go b/backend/plugin/advisor/pg/advisor_statement_maximum_limit_value.goindex d2b0b6646b..25620fe2dc 100644--- a/backend/plugin/advisor/pg/advisor_statement_maximum_limit_value.go+++ b/backend/plugin/advisor/pg/advisor_statement_maximum_limit_value.go@@ -8,7 +8,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/ast"@@ -73,7 +72,7 @@ func (checker *statementMaximumLimitValueChecker) Visit(in ast.Node) ast.VisitorCode: advisor.StatementExceedMaximumLimitValue.Int32(),Title: checker.title,Content: fmt.Sprintf("The limit value %d exceeds the maximum allowed value %d", *node.Limit, checker.limitMaxValue),- StartPosition: common.ConvertPGParserLineToPosition(checker.line),+ StartPosition: newPositionAtLineStart(checker.line),})}}diff --git a/backend/plugin/advisor/pg/advisor_statement_merge_alter_table.go b/backend/plugin/advisor/pg/advisor_statement_merge_alter_table.goindex d6b931b468..abff5f49a7 100644--- a/backend/plugin/advisor/pg/advisor_statement_merge_alter_table.go+++ b/backend/plugin/advisor/pg/advisor_statement_merge_alter_table.go@@ -9,7 +9,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/ast"@@ -73,7 +72,7 @@ func (checker *statementMergeAlterTableChecker) generateAdvice() []*storepb.AdviCode: advisor.StatementRedundantAlterTable.Int32(),Title: checker.title,Content: fmt.Sprintf("There are %d statements to modify table `%s`", table.count, table.name),- StartPosition: common.ConvertPGParserLineToPosition(table.line),+ StartPosition: newPositionAtLineStart(table.line),})}}diff --git a/backend/plugin/advisor/pg/advisor_statement_non_transactional.go b/backend/plugin/advisor/pg/advisor_statement_non_transactional.goindex df38084486..13eb8c74f1 100644--- a/backend/plugin/advisor/pg/advisor_statement_non_transactional.go+++ b/backend/plugin/advisor/pg/advisor_statement_non_transactional.go@@ -5,7 +5,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/db/pg"@@ -47,7 +46,7 @@ func (*NonTransactionalAdvisor) Check(_ context.Context, checkCtx advisor.ContexCode: advisor.StatementNonTransactional.Int32(),Title: checker.title,Content: "This statement is non-transactional",- StartPosition: common.ConvertPGParserLineToPosition(checker.line),+ StartPosition: newPositionAtLineStart(checker.line),})}}diff --git a/backend/plugin/advisor/pg/advisor_statement_object_owner_check.go b/backend/plugin/advisor/pg/advisor_statement_object_owner_check.goindex 2f08192ea8..ee892e5355 100644--- a/backend/plugin/advisor/pg/advisor_statement_object_owner_check.go+++ b/backend/plugin/advisor/pg/advisor_statement_object_owner_check.go@@ -8,7 +8,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common""github.com/bytebase/bytebase/backend/common/log"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor"@@ -84,7 +83,7 @@ func (*StatementObjectOwnerCheckAdvisor) Check(ctx context.Context, checkCtx advTitle: title,Content: fmt.Sprintf("Sequence \"%s\" is owned by \"%s\", but the current role is \"%s\".", n.Name.Name, owner, currentRole),Code: advisor.StatementObjectOwnerCheck.Int32(),- StartPosition: common.ConvertPGParserLineToPosition(stmt.LastLine()),+ StartPosition: newPositionAtLineStart(stmt.LastLine()),})}case *ast.AlterTableStmt:@@ -113,7 +112,7 @@ func (*StatementObjectOwnerCheckAdvisor) Check(ctx context.Context, checkCtx advTitle: title,Content: fmt.Sprintf("Table \"%s\" is owned by \"%s\", but the current role is \"%s\".", n.Table.Name, owner, currentRole),Code: advisor.StatementObjectOwnerCheck.Int32(),- StartPosition: common.ConvertPGParserLineToPosition(stmt.LastLine()),+ StartPosition: newPositionAtLineStart(stmt.LastLine()),})}case *ast.AlterTypeStmt:@@ -139,7 +138,7 @@ func (*StatementObjectOwnerCheckAdvisor) Check(ctx context.Context, checkCtx advTitle: title,Content: fmt.Sprintf("Type \"%s\" is owned by \"%s\", but the current role is \"%s\".", n.Type.Name, owner, currentRole),Code: advisor.StatementObjectOwnerCheck.Int32(),- StartPosition: common.ConvertPGParserLineToPosition(stmt.LastLine()),+ StartPosition: newPositionAtLineStart(stmt.LastLine()),})}case *ast.CreateExtensionStmt:@@ -161,7 +160,7 @@ func (*StatementObjectOwnerCheckAdvisor) Check(ctx context.Context, checkCtx advTitle: title,Content: fmt.Sprintf("Schema \"%s\" is owned by \"%s\", but the current role is \"%s\".", schemaName, owner, currentRole),Code: advisor.StatementObjectOwnerCheck.Int32(),- StartPosition: common.ConvertPGParserLineToPosition(stmt.LastLine()),+ StartPosition: newPositionAtLineStart(stmt.LastLine()),})}case *ast.CreateFunctionStmt:@@ -186,7 +185,7 @@ func (*StatementObjectOwnerCheckAdvisor) Check(ctx context.Context, checkCtx advTitle: title,Content: fmt.Sprintf("Schema \"%s\" is owned by \"%s\", but the current role is \"%s\".", schemaName, owner, currentRole),Code: advisor.StatementObjectOwnerCheck.Int32(),- StartPosition: common.ConvertPGParserLineToPosition(stmt.LastLine()),+ StartPosition: newPositionAtLineStart(stmt.LastLine()),})}case *ast.CreateIndexStmt:@@ -211,7 +210,7 @@ func (*StatementObjectOwnerCheckAdvisor) Check(ctx context.Context, checkCtx advTitle: title,Content: fmt.Sprintf("Schema \"%s\" is owned by \"%s\", but the current role is \"%s\".", schemaName, owner, currentRole),Code: advisor.StatementObjectOwnerCheck.Int32(),- StartPosition: common.ConvertPGParserLineToPosition(stmt.LastLine()),+ StartPosition: newPositionAtLineStart(stmt.LastLine()),})}case *ast.CreateSchemaStmt:@@ -222,7 +221,7 @@ func (*StatementObjectOwnerCheckAdvisor) Check(ctx context.Context, checkCtx advTitle: title,Content: fmt.Sprintf("Database \"%s\" is owned by \"%s\", but the current role is \"%s\".", dbMetadata.GetName(), owner, currentRole),Code: advisor.StatementObjectOwnerCheck.Int32(),- StartPosition: common.ConvertPGParserLineToPosition(stmt.LastLine()),+ StartPosition: newPositionAtLineStart(stmt.LastLine()),})}case *ast.CreateSequenceStmt:@@ -247,7 +246,7 @@ func (*StatementObjectOwnerCheckAdvisor) Check(ctx context.Context, checkCtx advTitle: title,Content: fmt.Sprintf("Schema \"%s\" is owned by \"%s\", but the current role is \"%s\".", schemaName, owner, currentRole),Code: advisor.StatementObjectOwnerCheck.Int32(),- StartPosition: common.ConvertPGParserLineToPosition(stmt.LastLine()),+ StartPosition: newPositionAtLineStart(stmt.LastLine()),})}case *ast.CreateTableStmt:@@ -272,7 +271,7 @@ func (*StatementObjectOwnerCheckAdvisor) Check(ctx context.Context, checkCtx advTitle: title,Content: fmt.Sprintf("Schema \"%s\" is owned by \"%s\", but the current role is \"%s\".", schemaName, owner, currentRole),Code: advisor.StatementObjectOwnerCheck.Int32(),- StartPosition: common.ConvertPGParserLineToPosition(stmt.LastLine()),+ StartPosition: newPositionAtLineStart(stmt.LastLine()),})}case *ast.CreateTriggerStmt:@@ -297,7 +296,7 @@ func (*StatementObjectOwnerCheckAdvisor) Check(ctx context.Context, checkCtx advTitle: title,Content: fmt.Sprintf("Schema \"%s\" is owned by \"%s\", but the current role is \"%s\".", schemaName, owner, currentRole),Code: advisor.StatementObjectOwnerCheck.Int32(),- StartPosition: common.ConvertPGParserLineToPosition(stmt.LastLine()),+ StartPosition: newPositionAtLineStart(stmt.LastLine()),})}case *ast.CreateTypeStmt:@@ -322,7 +321,7 @@ func (*StatementObjectOwnerCheckAdvisor) Check(ctx context.Context, checkCtx advTitle: title,Content: fmt.Sprintf("Schema \"%s\" is owned by \"%s\", but the current role is \"%s\".", schemaName, owner, currentRole),Code: advisor.StatementObjectOwnerCheck.Int32(),- StartPosition: common.ConvertPGParserLineToPosition(stmt.LastLine()),+ StartPosition: newPositionAtLineStart(stmt.LastLine()),})}case *ast.CreateViewStmt:@@ -347,7 +346,7 @@ func (*StatementObjectOwnerCheckAdvisor) Check(ctx context.Context, checkCtx advTitle: title,Content: fmt.Sprintf("Schema \"%s\" is owned by \"%s\", but the current role is \"%s\".", schemaName, owner, currentRole),Code: advisor.StatementObjectOwnerCheck.Int32(),- StartPosition: common.ConvertPGParserLineToPosition(stmt.LastLine()),+ StartPosition: newPositionAtLineStart(stmt.LastLine()),})}case *ast.DropFunctionStmt:@@ -373,7 +372,7 @@ func (*StatementObjectOwnerCheckAdvisor) Check(ctx context.Context, checkCtx advTitle: title,Content: fmt.Sprintf("Schema \"%s\" is owned by \"%s\", but the current role is \"%s\".", schemaName, owner, currentRole),Code: advisor.StatementObjectOwnerCheck.Int32(),- StartPosition: common.ConvertPGParserLineToPosition(stmt.LastLine()),+ StartPosition: newPositionAtLineStart(stmt.LastLine()),})}}@@ -400,7 +399,7 @@ func (*StatementObjectOwnerCheckAdvisor) Check(ctx context.Context, checkCtx advTitle: title,Content: fmt.Sprintf("Schema \"%s\" is owned by \"%s\", but the current role is \"%s\".", schemaName, owner, currentRole),Code: advisor.StatementObjectOwnerCheck.Int32(),- StartPosition: common.ConvertPGParserLineToPosition(stmt.LastLine()),+ StartPosition: newPositionAtLineStart(stmt.LastLine()),})}}@@ -420,7 +419,7 @@ func (*StatementObjectOwnerCheckAdvisor) Check(ctx context.Context, checkCtx advTitle: title,Content: fmt.Sprintf("Schema \"%s\" is owned by \"%s\", but the current role is \"%s\".", schemaName, owner, currentRole),Code: advisor.StatementObjectOwnerCheck.Int32(),- StartPosition: common.ConvertPGParserLineToPosition(stmt.LastLine()),+ StartPosition: newPositionAtLineStart(stmt.LastLine()),})}}@@ -447,7 +446,7 @@ func (*StatementObjectOwnerCheckAdvisor) Check(ctx context.Context, checkCtx advTitle: title,Content: fmt.Sprintf("Schema \"%s\" is owned by \"%s\", but the current role is \"%s\".", schemaName, owner, currentRole),Code: advisor.StatementObjectOwnerCheck.Int32(),- StartPosition: common.ConvertPGParserLineToPosition(stmt.LastLine()),+ StartPosition: newPositionAtLineStart(stmt.LastLine()),})}}@@ -480,7 +479,7 @@ func (*StatementObjectOwnerCheckAdvisor) Check(ctx context.Context, checkCtx advTitle: title,Content: fmt.Sprintf("Table \"%s\" is owned by \"%s\", but the current role is \"%s\".", table.Name, owner, currentRole),Code: advisor.StatementObjectOwnerCheck.Int32(),- StartPosition: common.ConvertPGParserLineToPosition(stmt.LastLine()),+ StartPosition: newPositionAtLineStart(stmt.LastLine()),})}default:@@ -495,7 +494,7 @@ func (*StatementObjectOwnerCheckAdvisor) Check(ctx context.Context, checkCtx advTitle: title,Content: fmt.Sprintf("Schema \"%s\" is owned by \"%s\", but the current role is \"%s\".", schemaName, owner, currentRole),Code: advisor.StatementObjectOwnerCheck.Int32(),- StartPosition: common.ConvertPGParserLineToPosition(stmt.LastLine()),+ StartPosition: newPositionAtLineStart(stmt.LastLine()),})}}@@ -522,7 +521,7 @@ func (*StatementObjectOwnerCheckAdvisor) Check(ctx context.Context, checkCtx advTitle: title,Content: fmt.Sprintf("Schema \"%s\" is owned by \"%s\", but the current role is \"%s\".", schemaName, owner, currentRole),Code: advisor.StatementObjectOwnerCheck.Int32(),- StartPosition: common.ConvertPGParserLineToPosition(stmt.LastLine()),+ StartPosition: newPositionAtLineStart(stmt.LastLine()),})}case *ast.DropTypeStmt:@@ -548,7 +547,7 @@ func (*StatementObjectOwnerCheckAdvisor) Check(ctx context.Context, checkCtx advTitle: title,Content: fmt.Sprintf("Schema \"%s\" is owned by \"%s\", but the current role is \"%s\".", schemaName, owner, currentRole),Code: advisor.StatementObjectOwnerCheck.Int32(),- StartPosition: common.ConvertPGParserLineToPosition(stmt.LastLine()),+ StartPosition: newPositionAtLineStart(stmt.LastLine()),})}}@@ -571,7 +570,7 @@ func (*StatementObjectOwnerCheckAdvisor) Check(ctx context.Context, checkCtx advTitle: title,Content: fmt.Sprintf("Schema \"%s\" is owned by \"%s\", but the current role is \"%s\".", schemaName, owner, currentRole),Code: advisor.StatementObjectOwnerCheck.Int32(),- StartPosition: common.ConvertPGParserLineToPosition(stmt.LastLine()),+ StartPosition: newPositionAtLineStart(stmt.LastLine()),})}case *ast.RenameSchemaStmt:@@ -589,7 +588,7 @@ func (*StatementObjectOwnerCheckAdvisor) Check(ctx context.Context, checkCtx advTitle: title,Content: fmt.Sprintf("Schema \"%s\" is owned by \"%s\", but the current role is \"%s\".", n.Schema, owner, currentRole),Code: advisor.StatementObjectOwnerCheck.Int32(),- StartPosition: common.ConvertPGParserLineToPosition(stmt.LastLine()),+ StartPosition: newPositionAtLineStart(stmt.LastLine()),})}}diff --git a/backend/plugin/advisor/pg/advisor_stmt_no_leading_wildcard_like.go b/backend/plugin/advisor/pg/advisor_stmt_no_leading_wildcard_like.goindex 8e6935902c..b0d98b9f2f 100644--- a/backend/plugin/advisor/pg/advisor_stmt_no_leading_wildcard_like.go+++ b/backend/plugin/advisor/pg/advisor_stmt_no_leading_wildcard_like.go@@ -6,7 +6,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/ast"@@ -57,7 +56,7 @@ func (*NoLeadingWildcardLikeAdvisor) Check(_ context.Context, checkCtx advisor.CCode: advisor.StatementLeadingWildcardLike.Int32(),Title: checker.title,Content: fmt.Sprintf("\"%s\" uses leading wildcard LIKE", checker.text),- StartPosition: common.ConvertPGParserLineToPosition(stmt.LastLine()),+ StartPosition: newPositionAtLineStart(stmt.LastLine()),})}}diff --git a/backend/plugin/advisor/pg/advisor_stmt_no_select_all.go b/backend/plugin/advisor/pg/advisor_stmt_no_select_all.goindex 2773ab6bd3..f1a940b4ec 100644--- a/backend/plugin/advisor/pg/advisor_stmt_no_select_all.go+++ b/backend/plugin/advisor/pg/advisor_stmt_no_select_all.go@@ -6,7 +6,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/ast"@@ -68,7 +67,7 @@ func (checker *noSelectAllChecker) Visit(node ast.Node) ast.Visitor {Code: advisor.StatementSelectAll.Int32(),Title: checker.title,Content: fmt.Sprintf("\"%s\" uses SELECT all", checker.text),- StartPosition: common.ConvertPGParserLineToPosition(checker.line),+ StartPosition: newPositionAtLineStart(checker.line),})break}diff --git a/backend/plugin/advisor/pg/advisor_stmt_where_required_select.go b/backend/plugin/advisor/pg/advisor_stmt_where_required_select.goindex 6f37f66dba..0fa0ed6433 100644--- a/backend/plugin/advisor/pg/advisor_stmt_where_required_select.go+++ b/backend/plugin/advisor/pg/advisor_stmt_where_required_select.go@@ -6,7 +6,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/ast"@@ -74,7 +73,7 @@ func (checker *whereRequirementForSelectChecker) Visit(node ast.Node) ast.VisitoCode: code.Int32(),Title: checker.title,Content: fmt.Sprintf("\"%s\" requires WHERE clause", checker.text),- StartPosition: common.ConvertPGParserLineToPosition(checker.line),+ StartPosition: newPositionAtLineStart(checker.line),})}return checkerdiff --git a/backend/plugin/advisor/pg/advisor_stmt_where_required_update_delete.go b/backend/plugin/advisor/pg/advisor_stmt_where_required_update_delete.goindex ea39267642..bef5bf3ede 100644--- a/backend/plugin/advisor/pg/advisor_stmt_where_required_update_delete.go+++ b/backend/plugin/advisor/pg/advisor_stmt_where_required_update_delete.go@@ -6,7 +6,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/ast"@@ -80,7 +79,7 @@ func (checker *whereRequirementForUpdateDeleteChecker) Visit(node ast.Node) ast.Code: code.Int32(),Title: checker.title,Content: fmt.Sprintf("\"%s\" requires WHERE clause", checker.text),- StartPosition: common.ConvertPGParserLineToPosition(checker.line),+ StartPosition: newPositionAtLineStart(checker.line),})}return checkerdiff --git a/backend/plugin/advisor/pg/advisor_table_comment_convention.go b/backend/plugin/advisor/pg/advisor_table_comment_convention.goindex bb12f53d8f..6ab7c7ae58 100644--- a/backend/plugin/advisor/pg/advisor_table_comment_convention.go+++ b/backend/plugin/advisor/pg/advisor_table_comment_convention.go@@ -69,7 +69,7 @@ func (*TableCommentConventionAdvisor) Check(_ context.Context, checkCtx advisor.Code: advisor.CommentEmpty.Int32(),Title: checker.title,Content: fmt.Sprintf("Comment is required for table `%s`", stringifyTableDef(createTableStmt.Name)),- StartPosition: common.ConvertPGParserLineToPosition(createTableStmt.LastLine()),+ StartPosition: newPositionAtLineStart(createTableStmt.LastLine()),})}} else {@@ -80,7 +80,7 @@ func (*TableCommentConventionAdvisor) Check(_ context.Context, checkCtx advisor.Code: advisor.CommentTooLong.Int32(),Title: checker.title,Content: fmt.Sprintf("Table `%s` comment is too long. The length of comment should be within %d characters", stringifyTableDef(createTableStmt.Name), checker.payload.MaxLength),- StartPosition: common.ConvertPGParserLineToPosition(commentStmt.LastLine()),+ StartPosition: newPositionAtLineStart(commentStmt.LastLine()),})}if checker.payload.RequiredClassification {@@ -90,7 +90,7 @@ func (*TableCommentConventionAdvisor) Check(_ context.Context, checkCtx advisor.Code: advisor.CommentMissingClassification.Int32(),Title: checker.title,Content: fmt.Sprintf("Table `%s` comment requires classification", stringifyTableDef(createTableStmt.Name)),- StartPosition: common.ConvertPGParserLineToPosition(commentStmt.LastLine()),+ StartPosition: newPositionAtLineStart(commentStmt.LastLine()),})}}diff --git a/backend/plugin/advisor/pg/advisor_table_disallow_partition.go b/backend/plugin/advisor/pg/advisor_table_disallow_partition.goindex 71a6ca6d50..54fcfa60e0 100644--- a/backend/plugin/advisor/pg/advisor_table_disallow_partition.go+++ b/backend/plugin/advisor/pg/advisor_table_disallow_partition.go@@ -8,7 +8,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/ast"@@ -79,7 +78,7 @@ func (checker *tableDisallowPartitionChecker) Visit(in ast.Node) ast.Visitor {Code: code.Int32(),Title: checker.title,Content: fmt.Sprintf("Table partition is forbidden, but \"%s\" creates", checker.text),- StartPosition: common.ConvertPGParserLineToPosition(checker.line),+ StartPosition: newPositionAtLineStart(checker.line),})}diff --git a/backend/plugin/advisor/pg/advisor_table_drop_naming_convention.go b/backend/plugin/advisor/pg/advisor_table_drop_naming_convention.goindex c1cfac5679..3a57b6b8bd 100644--- a/backend/plugin/advisor/pg/advisor_table_drop_naming_convention.go+++ b/backend/plugin/advisor/pg/advisor_table_drop_naming_convention.go@@ -9,7 +9,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/ast"@@ -74,7 +73,7 @@ func (checker *tableDropNamingConventionChecker) Visit(in ast.Node) ast.VisitorCode: advisor.TableDropNamingConventionMismatch.Int32(),Title: checker.title,Content: fmt.Sprintf("`%s` mismatches drop table naming convention, naming format should be %q", table.Name, checker.format),- StartPosition: common.ConvertPGParserLineToPosition(node.LastLine()),+ StartPosition: newPositionAtLineStart(node.LastLine()),})}}diff --git a/backend/plugin/advisor/pg/advisor_table_no_fk.go b/backend/plugin/advisor/pg/advisor_table_no_fk.goindex bb2faa3cb2..a3e027fa53 100644--- a/backend/plugin/advisor/pg/advisor_table_no_fk.go+++ b/backend/plugin/advisor/pg/advisor_table_no_fk.go@@ -6,7 +6,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/ast"@@ -89,7 +88,7 @@ func (checker *tableNoFKChecker) Visit(node ast.Node) ast.Visitor {tableHasFK.Name,checker.text,),- StartPosition: common.ConvertPGParserLineToPosition(node.LastLine()),+ StartPosition: newPositionAtLineStart(node.LastLine()),})}diff --git a/backend/plugin/advisor/pg/advisor_table_require_pk.go b/backend/plugin/advisor/pg/advisor_table_require_pk.goindex dcee64125e..b9e20e87bc 100644--- a/backend/plugin/advisor/pg/advisor_table_require_pk.go+++ b/backend/plugin/advisor/pg/advisor_table_require_pk.go@@ -6,7 +6,6 @@ import ("github.com/pkg/errors"- "github.com/bytebase/bytebase/backend/common"storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/advisor""github.com/bytebase/bytebase/backend/plugin/advisor/catalog"@@ -113,7 +112,7 @@ func (checker *tableRequirePKChecker) Visit(node ast.Node) ast.Visitor {missingPK.Name,checker.text,),- StartPosition: common.ConvertPGParserLineToPosition(node.LastLine()),+ StartPosition: newPositionAtLineStart(node.LastLine()),})}diff --git a/backend/plugin/advisor/pg/test/statement_check_set_role_variable.yaml b/backend/plugin/advisor/pg/test/statement_check_set_role_variable.yamlindex 709c8d6960..0e76beb7a9 100644--- a/backend/plugin/advisor/pg/test/statement_check_set_role_variable.yaml+++ b/backend/plugin/advisor/pg/test/statement_check_set_role_variable.yaml@@ -7,7 +7,5 @@code: 217title: statement.check-set-role-variablecontent: No SET ROLE statement found.- startposition:- line: 0- column: 0+ startposition: nullendposition: nulldiff --git a/backend/plugin/advisor/pg/utils.go b/backend/plugin/advisor/pg/utils.goindex a958bcea91..94349f753d 100644--- a/backend/plugin/advisor/pg/utils.go+++ b/backend/plugin/advisor/pg/utils.go@@ -4,6 +4,7 @@ package pgimport ("fmt"+ storepb "github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/ast")@@ -43,3 +44,13 @@ func normalizeTableName(table *ast.TableDef) string {}return fmt.Sprintf("%q.%q", schema, table.Name)}++// newPositionAtLineStart creates a Position at the start of the given line.+// The line number is used as-is (typically from PostgreSQL parser which uses+// 0-based line numbers), and column is set to 0.+func newPositionAtLineStart(line int) *storepb.Position {+ return &storepb.Position{+ Line: int32(line),+ Column: 0,+ }+}diff --git a/backend/plugin/advisor/tidb/advisor_builtin_prior_backup_check.go b/backend/plugin/advisor/tidb/advisor_builtin_prior_backup_check.goindex 630a304f36..15d056a952 100644--- a/backend/plugin/advisor/tidb/advisor_builtin_prior_backup_check.go+++ b/backend/plugin/advisor/tidb/advisor_builtin_prior_backup_check.go@@ -85,7 +85,7 @@ func (*StatementPriorBackupCheckAdvisor) Check(ctx context.Context, checkCtx advTitle: title,Content: fmt.Sprintf("Need database %q to do prior backup but it does not exist", databaseName),Code: advisor.DatabaseNotExists.Int32(),- StartPosition: common.FirstLinePosition,+ StartPosition: nil,})}@@ -95,7 +95,7 @@ func (*StatementPriorBackupCheckAdvisor) Check(ctx context.Context, checkCtx advTitle: title,Content: fmt.Sprintf("Prior backup is feasible only with up to %d statements that are either UPDATE or DELETE, or if all UPDATEs target the same table with a PRIMARY or UNIQUE KEY in the WHERE clause", maxMixedDMLCount),Code: advisor.BuiltinPriorBackupCheck.Int32(),- StartPosition: common.FirstLinePosition,+ StartPosition: nil,})}diff --git a/backend/plugin/parser/base/diagnose.go b/backend/plugin/parser/base/diagnose.goindex a822b1edd9..e1388c985d 100644--- a/backend/plugin/parser/base/diagnose.go+++ b/backend/plugin/parser/base/diagnose.go@@ -1,9 +1,11 @@package baseimport (+ "strings"+lsp "github.com/bytebase/lsp-protocol"- "github.com/bytebase/bytebase/backend/common"+ storepb "github.com/bytebase/bytebase/backend/generated-go/store")// DiagnosticContext is the context for diagnosing SQL statements.@@ -12,8 +14,45 @@ type DiagnoseContext struct {type Diagnostic = lsp.Diagnostic+// convertPositionToUTF16Position converts a Position to a UTF16Position in a given text.+// If the Position is nil, it returns a UTF16Position with line and character set to 0.+// If the line in Position is out of the end of text, replace it with the last line.+// If the column in Position is out of the end of line, replace it with the last column.+func convertPositionToUTF16Position(p *storepb.Position, text string) *lsp.Position {+ if p == nil {+ return &lsp.Position{+ Line: 0,+ Character: 0,+ }+ }+ lines := strings.Split(text, "\n")+ lineNumber := p.Line+ if lineNumber >= int32(len(lines)) {+ lineNumber = int32(len(lines)) - 1+ }+ u16CodeUnits := 0+ byteOffset := 0+ line := lines[lineNumber]+ for _, r := range line {+ if byteOffset >= int(p.Column) {+ break+ }+ byteOffset += len(string(r))+ u16CodeUnits+++ if r > 0xFFFF {+ // Need surrogate pair.+ u16CodeUnits+++ }+ }++ return &lsp.Position{+ Line: uint32(lineNumber),+ Character: uint32(u16CodeUnits),+ }+}+func ConvertSyntaxErrorToDiagnostic(err *SyntaxError, statement string) Diagnostic {- start := *common.ConvertPositionToUTF16Position(err.Position, statement)+ start := *convertPositionToUTF16Position(err.Position, statement)end := startend.Character++message := err.Messagediff --git a/backend/plugin/parser/base/diagnose_test.go b/backend/plugin/parser/base/diagnose_test.gonew file mode 100644index 0000000000..ab14683145--- /dev/null+++ b/backend/plugin/parser/base/diagnose_test.go@@ -0,0 +1,48 @@+package base++import (+ "testing"++ lsp "github.com/bytebase/lsp-protocol"+ "github.com/stretchr/testify/require"++ storepb "github.com/bytebase/bytebase/backend/generated-go/store"+)++func TestConvertPositionToUTF16Position(t *testing.T) {+ testCases := []struct {+ description string+ text string+ position *storepb.Position+ want *lsp.Position+ }{+ {+ description: "empty text",+ text: "",+ position: &storepb.Position{Line: 0, Column: 0},+ want: &lsp.Position{Line: 0, Character: 0},+ },+ {+ description: "ascii",+ text: "hello, world",+ position: &storepb.Position{Line: 0, Column: 6},+ want: &lsp.Position{Line: 0, Character: 6},+ },+ {+ description: "surrogate pairs",+ // 𝄞 encoded in utf16 with 2 code units, and 4 code units in utf8.+ text: "abc𝄞def",+ position: &storepb.Position{Line: 0, Column: 7},+ want: &lsp.Position{+ Line: 0,+ Character: 5,+ },+ },+ }++ a := require.New(t)+ for _, tc := range testCases {+ got := convertPositionToUTF16Position(tc.position, tc.text)+ a.Equalf(tc.want, got, "Test case: %s", tc.description)+ }+}diff --git a/backend/plugin/parser/bigquery/split.go b/backend/plugin/parser/bigquery/split.goindex 66ddcee031..d14b3efac2 100644--- a/backend/plugin/parser/bigquery/split.go+++ b/backend/plugin/parser/bigquery/split.go@@ -42,7 +42,7 @@ func SplitSQL(statement string) ([]base.SingleSQL, error) {antlrPosition := base.FirstDefaultChannelTokenPosition(buf)sqls = append(sqls, base.SingleSQL{Text: bufStr.String(),- BaseLine: common.ConvertANTLRLineToPositionLine(buf[0].GetLine()),+ BaseLine: buf[0].GetLine() - 1,End: common.ConvertANTLRPositionToPosition(&common.ANTLRPosition{Line: int32(buf[len(buf)-1].GetLine()),Column: int32(buf[len(buf)-1].GetColumn()),diff --git a/backend/plugin/parser/elasticsearch/diagnose.go b/backend/plugin/parser/elasticsearch/diagnose.goindex 45db1bb7ed..1510f8a279 100644--- a/backend/plugin/parser/elasticsearch/diagnose.go+++ b/backend/plugin/parser/elasticsearch/diagnose.go@@ -3,9 +3,6 @@ package elasticsearchimport ("context"- lsp "github.com/bytebase/lsp-protocol"-- "github.com/bytebase/bytebase/backend/common""github.com/bytebase/bytebase/backend/generated-go/store""github.com/bytebase/bytebase/backend/plugin/parser/base")@@ -22,21 +19,7 @@ func Diagnose(_ context.Context, _ base.DiagnoseContext, statement string) ([]ba}for _, err := range parseResult.Errors {if err != nil {- // TODO(zp): unify the position in diagnose.- start := *common.ConvertPositionToUTF16Position(err.Position, statement)- end := start- end.Character++- diagnostics = append(diagnostics, base.Diagnostic{- Range: lsp.Range{- Start: start,- End: end,- },- Severity: lsp.SeverityError,- Source: "Syntax check",- // Use RawMessage which created by antlr runtime, do not need our fine-tuned message- // because we had indicated the error position in the message.- Message: err.Error(),- })+ diagnostics = append(diagnostics, base.ConvertSyntaxErrorToDiagnostic(err, statement))}}diff --git a/backend/plugin/parser/pg/legacy/transform/mysql/transform.go b/backend/plugin/parser/pg/legacy/transform/mysql/transform.godeleted file mode 100644index d35eb88e28..0000000000--- a/backend/plugin/parser/pg/legacy/transform/mysql/transform.go+++ /dev/null@@ -1,591 +0,0 @@-// Package mysql provides the MySQL transformer plugin.-package mysql--import (- "bytes"- "slices"- "strings"-- "github.com/pingcap/tidb/pkg/parser"- "github.com/pingcap/tidb/pkg/parser/ast"- "github.com/pingcap/tidb/pkg/parser/format"- "github.com/pingcap/tidb/pkg/parser/model"- "github.com/pingcap/tidb/pkg/parser/mysql"- "github.com/pkg/errors"-- storepb "github.com/bytebase/bytebase/backend/generated-go/store"- mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql"- tidbparser "github.com/bytebase/bytebase/backend/plugin/parser/tidb"-- "github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/transform"-)--var (- _ transform.SchemaTransformer = (*SchemaTransformer)(nil)-)--func init() {- transform.Register(storepb.Engine_MYSQL, &SchemaTransformer{})- transform.Register(storepb.Engine_TIDB, &SchemaTransformer{})- transform.Register(storepb.Engine_OCEANBASE, &SchemaTransformer{})-}--// SchemaTransformer it the transformer for MySQL dialect.-type SchemaTransformer struct {-}--// Accepted MySQL SDL Format:-// 1. CREATE TABLE statements.-// i. Column define without constraints.-// ii. Primary key, check and foreign key constraints define in table-level.-// 2. CREATE INDEX statements.--type indexInfo struct {- originPos int- missing bool- createIndex *ast.CreateIndexStmt-}--type indexSet map[string]*indexInfo--func newIndexInfo(pos int, createIndex *ast.CreateIndexStmt) *indexInfo {- return &indexInfo{- originPos: pos,- missing: true,- createIndex: createIndex,- }-}--type tableInfo struct {- originPos int- missing bool- createTable *ast.CreateTableStmt- indexSet indexSet-}-type tableSet map[string]*tableInfo--func newTableInfo(pos int, createTable *ast.CreateTableStmt) *tableInfo {- return &tableInfo{- originPos: pos,- missing: true,- createTable: createTable,- indexSet: make(indexSet),- }-}--// Normalize normalizes the schema format. The schema and standard should be SDL format.-func (t *SchemaTransformer) Normalize(schema string, standard string) (string, error) {- var orderedList []ast.Node-- if _, err := t.Check(schema); err != nil {- return "", errors.Wrapf(err, "Schema is not the SDL format")- }- if _, err := t.Check(standard); err != nil {- return "", errors.Wrapf(err, "Standard is not the SDL format")- }- var remainingStatement []string-- // Phase One: build the schema table set.- tableSet := make(tableSet)- list, err := mysqlparser.SplitSQL(schema)- if err != nil {- return "", errors.Wrapf(err, "failed to split SQL")- }-- changeDelimiter := false- for i, stmt := range list {- if mysqlparser.IsDelimiter(stmt.Text) {- delimiter, err := mysqlparser.ExtractDelimiter(stmt.Text)- if err != nil {- return "", errors.Wrapf(err, "failed to extract delimiter from %q", stmt.Text)- }- if delimiter == ";" {- changeDelimiter = false- } else {- changeDelimiter = true- }- remainingStatement = append(remainingStatement, stmt.Text)- continue- }- if changeDelimiter {- // TiDB parser cannot deal with delimiter change.- // So we need to skip the statement if the delimiter is not `;`.- remainingStatement = append(remainingStatement, stmt.Text)- continue- }- if tidbparser.IsTiDBUnsupportDDLStmt(stmt.Text) {- remainingStatement = append(remainingStatement, stmt.Text)- continue- }- nodeList, _, err := parser.New().Parse(stmt.Text, "", "")- if err != nil {- return "", errors.Wrapf(err, "failed to parse schema %q", schema)- }- if len(nodeList) == 0 {- continue- }- if len(nodeList) > 1 {- return "", errors.Errorf("Expect one statement after splitting but found %d, text %q", len(nodeList), stmt.Text)- }-- switch node := nodeList[0].(type) {- case *ast.CreateTableStmt:- tableSet[node.Table.Name.String()] = newTableInfo(i, node)- case *ast.CreateIndexStmt:- table, exists := tableSet[node.Table.Name.String()]- if !exists {- return "", errors.Errorf("Table `%s` not found", node.Table.Name.String())- }- table.indexSet[node.IndexName] = newIndexInfo(i, node)- default:- remainingStatement = append(remainingStatement, stmt.Text)- }- }-- // Phase Two: find the missing table and index for schema and remove the collation and charset if needed.- standardList, err := mysqlparser.SplitSQL(standard)- if err != nil {- return "", errors.Wrapf(err, "failed to split SQL")- }-- for _, stmt := range standardList {- if tidbparser.IsTiDBUnsupportDDLStmt(stmt.Text) {- // TODO(rebelice): consider the unsupported DDL.- continue- }- nodeList, _, err := parser.New().Parse(stmt.Text, "", "")- if err != nil {- return "", errors.Wrapf(err, "failed to parse schema %q", schema)- }- if len(nodeList) == 0 {- continue- }- if len(nodeList) > 1 {- return "", errors.Errorf("Expect one statement after splitting but found %d, text %q", len(nodeList), stmt.Text)- }-- switch node := nodeList[0].(type) {- case *ast.CreateTableStmt:- if table, exists := tableSet[node.Table.Name.String()]; exists {- table.missing = false- removeRedundantTableOption(table.createTable, node)- removeRedundantColumnOption(table.createTable, node)- }- case *ast.CreateIndexStmt:- if table, exists := tableSet[node.Table.Name.String()]; exists {- if index, exists := table.indexSet[node.IndexName]; exists {- index.missing = false- }- }- default:- remainingStatement = append(remainingStatement, stmt.Text)- }- }-- // Phase Three: generate ordered statements.- // The order rule is:- // 1. existed tables are on top of missing tables.- // 2. existed tables and indexes are ordered as the table order in the standard schema.- // 3. missing indexes for existed table are below of this table and as the origin order.- // 4. missing tables are below of existed tables and as the origin order.- for _, stmt := range standardList {- if tidbparser.IsTiDBUnsupportDDLStmt(stmt.Text) {- // TODO(rebelice): consider the unsupported DDL.- continue- }- nodeList, _, err := parser.New().Parse(stmt.Text, "", "")- if err != nil {- return "", errors.Wrapf(err, "failed to parse schema %q", schema)- }- if len(nodeList) == 0 {- continue- }- if len(nodeList) > 1 {- return "", errors.Errorf("Expect one statement after splitting but found %d, text %q", len(nodeList), stmt.Text)- }-- switch node := nodeList[0].(type) {- case *ast.CreateTableStmt:- if table, exists := tableSet[node.Table.Name.String()]; exists {- orderedList = append(orderedList, table.createTable)- var missingIndexList []*indexInfo- for _, index := range table.indexSet {- if index.missing {- missingIndexList = append(missingIndexList, index)- }- }- slices.SortFunc(missingIndexList, func(a, b *indexInfo) int {- if a.originPos < b.originPos {- return -1- }- if a.originPos > b.originPos {- return 1- }- return 0- })- for _, index := range missingIndexList {- orderedList = append(orderedList, index.createIndex)- }- }- case *ast.CreateIndexStmt:- if table, exists := tableSet[node.Table.Name.String()]; exists {- if index, exists := table.indexSet[node.IndexName]; exists {- orderedList = append(orderedList, index.createIndex)- }- }- default:- remainingStatement = append(remainingStatement, stmt.Text)- }- }-- var missingTableList []*tableInfo- for _, table := range tableSet {- if table.missing {- missingTableList = append(missingTableList, table)- }- }- slices.SortFunc(missingTableList, func(a, b *tableInfo) int {- if a.originPos < b.originPos {- return -1- }- if a.originPos > b.originPos {- return 1- }- return 0- })- for _, table := range missingTableList {- orderedList = append(orderedList, table.createTable)- var missingIndexList []*indexInfo- for _, index := range table.indexSet {- if index.missing {- missingIndexList = append(missingIndexList, index)- }- }- slices.SortFunc(missingIndexList, func(a, b *indexInfo) int {- if a.originPos < b.originPos {- return -1- }- if a.originPos > b.originPos {- return 1- }- return 0- })- for _, index := range missingIndexList {- orderedList = append(orderedList, index.createIndex)- }- }-- orderedSDL, err := deparse(orderedList)- if err != nil {- return "", err- }- remainingStatement = append([]string{orderedSDL}, remainingStatement...)- return strings.Join(remainingStatement, ""), nil-}--func removeRedundantColumnOption(table *ast.CreateTableStmt, standard *ast.CreateTableStmt) {- columnSet := make(map[string]*ast.ColumnDef)- for _, column := range standard.Cols {- columnSet[column.Name.Name.O] = column- }-- for _, column := range table.Cols {- var newOptionList []*ast.ColumnOption- if standardColumn, exists := columnSet[column.Name.Name.O]; exists {- for _, option := range column.Options {- if option.Tp == ast.ColumnOptionCollate {- standardCollate := extractColumnCollate(standardColumn.Options)- if standardCollate == nil {- continue- }- } else if option.Tp == ast.ColumnOptionDefaultValue {- standardDefault := extractColumnDefault(standardColumn.Options)- if standardDefault == nil && option.Expr.GetType().GetType() == mysql.TypeNull {- continue- }- }- newOptionList = append(newOptionList, option)- }- }- column.Options = newOptionList- }-}--func extractColumnCollate(list []*ast.ColumnOption) *ast.ColumnOption {- for _, option := range list {- if option.Tp == ast.ColumnOptionCollate {- return option- }- }- return nil-}--func extractColumnDefault(list []*ast.ColumnOption) *ast.ColumnOption {- for _, option := range list {- if option.Tp == ast.ColumnOptionDefaultValue {- return option- }- }- return nil-}--func removeRedundantTableOption(table *ast.CreateTableStmt, standard *ast.CreateTableStmt) {- engine, charset, collation := extractEngineCharsetAndCollation(standard)- var newOptionList []*ast.TableOption- for _, option := range table.Options {- switch option.Tp {- case ast.TableOptionEngine:- if engine == nil {- continue- }- case ast.TableOptionCharset:- if charset == nil {- continue- }- case ast.TableOptionCollate:- if collation == nil {- continue- }- default:- // Keep other table options as-is- }- newOptionList = append(newOptionList, option)- }- table.Options = newOptionList-}--func extractEngineCharsetAndCollation(table *ast.CreateTableStmt) (engine, charset, collation *ast.TableOption) {- for _, option := range table.Options {- switch option.Tp {- case ast.TableOptionEngine:- engine = option- case ast.TableOptionCharset:- charset = option- case ast.TableOptionCollate:- collation = option- default:- // Ignore other table options- }- }- return engine, charset, collation-}--// Check checks the schema format.-func (*SchemaTransformer) Check(schema string) (int, error) {- list, err := mysqlparser.SplitSQL(schema)- if err != nil {- return 0, errors.Wrapf(err, "failed to split SQL")- }-- changeDelimiter := false- for _, stmt := range list {- if mysqlparser.IsDelimiter(stmt.Text) {- delimiter, err := mysqlparser.ExtractDelimiter(stmt.Text)- if err != nil {- return 0, errors.Wrapf(err, "failed to extract delimiter from %q", stmt.Text)- }- if delimiter == ";" {- changeDelimiter = false- } else {- changeDelimiter = true- }- continue- }- if changeDelimiter {- // TiDB parser cannot deal with delimiter change.- // So we need to skip the statement if the delimiter is not `;`.- continue- }- if tidbparser.IsTiDBUnsupportDDLStmt(stmt.Text) {- continue- }- nodeList, _, err := parser.New().Parse(stmt.Text, "", "")- if err != nil {- return int(stmt.End.GetLine()), errors.Wrapf(err, "failed to parse schema %q", schema)- }- if len(nodeList) == 0 {- continue- }- if len(nodeList) > 1 {- return int(stmt.End.GetLine()), errors.Errorf("Expect one statement after splitting but found %d, text %q", len(nodeList), stmt.Text)- }-- switch node := nodeList[0].(type) {- case *ast.CreateTableStmt:- for _, column := range node.Cols {- for _, option := range column.Options {- switch option.Tp {- case ast.ColumnOptionNoOption,- ast.ColumnOptionNotNull,- ast.ColumnOptionAutoIncrement,- ast.ColumnOptionDefaultValue,- ast.ColumnOptionNull,- ast.ColumnOptionOnUpdate,- ast.ColumnOptionFulltext,- ast.ColumnOptionComment,- ast.ColumnOptionGenerated,- ast.ColumnOptionCollate,- ast.ColumnOptionColumnFormat,- ast.ColumnOptionStorage,- ast.ColumnOptionAutoRandom:- case ast.ColumnOptionPrimaryKey:- return int(stmt.End.GetLine()), errors.Errorf("The column-level primary key constraint is invalid SDL format. Please use table-level primary key, such as \"CREATE TABLE t(id INT, PRIMARY KEY (id));\"")- case ast.ColumnOptionUniqKey:- return int(stmt.End.GetLine()), errors.Errorf("The column-level unique key constraint is invalid SDL format. Please use table-level unique key, such as \"CREATE TABLE t(id INT, UNIQUE KEY uk_t_id (id));\"")- case ast.ColumnOptionCheck:- return int(stmt.End.GetLine()), errors.Errorf("The column-level check constraint is invalid SDL format. Please use table-level check constraints, such as \"CREATE TABLE t(id INT, CONSTRAINT ck_t CHECK (id > 0));\"")- case ast.ColumnOptionReference:- return int(stmt.End.GetLine()), errors.Errorf("The column-level foreign key constraint is invalid SDL format. Please use table-level foreign key constraints, such as \"CREATE TABLE t(id INT, CONSTRAINT fk_t_id FOREIGN KEY (id) REFERENCES t1(c1));\"")- default:- // Ignore other column options- }- }- }- for _, constraint := range node.Constraints {- switch constraint.Tp {- case ast.ConstraintKey, ast.ConstraintIndex:- return int(stmt.End.GetLine()), errors.Errorf("The index/key define in CREATE TABLE statements is invalid SDL format. Please use CREATE INDEX statements, such as \"CREATE INDEX idx_t_id ON t(id);\"")- case ast.ConstraintUniq, ast.ConstraintUniqKey, ast.ConstraintUniqIndex:- return int(stmt.End.GetLine()), errors.Errorf("The unique constraint in CREATE TABLE statements is invalid SDL format. Please use CREATE UNIQUE INDEX statements, such as \"CREATE UNIQUE INDEX uk_t_id ON t(id);\"")- case ast.ConstraintFulltext:- return int(stmt.End.GetLine()), errors.Errorf("The fulltext constraint in CREATE TABLE statements is invalid SDL format. Please use CREATE FULLTEXT INDEX statements, such as \"CREATE UNIQUE INDEX fdx_t_id ON t(id);\"")- case ast.ConstraintCheck, ast.ConstraintForeignKey:- if constraint.Name == "" {- return int(stmt.End.GetLine()), errors.Errorf("The constraint name is required for SDL format")- }- default:- // Other constraint types- }- }- if node.Partition != nil {- return int(stmt.End.GetLine()), errors.Errorf("The SDL does not support partition table currently")- }- case *ast.CreateIndexStmt:- default:- return int(stmt.End.GetLine()), errors.Errorf("%T is invalid SDL statement", node)- }- }- return 0, nil-}--// Transform returns the transformed schema.-func (*SchemaTransformer) Transform(schema string) (string, error) {- var result []string- list, err := mysqlparser.SplitSQL(schema)- if err != nil {- return "", errors.Wrapf(err, "failed to split SQL")- }-- changeDelimiter := false- for _, stmt := range list {- if mysqlparser.IsDelimiter(stmt.Text) {- delimiter, err := mysqlparser.ExtractDelimiter(stmt.Text)- if err != nil {- return "", errors.Wrapf(err, "failed to extract delimiter from %q", stmt.Text)- }- if delimiter == ";" {- changeDelimiter = false- } else {- changeDelimiter = true- }- result = append(result, stmt.Text+"\n\n")- continue- }- if changeDelimiter {- // TiDB parser cannot deal with delimiter change.- // So we need to skip the statement if the delimiter is not `;`.- result = append(result, stmt.Text+"\n\n")- continue- }- if tidbparser.IsTiDBUnsupportDDLStmt(stmt.Text) {- result = append(result, stmt.Text+"\n\n")- continue- }- nodeList, _, err := parser.New().Parse(stmt.Text, "", "")- if err != nil {- // If the TiDB parser cannot parse the statement, we just skip it.- result = append(result, stmt.Text+"\n\n")- continue- }- if len(nodeList) == 0 {- continue- }- if len(nodeList) > 1 {- return "", errors.Errorf("Expect one statement after splitting but found %d, text %q", len(nodeList), stmt.Text)- }-- switch node := nodeList[0].(type) {- case *ast.CreateTableStmt:- var constraintList []*ast.Constraint- var indexList []*ast.CreateIndexStmt- for _, constraint := range node.Constraints {- switch constraint.Tp {- case ast.ConstraintUniq, ast.ConstraintUniqKey, ast.ConstraintUniqIndex:- // This becomes the unique index.- indexOption := constraint.Option- if indexOption == nil {- indexOption = &ast.IndexOption{}- }- indexList = append(indexList, &ast.CreateIndexStmt{- IndexName: constraint.Name,- Table: &ast.TableName{- Name: model.NewCIStr(node.Table.Name.O),- },- IndexPartSpecifications: constraint.Keys,- IndexOption: indexOption,- KeyType: ast.IndexKeyTypeUnique,- })- case ast.ConstraintIndex:- // This becomes the index.- indexOption := constraint.Option- if indexOption == nil {- indexOption = &ast.IndexOption{}- }- indexList = append(indexList, &ast.CreateIndexStmt{- IndexName: constraint.Name,- Table: &ast.TableName{- Name: model.NewCIStr(node.Table.Name.O),- },- IndexPartSpecifications: constraint.Keys,- IndexOption: indexOption,- KeyType: ast.IndexKeyTypeNone,- })- case ast.ConstraintPrimaryKey, ast.ConstraintKey, ast.ConstraintForeignKey, ast.ConstraintFulltext, ast.ConstraintCheck:- constraintList = append(constraintList, constraint)- default:- // Other constraint types- }- }- node.Constraints = constraintList- nodeList := []ast.Node{node}- for _, node := range indexList {- nodeList = append(nodeList, node)- }- text, err := deparse(nodeList)- if err != nil {- return "", errors.Wrapf(err, "failed to deparse %q", stmt.Text)- }- result = append(result, text)- case *ast.SetStmt:- // Skip these spammy set session variable statements.- continue- default:- result = append(result, stmt.Text+"\n\n")- }- }-- return strings.Join(result, ""), nil-}--func deparse(newNodeList []ast.Node) (string, error) {- var buf bytes.Buffer- for _, node := range newNodeList {- if err := node.Restore(format.NewRestoreCtx(format.DefaultRestoreFlags|format.RestoreStringWithoutCharset|format.RestorePrettyFormat, &buf)); err != nil {- return "", err- }- if _, err := buf.WriteString(";\n\n"); err != nil {- return "", err- }- }- return buf.String(), nil-}diff --git a/backend/plugin/parser/pg/legacy/transform/mysql/transform_test.go b/backend/plugin/parser/pg/legacy/transform/mysql/transform_test.godeleted file mode 100644index e9754f33bd..0000000000--- a/backend/plugin/parser/pg/legacy/transform/mysql/transform_test.go+++ /dev/null@@ -1,131 +0,0 @@-package mysql--import (- "testing"-- "github.com/stretchr/testify/require"-)--func TestCreateTableSeparateIndex(t *testing.T) {- input := "" +- "CREATE TABLE `t1` (\n" +- " `id` int DEFAULT NULL,\n" +- " `c1` int DEFAULT NULL,\n" +- " `c2` int DEFAULT NULL,\n" +- " UNIQUE KEY `c1` (`c1`,`c2`),\n" +- " UNIQUE KEY `haha` (`c2`),\n" +- " KEY `t1` (`c1`)\n" +- ") ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_0900_ai_ci;"- want := "CREATE TABLE `t1` (\n" +- " `id` INT DEFAULT NULL,\n" +- " `c1` INT DEFAULT NULL,\n" +- " `c2` INT DEFAULT NULL\n" +- ") ENGINE=InnoDB DEFAULT CHARACTER SET=UTF8MB4 DEFAULT COLLATE=UTF8MB4_0900_AI_CI;\n\n" +- "CREATE UNIQUE INDEX `c1` ON `t1` (`c1`, `c2`);\n\n" +- "CREATE UNIQUE INDEX `haha` ON `t1` (`c2`);\n\n" +- "CREATE INDEX `t1` ON `t1` (`c1`);\n\n"-- a := require.New(t)- mysqlTransformer := &SchemaTransformer{}- got, err := mysqlTransformer.Transform(input)- a.NoError(err)- a.Equal(want, got)-}--func TestTransform(t *testing.T) {- input := `- CREATE TABLE t (- id int NOT NULL,- name varchar(60),- uuid varchar(40),- PRIMARY KEY (id),- KEY idx_name (name)- );-- CREATE PROCEDURE p1()- BEGIN- SELECT * FROM t;- END;`-- want := "CREATE TABLE `t` (" + "\n" +- " `id` INT NOT NULL," + "\n" +- " `name` VARCHAR(60)," + "\n" +- " `uuid` VARCHAR(40)," + "\n" +- " PRIMARY KEY (`id`)" + "\n" +- ");" + "\n" +- "\n" +- "CREATE INDEX `idx_name` ON `t` (`name`);" + "\n" +- "\n\n\t\t\n\t\t" +- "CREATE PROCEDURE p1()" + "\n" +- " BEGIN" + "\n" +- " SELECT * FROM t;" + "\n" +- " END;" + "\n" +- "\n"-- a := require.New(t)- mysqlTransformer := &SchemaTransformer{}- got, err := mysqlTransformer.Transform(input)- a.NoError(err)- a.Equal(want, got)-}--func TestNormalize(t *testing.T) {- input := `- create table t(a int DEFAULT NULL, b varchar(20) COLLATE utf8mb4_general_ci) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;- create index idx_a on t(a);- create unique index uk_t_a on t(a);- create index idx_xxx on t(a);- create table t2(a int) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;- create table t3(a int);- `- standard := `- create table t4(a int);- create table t2(a int) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;- create table t(a int, b varchar(20));- create unique index uk_t_a on t(a);- create index idx_a on t(a);- create index idx_yyy on t(a);- `- want := "" +- "CREATE TABLE `t2` (\n" +- " `a` INT\n" +- ") ENGINE=InnoDB DEFAULT CHARACTER SET=UTF8MB4 DEFAULT COLLATE=UTF8MB4_GENERAL_CI;\n\n" +- "CREATE TABLE `t` (\n" +- " `a` INT,\n" +- " `b` VARCHAR(20)\n" +- ");\n\n" +- "CREATE INDEX `idx_xxx` ON `t` (`a`);\n\n" +- "CREATE UNIQUE INDEX `uk_t_a` ON `t` (`a`);\n\n" +- "CREATE INDEX `idx_a` ON `t` (`a`);\n\n" +- "CREATE TABLE `t3` (\n" +- " `a` INT\n" +- ");\n\n"- a := require.New(t)- mysqlTransformer := &SchemaTransformer{}- got, err := mysqlTransformer.Normalize(input, standard)- a.NoError(err)- a.Equal(want, got)-}--func TestCheck(t *testing.T) {- type testData struct {- input string- err string- }- tests := []testData{- {- input: `create table t(a int, FOREIGN KEY (a) references t1(a));`,- err: "The constraint name is required for SDL format",- },- {- input: `create table t(a int, CHECK (a > 0));`,- err: "The constraint name is required for SDL format",- },- }- a := require.New(t)- mysqlTransformer := &SchemaTransformer{}- for _, test := range tests {- _, err := mysqlTransformer.Check(test.input)- a.Equal(test.err, err.Error())- }-}diff --git a/backend/plugin/parser/pg/legacy/transform/transform.go b/backend/plugin/parser/pg/legacy/transform/transform.godeleted file mode 100644index 83c97c678a..0000000000--- a/backend/plugin/parser/pg/legacy/transform/transform.go+++ /dev/null@@ -1,71 +0,0 @@-// Package transform provides the schema transformation plugin.-package transform--import (- "fmt"- "sync"-- "github.com/pkg/errors"-- storepb "github.com/bytebase/bytebase/backend/generated-go/store"-)--// SchemaTransformer is the interface for schema SDL format transformer.-type SchemaTransformer interface {- Transform(schema string) (string, error)- Check(schema string) (int, error)- Normalize(schema string, standard string) (string, error)-}--var (- transformMu sync.RWMutex- transformers = make(map[storepb.Engine]SchemaTransformer)-)--// Register makes a schema transformer available by the provided id.-// If Register is called twice with the same name or if transformer is nil,-// it panics.-func Register(engineType storepb.Engine, t SchemaTransformer) {- if t == nil {- panic("parser: Register parser is nil")- }- transformMu.Lock()- defer transformMu.Unlock()- if _, dup := transformers[engineType]; dup {- panic(fmt.Sprintf("parser: Register called twice for schema transformer %s", engineType))- }- transformers[engineType] = t-}--// SchemaTransform returns the transformed schema(SDL format).-func SchemaTransform(engineType storepb.Engine, schema string) (string, error) {- transformMu.RLock()- p, ok := transformers[engineType]- transformMu.RUnlock()- if !ok {- return "", errors.Errorf("engine: unknown engine type %v", engineType)- }- return p.Transform(schema)-}--// CheckFormat checks the schema format.-func CheckFormat(engineType storepb.Engine, schema string) (int, error) {- transformMu.RLock()- p, ok := transformers[engineType]- transformMu.RUnlock()- if !ok {- return 0, errors.Errorf("engine: unknown engine type %v", engineType)- }- return p.Check(schema)-}--// Normalize normalizes the schema format. The schema and standard should be SDL format.-func Normalize(engineType storepb.Engine, schema string, standard string) (string, error) {- transformMu.RLock()- p, ok := transformers[engineType]- transformMu.RUnlock()- if !ok {- return "", errors.Errorf("engine: unknown engine type %v", engineType)- }- return p.Normalize(schema, standard)-}diff --git a/backend/server/ultimate.go b/backend/server/ultimate.goindex bd1fbae2a4..fd273ee599 100644--- a/backend/server/ultimate.go+++ b/backend/server/ultimate.go@@ -61,9 +61,6 @@ import (_ "github.com/bytebase/bytebase/backend/plugin/schema/tidb"_ "github.com/bytebase/bytebase/backend/plugin/schema/trino"- // Transformers.- _ "github.com/bytebase/bytebase/backend/plugin/parser/pg/legacy/transform/mysql"-// IM webhooks._ "github.com/bytebase/bytebase/backend/plugin/webhook/dingtalk"_ "github.com/bytebase/bytebase/backend/plugin/webhook/feishu"diff --git a/backend/tests/schema_update_test.go b/backend/tests/schema_update_test.goindex 13d1e470af..94b025a193 100644--- a/backend/tests/schema_update_test.go+++ b/backend/tests/schema_update_test.go@@ -136,7 +136,6 @@ func TestGetLatestSchema(t *testing.T) {databaseName stringddl stringwantRawSchema string- wantSDL stringwantDatabaseMetadata *v1pb.DatabaseMetadata}{{@@ -156,10 +155,6 @@ func TestGetLatestSchema(t *testing.T) {") ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;\n\n" +"SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS;\n" +"SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS;\n",- wantSDL: "CREATE TABLE `book` (\n" +- " `id` INT DEFAULT NULL,\n" +- " `name` TEXT DEFAULT NULL\n" +- ") ENGINE=InnoDB DEFAULT CHARACTER SET=UTF8MB4 DEFAULT COLLATE=UTF8MB4_GENERAL_CI;\n\n",wantDatabaseMetadata: &v1pb.DatabaseMetadata{Name: "instances/latest-schema-mysql/databases/latestSchema/metadata",CharacterSet: "utf8mb4",@@ -225,7 +220,6 @@ CREATE TABLE "public"."book" ();`,- wantSDL: ``,wantDatabaseMetadata: &v1pb.DatabaseMetadata{Name: "instances/latest-schema-postgres/databases/latestSchema/metadata",Owner: "postgres",@@ -339,15 +333,6 @@ CREATE TABLE "public"."book" (a.NoError(err)latestSchema := latestSchemaResp.Msga.Equal(test.wantRawSchema, latestSchema.Schema)- if test.dbType == storepb.Engine_MYSQL {- latestSchemaSDLResp, err := ctl.databaseServiceClient.GetDatabaseSchema(ctx, connect.NewRequest(&v1pb.GetDatabaseSchemaRequest{- Name: fmt.Sprintf("%s/schema", database.Name),- SdlFormat: true,- }))- a.NoError(err)- latestSchemaSDL := latestSchemaSDLResp.Msg- a.Equal(test.wantSDL, latestSchemaSDL.Schema)- }latestSchemaMetadataResp, err := ctl.databaseServiceClient.GetDatabaseMetadata(ctx, connect.NewRequest(&v1pb.GetDatabaseMetadataRequest{Name: fmt.Sprintf("%s/metadata", database.Name),}))diff --git a/frontend/src/components/SyncDatabaseSchemaV1/SelectTargetDatabasesView.vue b/frontend/src/components/SyncDatabaseSchemaV1/SelectTargetDatabasesView.vueindex 7a67a7b0c2..0f04806e8e 100644--- a/frontend/src/components/SyncDatabaseSchemaV1/SelectTargetDatabasesView.vue+++ b/frontend/src/components/SyncDatabaseSchemaV1/SelectTargetDatabasesView.vue@@ -315,10 +315,7 @@ watch(continue;}const db = databaseStore.getDatabaseByName(name);- const schema = await databaseStore.fetchDatabaseSchema(- db.name,- false /* sdlFormat */- );+ const schema = await databaseStore.fetchDatabaseSchema(db.name);databaseSchemaCache.value[name] = schema.schema;if (schemaDiffCache.value[name]) {continue;@@ -331,7 +328,6 @@ watch(case: "changelog",value: props.changelogSourceSchema.changelogName,},- sdlFormat: false,}): create(DiffSchemaRequestSchema, {name: db.name,@@ -339,7 +335,6 @@ watch(case: "schema",value: props.sourceSchemaString,},- sdlFormat: false,});const diffResp = await databaseStore.diffSchema(diffRequest);diff --git a/frontend/src/store/modules/v1/changelog.ts b/frontend/src/store/modules/v1/changelog.tsindex c7e78d68a5..b625cbd32d 100644--- a/frontend/src/store/modules/v1/changelog.ts+++ b/frontend/src/store/modules/v1/changelog.ts@@ -78,7 +78,6 @@ export const useChangelogStore = defineStore("changelog", () => {const request = create(GetChangelogRequestSchema, {name: params.name,view: params.view,- sdlFormat: params.sdlFormat,});const changelog = await databaseServiceClientConnect.getChangelog(request);cache.setEntity(diff --git a/frontend/src/store/modules/v1/database.ts b/frontend/src/store/modules/v1/database.tsindex 5abcb4f7c4..f6ee3d542f 100644--- a/frontend/src/store/modules/v1/database.ts+++ b/frontend/src/store/modules/v1/database.ts@@ -333,10 +333,9 @@ export const useDatabaseV1Store = defineStore("database_v1", () => {const [composed] = await upsertDatabaseMap([updated]);return composed;};- const fetchDatabaseSchema = async (database: string, sdlFormat = false) => {+ const fetchDatabaseSchema = async (database: string) => {const request = create(GetDatabaseSchemaRequestSchema, {name: `${database}/schema`,- sdlFormat,});const schema =await databaseServiceClientConnect.getDatabaseSchema(request);diff --git a/frontend/src/types/proto-es/v1/database_service_pb.d.ts b/frontend/src/types/proto-es/v1/database_service_pb.d.tsindex 3a3fd330e6..c292b0ae06 100644--- a/frontend/src/types/proto-es/v1/database_service_pb.d.ts+++ b/frontend/src/types/proto-es/v1/database_service_pb.d.ts@@ -404,13 +404,6 @@ export declare type GetDatabaseSchemaRequest = Message<"bytebase.v1.GetDatabaseS* @generated from field: string name = 1;*/name: string;-- /**- * Format the schema dump into SDL format.- *- * @generated from field: bool sdl_format = 2;- */- sdlFormat: boolean;};/**@@ -455,13 +448,6 @@ export declare type DiffSchemaRequest = Message<"bytebase.v1.DiffSchemaRequest">value: string;case: "changelog";} | { case: undefined; value?: undefined };-- /**- * Format the schema dump into SDL format.- *- * @generated from field: bool sdl_format = 4;- */- sdlFormat: boolean;};/**@@ -3120,13 +3106,6 @@ export declare type GetChangelogRequest = Message<"bytebase.v1.GetChangelogReque* @generated from field: bytebase.v1.ChangelogView view = 2;*/view: ChangelogView;-- /**- * Format the schema dump into SDL format.- *- * @generated from field: bool sdl_format = 3;- */- sdlFormat: boolean;};/**diff --git a/frontend/src/types/proto-es/v1/database_service_pb.js b/frontend/src/types/proto-es/v1/database_service_pb.jsindex e318450828..390cecc06f 100644--- a/frontend/src/types/proto-es/v1/database_service_pb.js+++ b/frontend/src/types/proto-es/v1/database_service_pb.js@@ -16,7 +16,7 @@ import { file_v1_instance_service } from "./instance_service_pb";* Describes the file v1/database_service.proto.*/export const file_v1_database_service = /*@__PURE__*/- fileDesc("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", [file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_field_mask, file_google_protobuf_timestamp, file_v1_annotation, file_v1_common, file_v1_instance_service]);+ fileDesc("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", [file_google_api_annotations, file_google_api_client, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_field_mask, file_google_protobuf_timestamp, file_v1_annotation, file_v1_common, file_v1_instance_service]);/*** Describes the message bytebase.v1.GetDatabaseRequest.diff --git a/frontend/src/types/proto-es/v1/sql_service_pb.d.ts b/frontend/src/types/proto-es/v1/sql_service_pb.d.tsindex 25624b034d..1a0121e533 100644--- a/frontend/src/types/proto-es/v1/sql_service_pb.d.ts+++ b/frontend/src/types/proto-es/v1/sql_service_pb.d.ts@@ -919,64 +919,6 @@ export declare type ExportResponse = Message<"bytebase.v1.ExportResponse"> & {*/export declare const ExportResponseSchema: GenMessage<ExportResponse>;-/**- * @generated from message bytebase.v1.PrettyRequest- */-export declare type PrettyRequest = Message<"bytebase.v1.PrettyRequest"> & {- /**- * @generated from field: bytebase.v1.Engine engine = 1;- */- engine: Engine;-- /**- * The SDL format SQL schema information that was dumped from a database- * engine. This information will be sorted to match the order of statements in- * the userSchema.- *- * @generated from field: string current_schema = 2;- */- currentSchema: string;-- /**- * The expected SDL schema. This schema will be checked for correctness and- * normalized.- *- * @generated from field: string expected_schema = 3;- */- expectedSchema: string;-};--/**- * Describes the message bytebase.v1.PrettyRequest.- * Use `create(PrettyRequestSchema)` to create a new message.- */-export declare const PrettyRequestSchema: GenMessage<PrettyRequest>;--/**- * @generated from message bytebase.v1.PrettyResponse- */-export declare type PrettyResponse = Message<"bytebase.v1.PrettyResponse"> & {- /**- * The pretty-formatted version of current schema.- *- * @generated from field: string current_schema = 1;- */- currentSchema: string;-- /**- * The expected SDL schema after normalizing.- *- * @generated from field: string expected_schema = 2;- */- expectedSchema: string;-};--/**- * Describes the message bytebase.v1.PrettyResponse.- * Use `create(PrettyResponseSchema)` to create a new message.- */-export declare const PrettyResponseSchema: GenMessage<PrettyResponse>;-/*** @generated from message bytebase.v1.CheckRequest*/@@ -1467,17 +1409,6 @@ export declare const SQLService: GenService<{input: typeof CheckRequestSchema;output: typeof CheckResponseSchema;},- /**- * Formats and normalizes SQL schema definitions.- * Permissions required: None- *- * @generated from rpc bytebase.v1.SQLService.Pretty- */- pretty: {- methodKind: "unary";- input: typeof PrettyRequestSchema;- output: typeof PrettyResponseSchema;- },/*** Computes schema differences between two database metadata.* Permissions required: Nonediff --git a/frontend/src/types/proto-es/v1/sql_service_pb.js b/frontend/src/types/proto-es/v1/sql_service_pb.jsindex 3490d6d96e..06cb21b46e 100644--- a/frontend/src/types/proto-es/v1/sql_service_pb.js+++ b/frontend/src/types/proto-es/v1/sql_service_pb.js@@ -16,7 +16,7 @@ import { file_v1_database_service } from "./database_service_pb";* Describes the file v1/sql_service.proto.*/export const file_v1_sql_service = /*@__PURE__*/- fileDesc("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", [file_google_api_annotations, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_duration, file_google_protobuf_struct, file_google_protobuf_timestamp, file_v1_annotation, file_v1_common, file_v1_database_catalog_service, file_v1_database_service]);+ fileDesc("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", [file_google_api_annotations, file_google_api_field_behavior, file_google_api_resource, file_google_protobuf_duration, file_google_protobuf_struct, file_google_protobuf_timestamp, file_v1_annotation, file_v1_common, file_v1_database_catalog_service, file_v1_database_service]);/*** Describes the message bytebase.v1.AdminExecuteRequest.@@ -168,32 +168,18 @@ export const ExportRequestSchema = /*@__PURE__*/export const ExportResponseSchema = /*@__PURE__*/messageDesc(file_v1_sql_service, 11);-/**- * Describes the message bytebase.v1.PrettyRequest.- * Use `create(PrettyRequestSchema)` to create a new message.- */-export const PrettyRequestSchema = /*@__PURE__*/- messageDesc(file_v1_sql_service, 12);--/**- * Describes the message bytebase.v1.PrettyResponse.- * Use `create(PrettyResponseSchema)` to create a new message.- */-export const PrettyResponseSchema = /*@__PURE__*/- messageDesc(file_v1_sql_service, 13);-/*** Describes the message bytebase.v1.CheckRequest.* Use `create(CheckRequestSchema)` to create a new message.*/export const CheckRequestSchema = /*@__PURE__*/- messageDesc(file_v1_sql_service, 14);+ messageDesc(file_v1_sql_service, 12);/*** Describes the enum bytebase.v1.CheckRequest.ChangeType.*/export const CheckRequest_ChangeTypeSchema = /*@__PURE__*/- enumDesc(file_v1_sql_service, 14, 0);+ enumDesc(file_v1_sql_service, 12, 0);/*** @generated from enum bytebase.v1.CheckRequest.ChangeType@@ -206,48 +192,48 @@ export const CheckRequest_ChangeType = /*@__PURE__*/* Use `create(CheckResponseSchema)` to create a new message.*/export const CheckResponseSchema = /*@__PURE__*/- messageDesc(file_v1_sql_service, 15);+ messageDesc(file_v1_sql_service, 13);/*** Describes the message bytebase.v1.DiffMetadataRequest.* Use `create(DiffMetadataRequestSchema)` to create a new message.*/export const DiffMetadataRequestSchema = /*@__PURE__*/- messageDesc(file_v1_sql_service, 16);+ messageDesc(file_v1_sql_service, 14);/*** Describes the message bytebase.v1.DiffMetadataResponse.* Use `create(DiffMetadataResponseSchema)` to create a new message.*/export const DiffMetadataResponseSchema = /*@__PURE__*/- messageDesc(file_v1_sql_service, 17);+ messageDesc(file_v1_sql_service, 15);/*** Describes the message bytebase.v1.SearchQueryHistoriesRequest.* Use `create(SearchQueryHistoriesRequestSchema)` to create a new message.*/export const SearchQueryHistoriesRequestSchema = /*@__PURE__*/- messageDesc(file_v1_sql_service, 18);+ messageDesc(file_v1_sql_service, 16);/*** Describes the message bytebase.v1.SearchQueryHistoriesResponse.* Use `create(SearchQueryHistoriesResponseSchema)` to create a new message.*/export const SearchQueryHistoriesResponseSchema = /*@__PURE__*/- messageDesc(file_v1_sql_service, 19);+ messageDesc(file_v1_sql_service, 17);/*** Describes the message bytebase.v1.QueryHistory.* Use `create(QueryHistorySchema)` to create a new message.*/export const QueryHistorySchema = /*@__PURE__*/- messageDesc(file_v1_sql_service, 20);+ messageDesc(file_v1_sql_service, 18);/*** Describes the enum bytebase.v1.QueryHistory.Type.*/export const QueryHistory_TypeSchema = /*@__PURE__*/- enumDesc(file_v1_sql_service, 20, 0);+ enumDesc(file_v1_sql_service, 18, 0);/*** @generated from enum bytebase.v1.QueryHistory.Type@@ -260,42 +246,42 @@ export const QueryHistory_Type = /*@__PURE__*/* Use `create(AICompletionRequestSchema)` to create a new message.*/export const AICompletionRequestSchema = /*@__PURE__*/- messageDesc(file_v1_sql_service, 21);+ messageDesc(file_v1_sql_service, 19);/*** Describes the message bytebase.v1.AICompletionRequest.Message.* Use `create(AICompletionRequest_MessageSchema)` to create a new message.*/export const AICompletionRequest_MessageSchema = /*@__PURE__*/- messageDesc(file_v1_sql_service, 21, 0);+ messageDesc(file_v1_sql_service, 19, 0);/*** Describes the message bytebase.v1.AICompletionResponse.* Use `create(AICompletionResponseSchema)` to create a new message.*/export const AICompletionResponseSchema = /*@__PURE__*/- messageDesc(file_v1_sql_service, 22);+ messageDesc(file_v1_sql_service, 20);/*** Describes the message bytebase.v1.AICompletionResponse.Candidate.* Use `create(AICompletionResponse_CandidateSchema)` to create a new message.*/export const AICompletionResponse_CandidateSchema = /*@__PURE__*/- messageDesc(file_v1_sql_service, 22, 0);+ messageDesc(file_v1_sql_service, 20, 0);/*** Describes the message bytebase.v1.AICompletionResponse.Candidate.Content.* Use `create(AICompletionResponse_Candidate_ContentSchema)` to create a new message.*/export const AICompletionResponse_Candidate_ContentSchema = /*@__PURE__*/- messageDesc(file_v1_sql_service, 22, 0, 0);+ messageDesc(file_v1_sql_service, 20, 0, 0);/*** Describes the message bytebase.v1.AICompletionResponse.Candidate.Content.Part.* Use `create(AICompletionResponse_Candidate_Content_PartSchema)` to create a new message.*/export const AICompletionResponse_Candidate_Content_PartSchema = /*@__PURE__*/- messageDesc(file_v1_sql_service, 22, 0, 0, 0);+ messageDesc(file_v1_sql_service, 20, 0, 0, 0);/*** SQLService executes SQL queries and manages query operations.diff --git a/proto/gen/grpc-doc/openapi.yaml b/proto/gen/grpc-doc/openapi.yamlindex 95a5c60200..0e878049b7 100644--- a/proto/gen/grpc-doc/openapi.yaml+++ b/proto/gen/grpc-doc/openapi.yaml@@ -1619,11 +1619,6 @@ paths:- CHANGELOG_VIEW_FULLtype: stringformat: enum- - name: sdlFormat- in: query- description: Format the schema dump into SDL format.- schema:- type: booleanresponses:"200":description: OK@@ -2242,11 +2237,6 @@ paths:required: trueschema:type: string- - name: sdlFormat- in: query- description: Format the schema dump into SDL format.- schema:- type: booleanresponses:"200":description: OK@@ -7637,33 +7627,6 @@ paths:application/json:schema:$ref: '#/components/schemas/Status'- /v1/sql/pretty:- post:- tags:- - SQLService- description: |-- Formats and normalizes SQL schema definitions.- Permissions required: None- operationId: SQLService_Pretty- requestBody:- content:- application/json:- schema:- $ref: '#/components/schemas/PrettyRequest'- required: true- responses:- "200":- description: OK- content:- application/json:- schema:- $ref: '#/components/schemas/PrettyResponse'- default:- description: Default error response- content:- application/json:- schema:- $ref: '#/components/schemas/Status'/v1/subscription:get:tags:@@ -10426,9 +10389,6 @@ components:The resource name of the changelogFormat:instances/{instance}/databases/{database}/changelogs/{changelog}- sdlFormat:- type: boolean- description: Format the schema dump into SDL format.DiffSchemaResponse:type: objectproperties:@@ -12525,59 +12485,6 @@ components:description: When the current query started.format: date-timedescription: PostgreSQL session information read from `pg_stat_activity`.- PrettyRequest:- type: object- properties:- engine:- enum:- - ENGINE_UNSPECIFIED- - CLICKHOUSE- - MYSQL- - POSTGRES- - SNOWFLAKE- - SQLITE- - TIDB- - MONGODB- - REDIS- - ORACLE- - SPANNER- - MSSQL- - REDSHIFT- - MARIADB- - OCEANBASE- - STARROCKS- - DORIS- - HIVE- - ELASTICSEARCH- - BIGQUERY- - DYNAMODB- - DATABRICKS- - COCKROACHDB- - COSMOSDB- - TRINO- - CASSANDRA- type: string- format: enum- currentSchema:- type: string- description: |-- The SDL format SQL schema information that was dumped from a database- engine. This information will be sorted to match the order of statements in- the userSchema.- expectedSchema:- type: string- description: |-- The expected SDL schema. This schema will be checked for correctness and- normalized.- PrettyResponse:- type: object- properties:- currentSchema:- type: string- description: The pretty-formatted version of current schema.- expectedSchema:- type: string- description: The expected SDL schema after normalizing.PreviewRolloutRequest:required:- projectdiff --git a/proto/gen/grpc-doc/v1/README.md b/proto/gen/grpc-doc/v1/README.mdindex 8be4404821..b729af618c 100644--- a/proto/gen/grpc-doc/v1/README.md+++ b/proto/gen/grpc-doc/v1/README.md@@ -445,8 +445,6 @@- [ExportRequest](#bytebase-v1-ExportRequest)- [ExportResponse](#bytebase-v1-ExportResponse)- [MaskingReason](#bytebase-v1-MaskingReason)- - [PrettyRequest](#bytebase-v1-PrettyRequest)- - [PrettyResponse](#bytebase-v1-PrettyResponse)- [QueryHistory](#bytebase-v1-QueryHistory)- [QueryOption](#bytebase-v1-QueryOption)- [QueryRequest](#bytebase-v1-QueryRequest)@@ -2387,7 +2385,6 @@ DependencyColumn is the metadata for dependency columns.| name | [string](#string) | | The name of the database or changelog. Format: database: instances/{instance}/databases/{database} changelog: instances/{instance}/databases/{database}/changelogs/{changelog} || schema | [string](#string) | | The target schema. || changelog | [string](#string) | | The resource name of the changelog Format: instances/{instance}/databases/{database}/changelogs/{changelog} |-| sdl_format | [bool](#bool) | | Format the schema dump into SDL format. |@@ -2592,7 +2589,6 @@ FunctionMetadata is the metadata for functions.| ----- | ---- | ----- | ----------- || name | [string](#string) | | The name of the changelog to retrieve. Format: instances/{instance}/databases/{database}/changelogs/{changelog} || view | [ChangelogView](#bytebase-v1-ChangelogView) | | |-| sdl_format | [bool](#bool) | | Format the schema dump into SDL format. |@@ -2644,7 +2640,6 @@ For example: schema == "schema-a" table == "table-a" table.match| Field | Type | Label | Description || ----- | ---- | ----- | ----------- || name | [string](#string) | | The name of the database to retrieve schema. Format: instances/{instance}/databases/{database}/schema |-| sdl_format | [bool](#bool) | | Format the schema dump into SDL format. |@@ -7434,39 +7429,6 @@ OrgPolicyService manages organizational policies at various resource levels.-<a name="bytebase-v1-PrettyRequest"></a>--### PrettyRequest----| Field | Type | Label | Description |-| ----- | ---- | ----- | ----------- |-| engine | [Engine](#bytebase-v1-Engine) | | |-| current_schema | [string](#string) | | The SDL format SQL schema information that was dumped from a database engine. This information will be sorted to match the order of statements in the userSchema. |-| expected_schema | [string](#string) | | The expected SDL schema. This schema will be checked for correctness and normalized. |-------<a name="bytebase-v1-PrettyResponse"></a>--### PrettyResponse----| Field | Type | Label | Description |-| ----- | ---- | ----- | ----------- |-| current_schema | [string](#string) | | The pretty-formatted version of current schema. |-| expected_schema | [string](#string) | | The expected SDL schema after normalizing. |------<a name="bytebase-v1-QueryHistory"></a>### QueryHistory@@ -7817,7 +7779,6 @@ SQLService executes SQL queries and manages query operations.| SearchQueryHistories | [SearchQueryHistoriesRequest](#bytebase-v1-SearchQueryHistoriesRequest) | [SearchQueryHistoriesResponse](#bytebase-v1-SearchQueryHistoriesResponse) | SearchQueryHistories searches query histories for the caller. Permissions required: None (only returns caller's own query histories) || Export | [ExportRequest](#bytebase-v1-ExportRequest) | [ExportResponse](#bytebase-v1-ExportResponse) | Exports query results to a file format. Permissions required: bb.databases.get || Check | [CheckRequest](#bytebase-v1-CheckRequest) | [CheckResponse](#bytebase-v1-CheckResponse) | Validates SQL statements against review rules. Permissions required: bb.databases.check |-| Pretty | [PrettyRequest](#bytebase-v1-PrettyRequest) | [PrettyResponse](#bytebase-v1-PrettyResponse) | Formats and normalizes SQL schema definitions. Permissions required: None || DiffMetadata | [DiffMetadataRequest](#bytebase-v1-DiffMetadataRequest) | [DiffMetadataResponse](#bytebase-v1-DiffMetadataResponse) | Computes schema differences between two database metadata. Permissions required: None || AICompletion | [AICompletionRequest](#bytebase-v1-AICompletionRequest) | [AICompletionResponse](#bytebase-v1-AICompletionResponse) | Provides AI-powered SQL completion and generation. Permissions required: None (authenticated users only, requires AI to be enabled) |diff --git a/proto/gen/grpc-doc/v1/index.html b/proto/gen/grpc-doc/v1/index.htmlindex 5281ed470f..ac2dacd2ab 100644--- a/proto/gen/grpc-doc/v1/index.html+++ b/proto/gen/grpc-doc/v1/index.html@@ -1879,14 +1879,6 @@<a href="#bytebase.v1.MaskingReason"><span class="badge">M</span>MaskingReason</a></li>- <li>- <a href="#bytebase.v1.PrettyRequest"><span class="badge">M</span>PrettyRequest</a>- </li>-- <li>- <a href="#bytebase.v1.PrettyResponse"><span class="badge">M</span>PrettyResponse</a>- </li>-<li><a href="#bytebase.v1.QueryHistory"><span class="badge">M</span>QueryHistory</a></li>@@ -7315,13 +7307,6 @@ Format:instances/{instance}/databases/{database}/changelogs/{changelog} </p></td></tr>- <tr>- <td>sdl_format</td>- <td><a href="#bool">bool</a></td>- <td></td>- <td><p>Format the schema dump into SDL format. </p></td>- </tr>-</tbody></table>@@ -7866,13 +7851,6 @@ Format: instances/{instance}/databases/{database}/changelogs/{changelog} </p></t<td><p> </p></td></tr>- <tr>- <td>sdl_format</td>- <td><a href="#bool">bool</a></td>- <td></td>- <td><p>Format the schema dump into SDL format. </p></td>- </tr>-</tbody></table>@@ -7978,13 +7956,6 @@ Format: instances/{instance}/databases/{database} </p></td>Format: instances/{instance}/databases/{database}/schema </p></td></tr>- <tr>- <td>sdl_format</td>- <td><a href="#bool">bool</a></td>- <td></td>- <td><p>Format the schema dump into SDL format. </p></td>- </tr>-</tbody></table>@@ -20988,78 +20959,6 @@ Oracle and search path in Postgres. </p></td>- <h3 id="bytebase.v1.PrettyRequest">PrettyRequest</h3>- <p></p>--- <table class="field-table">- <thead>- <tr><td>Field</td><td>Type</td><td>Label</td><td>Description</td></tr>- </thead>- <tbody>-- <tr>- <td>engine</td>- <td><a href="#bytebase.v1.Engine">Engine</a></td>- <td></td>- <td><p> </p></td>- </tr>-- <tr>- <td>current_schema</td>- <td><a href="#string">string</a></td>- <td></td>- <td><p>The SDL format SQL schema information that was dumped from a database-engine. This information will be sorted to match the order of statements in-the userSchema. </p></td>- </tr>-- <tr>- <td>expected_schema</td>- <td><a href="#string">string</a></td>- <td></td>- <td><p>The expected SDL schema. This schema will be checked for correctness and-normalized. </p></td>- </tr>-- </tbody>- </table>------ <h3 id="bytebase.v1.PrettyResponse">PrettyResponse</h3>- <p></p>--- <table class="field-table">- <thead>- <tr><td>Field</td><td>Type</td><td>Label</td><td>Description</td></tr>- </thead>- <tbody>-- <tr>- <td>current_schema</td>- <td><a href="#string">string</a></td>- <td></td>- <td><p>The pretty-formatted version of current schema. </p></td>- </tr>-- <tr>- <td>expected_schema</td>- <td><a href="#string">string</a></td>- <td></td>- <td><p>The expected SDL schema after normalizing. </p></td>- </tr>-- </tbody>- </table>-----<h3 id="bytebase.v1.QueryHistory">QueryHistory</h3><p></p>@@ -22075,14 +21974,6 @@ Permissions required: bb.databases.get</p></td>Permissions required: bb.databases.check</p></td></tr>- <tr>- <td>Pretty</td>- <td><a href="#bytebase.v1.PrettyRequest">PrettyRequest</a></td>- <td><a href="#bytebase.v1.PrettyResponse">PrettyResponse</a></td>- <td><p>Formats and normalizes SQL schema definitions.-Permissions required: None</p></td>- </tr>-<tr><td>DiffMetadata</td><td><a href="#bytebase.v1.DiffMetadataRequest">DiffMetadataRequest</a></td>@@ -22183,16 +22074,6 @@ Permissions required: None (authenticated users only, requires AI to be enabled)- <tr>- <td>Pretty</td>- <td>POST</td>- <td>/v1/sql/pretty</td>- <td>*</td>- </tr>----<tr><td>DiffMetadata</td><td>POST</td>diff --git a/proto/v1/v1/database_service.proto b/proto/v1/v1/database_service.protoindex 1d98736351..4be1dd8c47 100644--- a/proto/v1/v1/database_service.proto+++ b/proto/v1/v1/database_service.proto@@ -356,9 +356,6 @@ message GetDatabaseSchemaRequest {(google.api.field_behavior) = REQUIRED,(google.api.resource_reference) = {type: "bytebase.com/DatabaseSchema"}];-- // Format the schema dump into SDL format.- bool sdl_format = 2;}message DiffSchemaRequest {@@ -380,9 +377,6 @@ message DiffSchemaRequest {// instances/{instance}/databases/{database}/changelogs/{changelog}string changelog = 3;}-- // Format the schema dump into SDL format.- bool sdl_format = 4;}message DiffSchemaResponse {@@ -1442,9 +1436,6 @@ message GetChangelogRequest {];ChangelogView view = 2;-- // Format the schema dump into SDL format.- bool sdl_format = 3;}message Changelog {diff --git a/proto/v1/v1/sql_service.proto b/proto/v1/v1/sql_service.protoindex 0e661c0af1..2e30df4ad6 100644--- a/proto/v1/v1/sql_service.proto+++ b/proto/v1/v1/sql_service.proto@@ -81,16 +81,6 @@ service SQLService {option (bytebase.v1.auth_method) = IAM;}- // Formats and normalizes SQL schema definitions.- // Permissions required: None- rpc Pretty(PrettyRequest) returns (PrettyResponse) {- option (google.api.http) = {- post: "/v1/sql/pretty"- body: "*"- };- option (bytebase.v1.allow_without_credential) = true;- }-// Computes schema differences between two database metadata.// Permissions required: Nonerpc DiffMetadata(DiffMetadataRequest) returns (DiffMetadataResponse) {@@ -431,27 +421,6 @@ message ExportResponse {bytes content = 1;}-message PrettyRequest {- Engine engine = 1;-- // The SDL format SQL schema information that was dumped from a database- // engine. This information will be sorted to match the order of statements in- // the userSchema.- string current_schema = 2;-- // The expected SDL schema. This schema will be checked for correctness and- // normalized.- string expected_schema = 3;-}--message PrettyResponse {- // The pretty-formatted version of current schema.- string current_schema = 1;-- // The expected SDL schema after normalizing.- string expected_schema = 2;-}-message CheckRequest {// The database name to check against.// Format: instances/{instance}/databases/{database}