Skip to content

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

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.go
index 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.Dif
if 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.Dif
databaseSchema, 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.Dif
if 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.go
index 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.go
index 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.go
new file mode 100644
index 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.go
similarity index 100%
rename from backend/api/v1/issue_service_convert.go
rename to backend/api/v1/issue_service_converter.go
diff --git a/backend/api/v1/org_policy_service.go b/backend/api/v1/org_policy_service.go
index 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 *s
return 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.go
new file mode 100644
index 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.go
new file mode 100644
index 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.go
index 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 string
Role string
@@ -1160,131 +1144,6 @@ func (s *ProjectService) TestWebhook(ctx context.Context, req *connect.Request[v
return 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) (*s
return 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.go
new file mode 100644
index 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.go
index 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.TaskRun
for _, taskRun := range taskRuns {
diff --git a/backend/api/v1/setting_service.go b/backend/api/v1/setting_service.go
index 95306fed63..61e949ef8c 100644
--- a/backend/api/v1/setting_service.go
+++ b/backend/api/v1/setting_service.go
@@ -2,7 +2,6 @@ package v1
import (
"context"
- "fmt"
"log/slog"
"regexp"
"time"
@@ -556,179 +555,32 @@ func (s *SettingService) UpdateSetting(ctx context.Context, request *connect.Req
return 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.go
new file mode 100644
index 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.go
index 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.Requ
return 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 *sto
return 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.Msg
switch 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.go
new file mode 100644
index 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.go
deleted file mode 100644
index 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.go
index 8d20a17552..2bab5ee28d 100644
--- a/backend/common/position.go
+++ b/backend/common/position.go
@@ -2,7 +2,6 @@
package common
import (
- "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 - 1
if 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) *storep
Column: 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.go
index 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.go
index 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.Advic
Code: 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.go
index 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.UnknownFields
sizeCache 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.UnknownFields
sizeCache 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.UnknownFields
sizeCache 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.go
index 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, ma
return 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, marshaler
if 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, mars
if 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.go
index 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.go
index 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.QueryResult
0, // 3: bytebase.v1.QueryOption.redis_run_commands_on:type_name -> bytebase.v1.QueryOption.RedisRunCommandsOn
12, // 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.Message
11, // 8: bytebase.v1.QueryResult.masked:type_name -> bytebase.v1.MaskingReason
13, // 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.TimestampTZ
2, // 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.go
index 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.Mar
return 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.ForwardResponseMessage
forward_SQLService_Export_2 = runtime.ForwardResponseMessage
forward_SQLService_Check_0 = runtime.ForwardResponseMessage
- forward_SQLService_Pretty_0 = runtime.ForwardResponseMessage
forward_SQLService_DiffMetadata_0 = runtime.ForwardResponseMessage
forward_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.go
index 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 true
diff --git a/backend/generated-go/v1/sql_service_grpc.pb.go b/backend/generated-go/v1/sql_service_grpc.pb.go
index 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.check
Check(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: None
DiffMetadata(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.check
Check(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: None
DiffMetadata(context.Context, *DiffMetadataRequest) (*DiffMetadataResponse, error)
@@ -207,9 +190,6 @@ func (UnimplementedSQLServiceServer) Export(context.Context, *ExportRequest) (*E
func (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(in
return 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.go
index 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.check
Check(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: None
DiffMetadata(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.Ch
return 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.check
Check(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: None
DiffMetadata(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[v1
return 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.go
index 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 adv
Title: 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 adv
Title: 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 adv
Title: 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.go
index 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.Conte
Title: 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.go
index 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.go
index 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 advisor
Title: 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 advisor
Title: 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 advisor
Title: 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.go
index 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.go
index 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 advisor
Code: 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 advisor
Code: 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 advisor
Code: 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.go
index 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() []*storepb
Code: 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.go
index 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.Visitor
Code: 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.go
index 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.Visit
Code: 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.go
index 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.go
index 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.go
index 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.go
index 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 checker
diff --git a/backend/plugin/advisor/pg/advisor_comment_convention.go b/backend/plugin/advisor/pg/advisor_comment_convention.go
index 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.go
index 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.go
index 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.go
index 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 checker
diff --git a/backend/plugin/advisor/pg/advisor_index_no_duplicate_column.go b/backend/plugin/advisor/pg/advisor_index_no_duplicate_column.go
index 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.go
index 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.Visit
Code: 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.go
index 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.Advice
Code: 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.go
index 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.Visitor
Code: 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.go
index 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.go
index 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 checker
diff --git a/backend/plugin/advisor/pg/advisor_migration_compatibility.go b/backend/plugin/advisor/pg/advisor_migration_compatibility.go
index 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 checker
diff --git a/backend/plugin/advisor/pg/advisor_naming_column.go b/backend/plugin/advisor/pg/advisor_naming_column.go
index 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.go
index 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.go
index 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 st
Code: 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.go
index 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.go
index 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.go
index 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.go
index 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.go
index 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.Visitor
Code: 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.go
index 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.go
index 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.Visitor
Code: 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.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(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.Visitor
Code: 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 checker
diff --git a/backend/plugin/advisor/pg/advisor_statement_check_set_role_variable.go b/backend/plugin/advisor/pg/advisor_statement_check_set_role_variable.go
index 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.go
index 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.go
index 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.go
index 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.Visito
Code: 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.go
index 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.go
index 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 advis
Title: 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.go
index 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 advis
Title: 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.go
index 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.go
index 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.Visitor
Code: 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.go
index 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.Advi
Code: 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.go
index 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.Contex
Code: 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.go
index 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 adv
Title: 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 adv
Title: 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 adv
Title: 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 adv
Title: 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 adv
Title: 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 adv
Title: 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 adv
Title: 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 adv
Title: 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 adv
Title: 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 adv
Title: 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 adv
Title: 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 adv
Title: 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 adv
Title: 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 adv
Title: 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 adv
Title: 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 adv
Title: 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 adv
Title: 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 adv
Title: 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 adv
Title: 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 adv
Title: 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 adv
Title: 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 adv
Title: 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.go
index 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.C
Code: 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.go
index 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.go
index 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.Visito
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 checker
diff --git a/backend/plugin/advisor/pg/advisor_stmt_where_required_update_delete.go b/backend/plugin/advisor/pg/advisor_stmt_where_required_update_delete.go
index 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 checker
diff --git a/backend/plugin/advisor/pg/advisor_table_comment_convention.go b/backend/plugin/advisor/pg/advisor_table_comment_convention.go
index 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.go
index 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.go
index 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.Visitor
Code: 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.go
index 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.go
index 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.yaml
index 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: 217
title: statement.check-set-role-variable
content: No SET ROLE statement found.
- startposition:
- line: 0
- column: 0
+ startposition: null
endposition: null
diff --git a/backend/plugin/advisor/pg/utils.go b/backend/plugin/advisor/pg/utils.go
index a958bcea91..94349f753d 100644
--- a/backend/plugin/advisor/pg/utils.go
+++ b/backend/plugin/advisor/pg/utils.go
@@ -4,6 +4,7 @@ package pg
import (
"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.go
index 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 adv
Title: 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 adv
Title: 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.go
index a822b1edd9..e1388c985d 100644
--- a/backend/plugin/parser/base/diagnose.go
+++ b/backend/plugin/parser/base/diagnose.go
@@ -1,9 +1,11 @@
package base
import (
+ "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 := start
end.Character++
message := err.Message
diff --git a/backend/plugin/parser/base/diagnose_test.go b/backend/plugin/parser/base/diagnose_test.go
new file mode 100644
index 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.go
index 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.go
index 45db1bb7ed..1510f8a279 100644
--- a/backend/plugin/parser/elasticsearch/diagnose.go
+++ b/backend/plugin/parser/elasticsearch/diagnose.go
@@ -3,9 +3,6 @@ package elasticsearch
import (
"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.go
deleted file mode 100644
index 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.go
deleted file mode 100644
index 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.go
deleted file mode 100644
index 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.go
index 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.go
index 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 string
ddl string
wantRawSchema string
- wantSDL string
wantDatabaseMetadata *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.Msg
a.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.vue
index 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.ts
index 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.ts
index 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.ts
index 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.js
index 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.ts
index 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: None
diff --git a/frontend/src/types/proto-es/v1/sql_service_pb.js b/frontend/src/types/proto-es/v1/sql_service_pb.js
index 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.yaml
index 95a5c60200..0e878049b7 100644
--- a/proto/gen/grpc-doc/openapi.yaml
+++ b/proto/gen/grpc-doc/openapi.yaml
@@ -1619,11 +1619,6 @@ paths:
- CHANGELOG_VIEW_FULL
type: string
format: enum
- - name: sdlFormat
- in: query
- description: Format the schema dump into SDL format.
- schema:
- type: boolean
responses:
"200":
description: OK
@@ -2242,11 +2237,6 @@ paths:
required: true
schema:
type: string
- - name: sdlFormat
- in: query
- description: Format the schema dump into SDL format.
- schema:
- type: boolean
responses:
"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 changelog
Format:
instances/{instance}/databases/{database}/changelogs/{changelog}
- sdlFormat:
- type: boolean
- description: Format the schema dump into SDL format.
DiffSchemaResponse:
type: object
properties:
@@ -12525,59 +12485,6 @@ components:
description: When the current query started.
format: date-time
description: 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:
- project
diff --git a/proto/gen/grpc-doc/v1/README.md b/proto/gen/grpc-doc/v1/README.md
index 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 == &#34;schema-a&#34; table == &#34;table-a&#34; 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&#39;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.html
index 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.proto
index 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.proto
index 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: None
rpc 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}