diff --git a/pkg/ccr/base/spec.go b/pkg/ccr/base/spec.go index 0eb5f895..4d63683b 100644 --- a/pkg/ccr/base/spec.go +++ b/pkg/ccr/base/spec.go @@ -83,6 +83,22 @@ func ParseBackupState(state string) BackupState { } } +// isSystemDatabase determines if it's a system database that should be skipped +func isSystemDatabase(dbName string) bool { + systemDatabases := []string{ + "information_schema", + "mysql", + "__internal_schema", + } + + for _, sysDb := range systemDatabases { + if dbName == sysDb { + return true + } + } + return false +} + type RestoreState int const ( @@ -464,6 +480,40 @@ func (s *Spec) GetAllTables() ([]string, error) { return tables, nil } +func (s *Spec) GetAllDatabases() ([]string, error) { + log.Tracef("get all databases from cluster") + + db, err := s.Connect() + if err != nil { + return nil, err + } + + sql := "SHOW DATABASES" + rows, err := db.Query(sql) + if err != nil { + return nil, xerror.Wrapf(err, xerror.Normal, "query %s failed", sql) + } + defer rows.Close() + + var databases []string + for rows.Next() { + var database string + if err := rows.Scan(&database); err != nil { + return nil, xerror.Wrapf(err, xerror.Normal, "scan database failed") + } + // Filter system databases + if !isSystemDatabase(database) { + databases = append(databases, database) + } + } + + if err := rows.Err(); err != nil { + return nil, xerror.Wrapf(err, xerror.Normal, "rows error") + } + + return databases, nil +} + func (s *Spec) queryResult(querySQL string, queryColumn string, errMsg string) ([]string, error) { db, err := s.Connect() if err != nil { @@ -773,6 +823,45 @@ func (s *Spec) CreateSnapshot(snapshotName string, tables []string) error { return nil } +// CreateGlobalSnapshot creates a global snapshot for synchronizing global objects +// Sets different properties based on different options +func (s *Spec) CreateGlobalSnapshot(snapshotName string, backupPrivilege, backupCatalog, backupWorkloadGroup bool) error { + log.Infof("Creating global snapshot %s", snapshotName) + + db, err := s.Connect() + if err != nil { + return err + } + + // Build SQL statement + sql := fmt.Sprintf("BACKUP GLOBAL SNAPSHOT %s TO `__keep_on_local__`", utils.FormatKeywordName(snapshotName)) + + // Add properties based on different options + properties := make([]string, 0) + if backupPrivilege { + properties = append(properties, "\"backup_privilege\" = \"true\"") + } + if backupCatalog { + properties = append(properties, "\"backup_catalog\" = \"true\"") + } + if backupWorkloadGroup { + properties = append(properties, "\"backup_workload_group\" = \"true\"") + } + + // If there are properties, add PROPERTIES clause + if len(properties) > 0 { + sql += fmt.Sprintf(" PROPERTIES (%s)", strings.Join(properties, ", ")) + } + + log.Infof("Creating global snapshot SQL: %s", sql) + _, err = db.Exec(sql) + if err != nil { + return xerror.Wrapf(err, xerror.Normal, "Failed to create global snapshot %s, SQL: %s", snapshotName, sql) + } + + return nil +} + // mysql> BACKUP SNAPSHOT ccr.snapshot_20230605 TO `__keep_on_local__` ON (src_1 PARTITION (`p1`)) PROPERTIES ("type" = "full"); func (s *Spec) CreatePartialSnapshot(snapshotName, table string, partitions []string) error { if len(table) == 0 { @@ -847,6 +936,87 @@ func (s *Spec) checkBackupFinished(snapshotName string) (BackupState, string, er return BackupStateUnknown, "", xerror.Errorf(xerror.Normal, "no backup state found, sql: %s", sql) } +// checkGlobalBackupFinished checks global backup status +func (s *Spec) checkGlobalBackupFinished(snapshotName string) (BackupState, string, error) { + log.Tracef("Checking global backup status %s", snapshotName) + + db, err := s.Connect() + if err != nil { + return BackupStateUnknown, "", err + } + + sql := fmt.Sprintf("SHOW GLOBAL BACKUP WHERE SnapshotName = \"%s\"", snapshotName) + log.Infof("Checking global backup status SQL: %s", sql) + rows, err := db.Query(sql) + if err != nil { + return BackupStateUnknown, "", xerror.Wrapf(err, xerror.Normal, "Failed to query global backup status, SQL: %s", sql) + } + defer rows.Close() + + if rows.Next() { + rowParser := utils.NewRowParser() + if err := rowParser.Parse(rows); err != nil { + return BackupStateUnknown, "", xerror.Wrap(err, xerror.Normal, sql) + } + + stateStr, err := rowParser.GetString("State") + if err != nil { + return BackupStateUnknown, "", xerror.Wrap(err, xerror.Normal, "Failed to parse global backup State") + } + + status, err := rowParser.GetString("Status") + if err != nil { + return BackupStateUnknown, "", xerror.Wrap(err, xerror.Normal, "Failed to parse global backup Status") + } + + log.Infof("Checking global snapshot %s backup status: [%v]", snapshotName, stateStr) + return ParseBackupState(stateStr), status, nil + } + + if err := rows.Err(); err != nil { + return BackupStateUnknown, "", xerror.Wrapf(err, xerror.Normal, "Check global backup status, SQL: %s", sql) + } + + return BackupStateUnknown, "", xerror.Errorf(xerror.Normal, "Global backup status not found, SQL: %s", sql) +} + +// CheckGlobalBackupFinished checks if global backup is finished +func (s *Spec) CheckGlobalBackupFinished(snapshotName string) (bool, error) { + log.Tracef("Checking if global backup is finished, spec: %s, snapshot: %s", s.String(), snapshotName) + + // Retry network related errors to avoid full sync when target network is interrupted or process is restarted + if backupState, status, err := s.checkGlobalBackupFinished(snapshotName); err != nil && !isNetworkRelated(err) { + return false, err + } else if err == nil && backupState == BackupStateFinished { + return true, nil + } else if err == nil && backupState == BackupStateCancelled { + return false, xerror.Errorf(xerror.Normal, "Global backup failed or cancelled, backup status: %s", status) + } else { + // BackupStatePending, BackupStateUnknown or network related errors + if err != nil { + log.Warnf("Failed to check global backup status, spec: %s, snapshot: %s, err: %v", s.String(), snapshotName, err) + } + return false, nil + } +} + +func (s *Spec) RestoreGlobalInfo(sqls string) error { + log.Infof("Restoring global information") + + db, err := s.Connect() + if err != nil { + return err + } + + log.Infof("Executing global restore SQL: %s", sqls) + _, err = db.Exec(sqls) + if err != nil { + return xerror.Wrapf(err, xerror.Normal, "Failed to restore global information, SQL: %s", sqls) + } + + return nil +} + func (s *Spec) CheckBackupFinished(snapshotName string) (bool, error) { log.Tracef("check backup state, spec: %s, snapshot: %s", s.String(), snapshotName) diff --git a/pkg/ccr/base/specer.go b/pkg/ccr/base/specer.go index a64c7e5c..d3b9c3e4 100644 --- a/pkg/ccr/base/specer.go +++ b/pkg/ccr/base/specer.go @@ -47,7 +47,10 @@ type Specer interface { CancelRestoreIfExists(snapshotName string) error CreatePartialSnapshot(snapshotName, table string, partitions []string) error CreateSnapshot(snapshotName string, tables []string) error + CreateGlobalSnapshot(snapshotName string, backupPrivilege, backupCatalog, backupWorkloadGroup bool) error + RestoreGlobalInfo(sqls string) error CheckBackupFinished(snapshotName string) (bool, error) + CheckGlobalBackupFinished(snapshotName string) (bool, error) CheckRestoreFinished(snapshotName string) (bool, error) GetRestoreSignatureNotMatchedTableOrView(snapshotName string) (string, bool, error) WaitTransactionDone(txnId int64) // busy wait diff --git a/pkg/ccr/job.go b/pkg/ccr/job.go index 41312f2e..277d4ce8 100644 --- a/pkg/ccr/job.go +++ b/pkg/ccr/job.go @@ -127,8 +127,9 @@ func init() { type SyncType int const ( - DBSync SyncType = 0 - TableSync SyncType = 1 + DBSync SyncType = 0 + TableSync SyncType = 1 + ClusterSync SyncType = 2 ) func (s SyncType) String() string { @@ -137,6 +138,8 @@ func (s SyncType) String() string { return "db_sync" case TableSync: return "table_sync" + case ClusterSync: + return "cluster_sync" default: return "unknown_sync" } diff --git a/pkg/ccr/specer_mock.go b/pkg/ccr/specer_mock.go index cbf278b7..4b6b51fa 100644 --- a/pkg/ccr/specer_mock.go +++ b/pkg/ccr/specer_mock.go @@ -216,6 +216,21 @@ func (mr *MockSpecerMockRecorder) Exec(sql any) *gomock.Call { return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Exec", reflect.TypeOf((*MockSpecer)(nil).Exec), sql) } +// GetAllTables mocks base method. +func (m *MockSpecer) GetAllDatabases() ([]string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetAllDatabases") + ret0, _ := ret[0].([]string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetAllDatabases indicates an expected call of GetAllDatabases. +func (mr *MockSpecerMockRecorder) GetAllDatabases() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetAllDatabases", reflect.TypeOf((*MockSpecer)(nil).GetAllDatabases)) +} + // GetAllTables mocks base method. func (m *MockSpecer) GetAllTables() ([]string, error) { m.ctrl.T.Helper() diff --git a/pkg/ccr/utils.go b/pkg/ccr/utils.go index 1c6a0480..a7f55457 100644 --- a/pkg/ccr/utils.go +++ b/pkg/ccr/utils.go @@ -55,6 +55,10 @@ func NewBackupJobInfoFromJson(data []byte) (*BackupJobInfo, error) { return jobInfo, nil } +func NewBackupSqlsFromBytes(backupSqls []byte) (string, error) { + return string(backupSqls), nil +} + func (i *BackupJobInfo) TableNameMapping() map[int64]string { tableMapping := make(map[int64]string) for tableName, tableInfo := range i.BackupObjects { diff --git a/pkg/rpc/fe.go b/pkg/rpc/fe.go index 4f85b00d..5c057ebf 100644 --- a/pkg/rpc/fe.go +++ b/pkg/rpc/fe.go @@ -108,6 +108,7 @@ type IFeRpc interface { GetBinlog(*base.Spec, int64, int64) (*festruct.TGetBinlogResult_, error) GetBinlogLag(*base.Spec, int64) (*festruct.TGetBinlogLagResult_, error) GetSnapshot(*base.Spec, string, bool) (*festruct.TGetSnapshotResult_, error) + GetGlobalSnapshot(*base.Spec, string) (*festruct.TGetGlobalSnapshotResult_, error) RestoreSnapshot(*base.Spec, *RestoreSnapshotRequest) (*festruct.TRestoreSnapshotResult_, error) GetMasterToken(*base.Spec) (*festruct.TGetMasterTokenResult_, error) GetDbMeta(spec *base.Spec) (*festruct.TGetMetaResult_, error) @@ -471,6 +472,14 @@ func (rpc *FeRpc) GetSnapshot(spec *base.Spec, labelName string, compress bool) return convertResult[festruct.TGetSnapshotResult_](result, err) } +func (rpc *FeRpc) GetGlobalSnapshot(spec *base.Spec, labelName string) (*festruct.TGetGlobalSnapshotResult_, error) { + caller := func(client IFeRpc) (resultType, error) { + return client.GetGlobalSnapshot(spec, labelName) + } + result, err := rpc.callWithMasterRedirect(caller) + return convertResult[festruct.TGetGlobalSnapshotResult_](result, err) +} + func (rpc *FeRpc) RestoreSnapshot(spec *base.Spec, req *RestoreSnapshotRequest) (*festruct.TRestoreSnapshotResult_, error) { caller := func(client IFeRpc) (resultType, error) { return client.RestoreSnapshot(spec, req) @@ -801,6 +810,41 @@ func (rpc *singleFeClient) GetSnapshot(spec *base.Spec, labelName string, compre } } +// struct TGetGlobalSnapshotRequest { +// 1: optional string cluster +// 2: optional string user +// 3: optional string passwd +// 4: optional string token +// 5: optional string label_name +// 6: optional string snapshot_name +// 7: optional TSnapshotType snapshot_type +// } +// +// Get Global Snapshot rpc +func (rpc *singleFeClient) GetGlobalSnapshot(spec *base.Spec, labelName string) (*festruct.TGetGlobalSnapshotResult_, error) { + log.Tracef("Call GetGlobalSnapshot, addr: %s, spec: %s, label: %s", rpc.Address(), spec, labelName) + + defer xmetrics.RecordFeRpc("GetGlobalSnapshot", rpc.addr)() + + client := rpc.client + snapshotType := festruct.TSnapshotType_LOCAL + req := &festruct.TGetGlobalSnapshotRequest{ + Cluster: &spec.Cluster, + User: &spec.User, + Passwd: &spec.Password, + SnapshotName: &labelName, + SnapshotType: &snapshotType, + } + + log.Tracef("GetGlobalSnapshotRequest user %s, cluster %s, snapshot name %s, snapshot type %d", + req.GetUser(), req.GetCluster(), req.GetSnapshotName(), req.GetSnapshotType()) + if resp, err := client.GetGlobalSnapshot(context.Background(), req); err != nil { + return nil, xerror.Wrapf(err, xerror.RPC, "GetGlobalSnapshot error: %v, req: %+v", err, req) + } else { + return resp, nil + } +} + // struct TRestoreSnapshotRequest { // 1: optional string cluster // 2: optional string user diff --git a/pkg/rpc/kitex_gen/frontendservice/FrontendService.go b/pkg/rpc/kitex_gen/frontendservice/FrontendService.go index 4829e665..61b76306 100644 --- a/pkg/rpc/kitex_gen/frontendservice/FrontendService.go +++ b/pkg/rpc/kitex_gen/frontendservice/FrontendService.go @@ -53734,6 +53734,1094 @@ func (p *TGetSnapshotResult_) Field7DeepEqual(src *int64) bool { return true } +type TGetGlobalSnapshotRequest struct { + Cluster *string `thrift:"cluster,1,optional" frugal:"1,optional,string" json:"cluster,omitempty"` + User *string `thrift:"user,2,optional" frugal:"2,optional,string" json:"user,omitempty"` + Passwd *string `thrift:"passwd,3,optional" frugal:"3,optional,string" json:"passwd,omitempty"` + Token *string `thrift:"token,4,optional" frugal:"4,optional,string" json:"token,omitempty"` + LabelName *string `thrift:"label_name,5,optional" frugal:"5,optional,string" json:"label_name,omitempty"` + SnapshotName *string `thrift:"snapshot_name,6,optional" frugal:"6,optional,string" json:"snapshot_name,omitempty"` + SnapshotType *TSnapshotType `thrift:"snapshot_type,7,optional" frugal:"7,optional,TSnapshotType" json:"snapshot_type,omitempty"` +} + +func NewTGetGlobalSnapshotRequest() *TGetGlobalSnapshotRequest { + return &TGetGlobalSnapshotRequest{} +} + +func (p *TGetGlobalSnapshotRequest) InitDefault() { +} + +var TGetGlobalSnapshotRequest_Cluster_DEFAULT string + +func (p *TGetGlobalSnapshotRequest) GetCluster() (v string) { + if !p.IsSetCluster() { + return TGetGlobalSnapshotRequest_Cluster_DEFAULT + } + return *p.Cluster +} + +var TGetGlobalSnapshotRequest_User_DEFAULT string + +func (p *TGetGlobalSnapshotRequest) GetUser() (v string) { + if !p.IsSetUser() { + return TGetGlobalSnapshotRequest_User_DEFAULT + } + return *p.User +} + +var TGetGlobalSnapshotRequest_Passwd_DEFAULT string + +func (p *TGetGlobalSnapshotRequest) GetPasswd() (v string) { + if !p.IsSetPasswd() { + return TGetGlobalSnapshotRequest_Passwd_DEFAULT + } + return *p.Passwd +} + +var TGetGlobalSnapshotRequest_Token_DEFAULT string + +func (p *TGetGlobalSnapshotRequest) GetToken() (v string) { + if !p.IsSetToken() { + return TGetGlobalSnapshotRequest_Token_DEFAULT + } + return *p.Token +} + +var TGetGlobalSnapshotRequest_LabelName_DEFAULT string + +func (p *TGetGlobalSnapshotRequest) GetLabelName() (v string) { + if !p.IsSetLabelName() { + return TGetGlobalSnapshotRequest_LabelName_DEFAULT + } + return *p.LabelName +} + +var TGetGlobalSnapshotRequest_SnapshotName_DEFAULT string + +func (p *TGetGlobalSnapshotRequest) GetSnapshotName() (v string) { + if !p.IsSetSnapshotName() { + return TGetGlobalSnapshotRequest_SnapshotName_DEFAULT + } + return *p.SnapshotName +} + +var TGetGlobalSnapshotRequest_SnapshotType_DEFAULT TSnapshotType + +func (p *TGetGlobalSnapshotRequest) GetSnapshotType() (v TSnapshotType) { + if !p.IsSetSnapshotType() { + return TGetGlobalSnapshotRequest_SnapshotType_DEFAULT + } + return *p.SnapshotType +} +func (p *TGetGlobalSnapshotRequest) SetCluster(val *string) { + p.Cluster = val +} +func (p *TGetGlobalSnapshotRequest) SetUser(val *string) { + p.User = val +} +func (p *TGetGlobalSnapshotRequest) SetPasswd(val *string) { + p.Passwd = val +} +func (p *TGetGlobalSnapshotRequest) SetToken(val *string) { + p.Token = val +} +func (p *TGetGlobalSnapshotRequest) SetLabelName(val *string) { + p.LabelName = val +} +func (p *TGetGlobalSnapshotRequest) SetSnapshotName(val *string) { + p.SnapshotName = val +} +func (p *TGetGlobalSnapshotRequest) SetSnapshotType(val *TSnapshotType) { + p.SnapshotType = val +} + +var fieldIDToName_TGetGlobalSnapshotRequest = map[int16]string{ + 1: "cluster", + 2: "user", + 3: "passwd", + 4: "token", + 5: "label_name", + 6: "snapshot_name", + 7: "snapshot_type", +} + +func (p *TGetGlobalSnapshotRequest) IsSetCluster() bool { + return p.Cluster != nil +} + +func (p *TGetGlobalSnapshotRequest) IsSetUser() bool { + return p.User != nil +} + +func (p *TGetGlobalSnapshotRequest) IsSetPasswd() bool { + return p.Passwd != nil +} + +func (p *TGetGlobalSnapshotRequest) IsSetToken() bool { + return p.Token != nil +} + +func (p *TGetGlobalSnapshotRequest) IsSetLabelName() bool { + return p.LabelName != nil +} + +func (p *TGetGlobalSnapshotRequest) IsSetSnapshotName() bool { + return p.SnapshotName != nil +} + +func (p *TGetGlobalSnapshotRequest) IsSetSnapshotType() bool { + return p.SnapshotType != nil +} + +func (p *TGetGlobalSnapshotRequest) Read(iprot thrift.TProtocol) (err error) { + + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 1: + if fieldTypeId == thrift.STRING { + if err = p.ReadField1(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 2: + if fieldTypeId == thrift.STRING { + if err = p.ReadField2(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 3: + if fieldTypeId == thrift.STRING { + if err = p.ReadField3(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 4: + if fieldTypeId == thrift.STRING { + if err = p.ReadField4(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 5: + if fieldTypeId == thrift.STRING { + if err = p.ReadField5(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 6: + if fieldTypeId == thrift.STRING { + if err = p.ReadField6(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 7: + if fieldTypeId == thrift.I32 { + if err = p.ReadField7(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_TGetGlobalSnapshotRequest[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *TGetGlobalSnapshotRequest) ReadField1(iprot thrift.TProtocol) error { + + var _field *string + if v, err := iprot.ReadString(); err != nil { + return err + } else { + _field = &v + } + p.Cluster = _field + return nil +} +func (p *TGetGlobalSnapshotRequest) ReadField2(iprot thrift.TProtocol) error { + + var _field *string + if v, err := iprot.ReadString(); err != nil { + return err + } else { + _field = &v + } + p.User = _field + return nil +} +func (p *TGetGlobalSnapshotRequest) ReadField3(iprot thrift.TProtocol) error { + + var _field *string + if v, err := iprot.ReadString(); err != nil { + return err + } else { + _field = &v + } + p.Passwd = _field + return nil +} +func (p *TGetGlobalSnapshotRequest) ReadField4(iprot thrift.TProtocol) error { + + var _field *string + if v, err := iprot.ReadString(); err != nil { + return err + } else { + _field = &v + } + p.Token = _field + return nil +} +func (p *TGetGlobalSnapshotRequest) ReadField5(iprot thrift.TProtocol) error { + + var _field *string + if v, err := iprot.ReadString(); err != nil { + return err + } else { + _field = &v + } + p.LabelName = _field + return nil +} +func (p *TGetGlobalSnapshotRequest) ReadField6(iprot thrift.TProtocol) error { + + var _field *string + if v, err := iprot.ReadString(); err != nil { + return err + } else { + _field = &v + } + p.SnapshotName = _field + return nil +} +func (p *TGetGlobalSnapshotRequest) ReadField7(iprot thrift.TProtocol) error { + + var _field *TSnapshotType + if v, err := iprot.ReadI32(); err != nil { + return err + } else { + tmp := TSnapshotType(v) + _field = &tmp + } + p.SnapshotType = _field + return nil +} + +func (p *TGetGlobalSnapshotRequest) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("TGetGlobalSnapshotRequest"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField1(oprot); err != nil { + fieldId = 1 + goto WriteFieldError + } + if err = p.writeField2(oprot); err != nil { + fieldId = 2 + goto WriteFieldError + } + if err = p.writeField3(oprot); err != nil { + fieldId = 3 + goto WriteFieldError + } + if err = p.writeField4(oprot); err != nil { + fieldId = 4 + goto WriteFieldError + } + if err = p.writeField5(oprot); err != nil { + fieldId = 5 + goto WriteFieldError + } + if err = p.writeField6(oprot); err != nil { + fieldId = 6 + goto WriteFieldError + } + if err = p.writeField7(oprot); err != nil { + fieldId = 7 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *TGetGlobalSnapshotRequest) writeField1(oprot thrift.TProtocol) (err error) { + if p.IsSetCluster() { + if err = oprot.WriteFieldBegin("cluster", thrift.STRING, 1); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteString(*p.Cluster); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) +} + +func (p *TGetGlobalSnapshotRequest) writeField2(oprot thrift.TProtocol) (err error) { + if p.IsSetUser() { + if err = oprot.WriteFieldBegin("user", thrift.STRING, 2); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteString(*p.User); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 2 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err) +} + +func (p *TGetGlobalSnapshotRequest) writeField3(oprot thrift.TProtocol) (err error) { + if p.IsSetPasswd() { + if err = oprot.WriteFieldBegin("passwd", thrift.STRING, 3); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteString(*p.Passwd); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 3 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 3 end error: ", p), err) +} + +func (p *TGetGlobalSnapshotRequest) writeField4(oprot thrift.TProtocol) (err error) { + if p.IsSetToken() { + if err = oprot.WriteFieldBegin("token", thrift.STRING, 4); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteString(*p.Token); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 4 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 4 end error: ", p), err) +} + +func (p *TGetGlobalSnapshotRequest) writeField5(oprot thrift.TProtocol) (err error) { + if p.IsSetLabelName() { + if err = oprot.WriteFieldBegin("label_name", thrift.STRING, 5); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteString(*p.LabelName); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 5 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 5 end error: ", p), err) +} + +func (p *TGetGlobalSnapshotRequest) writeField6(oprot thrift.TProtocol) (err error) { + if p.IsSetSnapshotName() { + if err = oprot.WriteFieldBegin("snapshot_name", thrift.STRING, 6); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteString(*p.SnapshotName); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 6 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 6 end error: ", p), err) +} + +func (p *TGetGlobalSnapshotRequest) writeField7(oprot thrift.TProtocol) (err error) { + if p.IsSetSnapshotType() { + if err = oprot.WriteFieldBegin("snapshot_type", thrift.I32, 7); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteI32(int32(*p.SnapshotType)); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 7 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 7 end error: ", p), err) +} + +func (p *TGetGlobalSnapshotRequest) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("TGetGlobalSnapshotRequest(%+v)", *p) + +} + +func (p *TGetGlobalSnapshotRequest) DeepEqual(ano *TGetGlobalSnapshotRequest) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field1DeepEqual(ano.Cluster) { + return false + } + if !p.Field2DeepEqual(ano.User) { + return false + } + if !p.Field3DeepEqual(ano.Passwd) { + return false + } + if !p.Field4DeepEqual(ano.Token) { + return false + } + if !p.Field5DeepEqual(ano.LabelName) { + return false + } + if !p.Field6DeepEqual(ano.SnapshotName) { + return false + } + if !p.Field7DeepEqual(ano.SnapshotType) { + return false + } + return true +} + +func (p *TGetGlobalSnapshotRequest) Field1DeepEqual(src *string) bool { + + if p.Cluster == src { + return true + } else if p.Cluster == nil || src == nil { + return false + } + if strings.Compare(*p.Cluster, *src) != 0 { + return false + } + return true +} +func (p *TGetGlobalSnapshotRequest) Field2DeepEqual(src *string) bool { + + if p.User == src { + return true + } else if p.User == nil || src == nil { + return false + } + if strings.Compare(*p.User, *src) != 0 { + return false + } + return true +} +func (p *TGetGlobalSnapshotRequest) Field3DeepEqual(src *string) bool { + + if p.Passwd == src { + return true + } else if p.Passwd == nil || src == nil { + return false + } + if strings.Compare(*p.Passwd, *src) != 0 { + return false + } + return true +} +func (p *TGetGlobalSnapshotRequest) Field4DeepEqual(src *string) bool { + + if p.Token == src { + return true + } else if p.Token == nil || src == nil { + return false + } + if strings.Compare(*p.Token, *src) != 0 { + return false + } + return true +} +func (p *TGetGlobalSnapshotRequest) Field5DeepEqual(src *string) bool { + + if p.LabelName == src { + return true + } else if p.LabelName == nil || src == nil { + return false + } + if strings.Compare(*p.LabelName, *src) != 0 { + return false + } + return true +} +func (p *TGetGlobalSnapshotRequest) Field6DeepEqual(src *string) bool { + + if p.SnapshotName == src { + return true + } else if p.SnapshotName == nil || src == nil { + return false + } + if strings.Compare(*p.SnapshotName, *src) != 0 { + return false + } + return true +} +func (p *TGetGlobalSnapshotRequest) Field7DeepEqual(src *TSnapshotType) bool { + + if p.SnapshotType == src { + return true + } else if p.SnapshotType == nil || src == nil { + return false + } + if *p.SnapshotType != *src { + return false + } + return true +} + +type TGetGlobalSnapshotResult_ struct { + Status *status.TStatus `thrift:"status,1,optional" frugal:"1,optional,status.TStatus" json:"status,omitempty"` + GlobalInfo []byte `thrift:"global_info,2,optional" frugal:"2,optional,binary" json:"global_info,omitempty"` + MasterAddress *types.TNetworkAddress `thrift:"master_address,3,optional" frugal:"3,optional,types.TNetworkAddress" json:"master_address,omitempty"` + ExpiredAt *int64 `thrift:"expiredAt,4,optional" frugal:"4,optional,i64" json:"expiredAt,omitempty"` + CommitSeq *int64 `thrift:"commit_seq,5,optional" frugal:"5,optional,i64" json:"commit_seq,omitempty"` +} + +func NewTGetGlobalSnapshotResult_() *TGetGlobalSnapshotResult_ { + return &TGetGlobalSnapshotResult_{} +} + +func (p *TGetGlobalSnapshotResult_) InitDefault() { +} + +var TGetGlobalSnapshotResult__Status_DEFAULT *status.TStatus + +func (p *TGetGlobalSnapshotResult_) GetStatus() (v *status.TStatus) { + if !p.IsSetStatus() { + return TGetGlobalSnapshotResult__Status_DEFAULT + } + return p.Status +} + +var TGetGlobalSnapshotResult__GlobalInfo_DEFAULT []byte + +func (p *TGetGlobalSnapshotResult_) GetGlobalInfo() (v []byte) { + if !p.IsSetGlobalInfo() { + return TGetGlobalSnapshotResult__GlobalInfo_DEFAULT + } + return p.GlobalInfo +} + +var TGetGlobalSnapshotResult__MasterAddress_DEFAULT *types.TNetworkAddress + +func (p *TGetGlobalSnapshotResult_) GetMasterAddress() (v *types.TNetworkAddress) { + if !p.IsSetMasterAddress() { + return TGetGlobalSnapshotResult__MasterAddress_DEFAULT + } + return p.MasterAddress +} + +var TGetGlobalSnapshotResult__ExpiredAt_DEFAULT int64 + +func (p *TGetGlobalSnapshotResult_) GetExpiredAt() (v int64) { + if !p.IsSetExpiredAt() { + return TGetGlobalSnapshotResult__ExpiredAt_DEFAULT + } + return *p.ExpiredAt +} + +var TGetGlobalSnapshotResult__CommitSeq_DEFAULT int64 + +func (p *TGetGlobalSnapshotResult_) GetCommitSeq() (v int64) { + if !p.IsSetCommitSeq() { + return TGetGlobalSnapshotResult__CommitSeq_DEFAULT + } + return *p.CommitSeq +} +func (p *TGetGlobalSnapshotResult_) SetStatus(val *status.TStatus) { + p.Status = val +} +func (p *TGetGlobalSnapshotResult_) SetGlobalInfo(val []byte) { + p.GlobalInfo = val +} +func (p *TGetGlobalSnapshotResult_) SetMasterAddress(val *types.TNetworkAddress) { + p.MasterAddress = val +} +func (p *TGetGlobalSnapshotResult_) SetExpiredAt(val *int64) { + p.ExpiredAt = val +} +func (p *TGetGlobalSnapshotResult_) SetCommitSeq(val *int64) { + p.CommitSeq = val +} + +var fieldIDToName_TGetGlobalSnapshotResult_ = map[int16]string{ + 1: "status", + 2: "global_info", + 3: "master_address", + 4: "expiredAt", + 5: "commit_seq", +} + +func (p *TGetGlobalSnapshotResult_) IsSetStatus() bool { + return p.Status != nil +} + +func (p *TGetGlobalSnapshotResult_) IsSetGlobalInfo() bool { + return p.GlobalInfo != nil +} + +func (p *TGetGlobalSnapshotResult_) IsSetMasterAddress() bool { + return p.MasterAddress != nil +} + +func (p *TGetGlobalSnapshotResult_) IsSetExpiredAt() bool { + return p.ExpiredAt != nil +} + +func (p *TGetGlobalSnapshotResult_) IsSetCommitSeq() bool { + return p.CommitSeq != nil +} + +func (p *TGetGlobalSnapshotResult_) Read(iprot thrift.TProtocol) (err error) { + + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 1: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField1(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 2: + if fieldTypeId == thrift.STRING { + if err = p.ReadField2(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 3: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField3(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 4: + if fieldTypeId == thrift.I64 { + if err = p.ReadField4(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + case 5: + if fieldTypeId == thrift.I64 { + if err = p.ReadField5(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_TGetGlobalSnapshotResult_[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *TGetGlobalSnapshotResult_) ReadField1(iprot thrift.TProtocol) error { + _field := status.NewTStatus() + if err := _field.Read(iprot); err != nil { + return err + } + p.Status = _field + return nil +} +func (p *TGetGlobalSnapshotResult_) ReadField2(iprot thrift.TProtocol) error { + + var _field []byte + if v, err := iprot.ReadBinary(); err != nil { + return err + } else { + _field = []byte(v) + } + p.GlobalInfo = _field + return nil +} +func (p *TGetGlobalSnapshotResult_) ReadField3(iprot thrift.TProtocol) error { + _field := types.NewTNetworkAddress() + if err := _field.Read(iprot); err != nil { + return err + } + p.MasterAddress = _field + return nil +} +func (p *TGetGlobalSnapshotResult_) ReadField4(iprot thrift.TProtocol) error { + + var _field *int64 + if v, err := iprot.ReadI64(); err != nil { + return err + } else { + _field = &v + } + p.ExpiredAt = _field + return nil +} +func (p *TGetGlobalSnapshotResult_) ReadField5(iprot thrift.TProtocol) error { + + var _field *int64 + if v, err := iprot.ReadI64(); err != nil { + return err + } else { + _field = &v + } + p.CommitSeq = _field + return nil +} + +func (p *TGetGlobalSnapshotResult_) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("TGetGlobalSnapshotResult"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField1(oprot); err != nil { + fieldId = 1 + goto WriteFieldError + } + if err = p.writeField2(oprot); err != nil { + fieldId = 2 + goto WriteFieldError + } + if err = p.writeField3(oprot); err != nil { + fieldId = 3 + goto WriteFieldError + } + if err = p.writeField4(oprot); err != nil { + fieldId = 4 + goto WriteFieldError + } + if err = p.writeField5(oprot); err != nil { + fieldId = 5 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *TGetGlobalSnapshotResult_) writeField1(oprot thrift.TProtocol) (err error) { + if p.IsSetStatus() { + if err = oprot.WriteFieldBegin("status", thrift.STRUCT, 1); err != nil { + goto WriteFieldBeginError + } + if err := p.Status.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) +} + +func (p *TGetGlobalSnapshotResult_) writeField2(oprot thrift.TProtocol) (err error) { + if p.IsSetGlobalInfo() { + if err = oprot.WriteFieldBegin("global_info", thrift.STRING, 2); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteBinary([]byte(p.GlobalInfo)); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 2 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err) +} + +func (p *TGetGlobalSnapshotResult_) writeField3(oprot thrift.TProtocol) (err error) { + if p.IsSetMasterAddress() { + if err = oprot.WriteFieldBegin("master_address", thrift.STRUCT, 3); err != nil { + goto WriteFieldBeginError + } + if err := p.MasterAddress.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 3 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 3 end error: ", p), err) +} + +func (p *TGetGlobalSnapshotResult_) writeField4(oprot thrift.TProtocol) (err error) { + if p.IsSetExpiredAt() { + if err = oprot.WriteFieldBegin("expiredAt", thrift.I64, 4); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteI64(*p.ExpiredAt); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 4 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 4 end error: ", p), err) +} + +func (p *TGetGlobalSnapshotResult_) writeField5(oprot thrift.TProtocol) (err error) { + if p.IsSetCommitSeq() { + if err = oprot.WriteFieldBegin("commit_seq", thrift.I64, 5); err != nil { + goto WriteFieldBeginError + } + if err := oprot.WriteI64(*p.CommitSeq); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 5 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 5 end error: ", p), err) +} + +func (p *TGetGlobalSnapshotResult_) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("TGetGlobalSnapshotResult_(%+v)", *p) + +} + +func (p *TGetGlobalSnapshotResult_) DeepEqual(ano *TGetGlobalSnapshotResult_) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field1DeepEqual(ano.Status) { + return false + } + if !p.Field2DeepEqual(ano.GlobalInfo) { + return false + } + if !p.Field3DeepEqual(ano.MasterAddress) { + return false + } + if !p.Field4DeepEqual(ano.ExpiredAt) { + return false + } + if !p.Field5DeepEqual(ano.CommitSeq) { + return false + } + return true +} + +func (p *TGetGlobalSnapshotResult_) Field1DeepEqual(src *status.TStatus) bool { + + if !p.Status.DeepEqual(src) { + return false + } + return true +} +func (p *TGetGlobalSnapshotResult_) Field2DeepEqual(src []byte) bool { + + if bytes.Compare(p.GlobalInfo, src) != 0 { + return false + } + return true +} +func (p *TGetGlobalSnapshotResult_) Field3DeepEqual(src *types.TNetworkAddress) bool { + + if !p.MasterAddress.DeepEqual(src) { + return false + } + return true +} +func (p *TGetGlobalSnapshotResult_) Field4DeepEqual(src *int64) bool { + + if p.ExpiredAt == src { + return true + } else if p.ExpiredAt == nil || src == nil { + return false + } + if *p.ExpiredAt != *src { + return false + } + return true +} +func (p *TGetGlobalSnapshotResult_) Field5DeepEqual(src *int64) bool { + + if p.CommitSeq == src { + return true + } else if p.CommitSeq == nil || src == nil { + return false + } + if *p.CommitSeq != *src { + return false + } + return true +} + type TTableRef struct { Table *string `thrift:"table,1,optional" frugal:"1,optional,string" json:"table,omitempty"` AliasName *string `thrift:"alias_name,3,optional" frugal:"3,optional,string" json:"alias_name,omitempty"` @@ -74380,6 +75468,8 @@ type FrontendService interface { GetSnapshot(ctx context.Context, request *TGetSnapshotRequest) (r *TGetSnapshotResult_, err error) + GetGlobalSnapshot(ctx context.Context, request *TGetGlobalSnapshotRequest) (r *TGetGlobalSnapshotResult_, err error) + RestoreSnapshot(ctx context.Context, request *TRestoreSnapshotRequest) (r *TRestoreSnapshotResult_, err error) LockBinlog(ctx context.Context, request *TLockBinlogRequest) (r *TLockBinlogResult_, err error) @@ -74705,6 +75795,15 @@ func (p *FrontendServiceClient) GetSnapshot(ctx context.Context, request *TGetSn } return _result.GetSuccess(), nil } +func (p *FrontendServiceClient) GetGlobalSnapshot(ctx context.Context, request *TGetGlobalSnapshotRequest) (r *TGetGlobalSnapshotResult_, err error) { + var _args FrontendServiceGetGlobalSnapshotArgs + _args.Request = request + var _result FrontendServiceGetGlobalSnapshotResult + if err = p.Client_().Call(ctx, "getGlobalSnapshot", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} func (p *FrontendServiceClient) RestoreSnapshot(ctx context.Context, request *TRestoreSnapshotRequest) (r *TRestoreSnapshotResult_, err error) { var _args FrontendServiceRestoreSnapshotArgs _args.Request = request @@ -75083,6 +76182,7 @@ func NewFrontendServiceProcessor(handler FrontendService) *FrontendServiceProces self.AddToProcessorMap("rollbackTxn", &frontendServiceProcessorRollbackTxn{handler: handler}) self.AddToProcessorMap("getBinlog", &frontendServiceProcessorGetBinlog{handler: handler}) self.AddToProcessorMap("getSnapshot", &frontendServiceProcessorGetSnapshot{handler: handler}) + self.AddToProcessorMap("getGlobalSnapshot", &frontendServiceProcessorGetGlobalSnapshot{handler: handler}) self.AddToProcessorMap("restoreSnapshot", &frontendServiceProcessorRestoreSnapshot{handler: handler}) self.AddToProcessorMap("lockBinlog", &frontendServiceProcessorLockBinlog{handler: handler}) self.AddToProcessorMap("waitingTxnStatus", &frontendServiceProcessorWaitingTxnStatus{handler: handler}) @@ -76340,6 +77440,54 @@ func (p *frontendServiceProcessorGetSnapshot) Process(ctx context.Context, seqId return true, err } +type frontendServiceProcessorGetGlobalSnapshot struct { + handler FrontendService +} + +func (p *frontendServiceProcessorGetGlobalSnapshot) Process(ctx context.Context, seqId int32, iprot, oprot thrift.TProtocol) (success bool, err thrift.TException) { + args := FrontendServiceGetGlobalSnapshotArgs{} + if err = args.Read(iprot); err != nil { + iprot.ReadMessageEnd() + x := thrift.NewTApplicationException(thrift.PROTOCOL_ERROR, err.Error()) + oprot.WriteMessageBegin("getGlobalSnapshot", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush(ctx) + return false, err + } + + iprot.ReadMessageEnd() + var err2 error + result := FrontendServiceGetGlobalSnapshotResult{} + var retval *TGetGlobalSnapshotResult_ + if retval, err2 = p.handler.GetGlobalSnapshot(ctx, args.Request); err2 != nil { + x := thrift.NewTApplicationException(thrift.INTERNAL_ERROR, "Internal error processing getGlobalSnapshot: "+err2.Error()) + oprot.WriteMessageBegin("getGlobalSnapshot", thrift.EXCEPTION, seqId) + x.Write(oprot) + oprot.WriteMessageEnd() + oprot.Flush(ctx) + return true, err2 + } else { + result.Success = retval + } + if err2 = oprot.WriteMessageBegin("getGlobalSnapshot", thrift.REPLY, seqId); err2 != nil { + err = err2 + } + if err2 = result.Write(oprot); err == nil && err2 != nil { + err = err2 + } + if err2 = oprot.WriteMessageEnd(); err == nil && err2 != nil { + err = err2 + } + if err2 = oprot.Flush(ctx); err == nil && err2 != nil { + err = err2 + } + if err != nil { + return + } + return true, err +} + type frontendServiceProcessorRestoreSnapshot struct { handler FrontendService } @@ -80449,7 +81597,270 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceReportResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceReportResult) writeField0(oprot thrift.TProtocol) (err error) { + if p.IsSetSuccess() { + if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { + goto WriteFieldBeginError + } + if err := p.Success.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 0 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) +} + +func (p *FrontendServiceReportResult) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("FrontendServiceReportResult(%+v)", *p) + +} + +func (p *FrontendServiceReportResult) DeepEqual(ano *FrontendServiceReportResult) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + if !p.Field0DeepEqual(ano.Success) { + return false + } + return true +} + +func (p *FrontendServiceReportResult) Field0DeepEqual(src *masterservice.TMasterResult_) bool { + + if !p.Success.DeepEqual(src) { + return false + } + return true +} + +type FrontendServiceFetchResourceArgs struct { +} + +func NewFrontendServiceFetchResourceArgs() *FrontendServiceFetchResourceArgs { + return &FrontendServiceFetchResourceArgs{} +} + +func (p *FrontendServiceFetchResourceArgs) InitDefault() { +} + +var fieldIDToName_FrontendServiceFetchResourceArgs = map[int16]string{} + +func (p *FrontendServiceFetchResourceArgs) Read(iprot thrift.TProtocol) (err error) { + + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldTypeError + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +SkipFieldTypeError: + return thrift.PrependError(fmt.Sprintf("%T skip field type %d error", p, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *FrontendServiceFetchResourceArgs) Write(oprot thrift.TProtocol) (err error) { + if err = oprot.WriteStructBegin("fetchResource_args"); err != nil { + goto WriteStructBeginError + } + if p != nil { + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *FrontendServiceFetchResourceArgs) String() string { + if p == nil { + return "" + } + return fmt.Sprintf("FrontendServiceFetchResourceArgs(%+v)", *p) + +} + +func (p *FrontendServiceFetchResourceArgs) DeepEqual(ano *FrontendServiceFetchResourceArgs) bool { + if p == ano { + return true + } else if p == nil || ano == nil { + return false + } + return true +} + +type FrontendServiceFetchResourceResult struct { + Success *masterservice.TFetchResourceResult_ `thrift:"success,0,optional" frugal:"0,optional,masterservice.TFetchResourceResult_" json:"success,omitempty"` +} + +func NewFrontendServiceFetchResourceResult() *FrontendServiceFetchResourceResult { + return &FrontendServiceFetchResourceResult{} +} + +func (p *FrontendServiceFetchResourceResult) InitDefault() { +} + +var FrontendServiceFetchResourceResult_Success_DEFAULT *masterservice.TFetchResourceResult_ + +func (p *FrontendServiceFetchResourceResult) GetSuccess() (v *masterservice.TFetchResourceResult_) { + if !p.IsSetSuccess() { + return FrontendServiceFetchResourceResult_Success_DEFAULT + } + return p.Success +} +func (p *FrontendServiceFetchResourceResult) SetSuccess(x interface{}) { + p.Success = x.(*masterservice.TFetchResourceResult_) +} + +var fieldIDToName_FrontendServiceFetchResourceResult = map[int16]string{ + 0: "success", +} + +func (p *FrontendServiceFetchResourceResult) IsSetSuccess() bool { + return p.Success != nil +} + +func (p *FrontendServiceFetchResourceResult) Read(iprot thrift.TProtocol) (err error) { + + var fieldTypeId thrift.TType + var fieldId int16 + + if _, err = iprot.ReadStructBegin(); err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, err = iprot.ReadFieldBegin() + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + + switch fieldId { + case 0: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField0(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + } + if err = iprot.ReadFieldEnd(); err != nil { + goto ReadFieldEndError + } + } + if err = iprot.ReadStructEnd(); err != nil { + goto ReadStructEndError + } + + return nil +ReadStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceFetchResourceResult[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) + +ReadFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *FrontendServiceFetchResourceResult) ReadField0(iprot thrift.TProtocol) error { + _field := masterservice.NewTFetchResourceResult_() + if err := _field.Read(iprot); err != nil { + return err + } + p.Success = _field + return nil +} + +func (p *FrontendServiceFetchResourceResult) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("fetchResource_result"); err != nil { + goto WriteStructBeginError + } + if p != nil { + if err = p.writeField0(oprot); err != nil { + fieldId = 0 + goto WriteFieldError + } + } + if err = oprot.WriteFieldStop(); err != nil { + goto WriteFieldStopError + } + if err = oprot.WriteStructEnd(); err != nil { + goto WriteStructEndError + } + return nil +WriteStructBeginError: + return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) +WriteFieldStopError: + return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) +WriteStructEndError: + return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) +} + +func (p *FrontendServiceFetchResourceResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -80468,15 +81879,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *FrontendServiceReportResult) String() string { +func (p *FrontendServiceFetchResourceResult) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceReportResult(%+v)", *p) + return fmt.Sprintf("FrontendServiceFetchResourceResult(%+v)", *p) } -func (p *FrontendServiceReportResult) DeepEqual(ano *FrontendServiceReportResult) bool { +func (p *FrontendServiceFetchResourceResult) DeepEqual(ano *FrontendServiceFetchResourceResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -80488,7 +81899,7 @@ func (p *FrontendServiceReportResult) DeepEqual(ano *FrontendServiceReportResult return true } -func (p *FrontendServiceReportResult) Field0DeepEqual(src *masterservice.TMasterResult_) bool { +func (p *FrontendServiceFetchResourceResult) Field0DeepEqual(src *masterservice.TFetchResourceResult_) bool { if !p.Success.DeepEqual(src) { return false @@ -80496,19 +81907,38 @@ func (p *FrontendServiceReportResult) Field0DeepEqual(src *masterservice.TMaster return true } -type FrontendServiceFetchResourceArgs struct { +type FrontendServiceForwardArgs struct { + Params *TMasterOpRequest `thrift:"params,1" frugal:"1,default,TMasterOpRequest" json:"params"` } -func NewFrontendServiceFetchResourceArgs() *FrontendServiceFetchResourceArgs { - return &FrontendServiceFetchResourceArgs{} +func NewFrontendServiceForwardArgs() *FrontendServiceForwardArgs { + return &FrontendServiceForwardArgs{} } -func (p *FrontendServiceFetchResourceArgs) InitDefault() { +func (p *FrontendServiceForwardArgs) InitDefault() { } -var fieldIDToName_FrontendServiceFetchResourceArgs = map[int16]string{} +var FrontendServiceForwardArgs_Params_DEFAULT *TMasterOpRequest -func (p *FrontendServiceFetchResourceArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceForwardArgs) GetParams() (v *TMasterOpRequest) { + if !p.IsSetParams() { + return FrontendServiceForwardArgs_Params_DEFAULT + } + return p.Params +} +func (p *FrontendServiceForwardArgs) SetParams(val *TMasterOpRequest) { + p.Params = val +} + +var fieldIDToName_FrontendServiceForwardArgs = map[int16]string{ + 1: "params", +} + +func (p *FrontendServiceForwardArgs) IsSetParams() bool { + return p.Params != nil +} + +func (p *FrontendServiceForwardArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -80525,8 +81955,20 @@ func (p *FrontendServiceFetchResourceArgs) Read(iprot thrift.TProtocol) (err err if fieldTypeId == thrift.STOP { break } - if err = iprot.Skip(fieldTypeId); err != nil { - goto SkipFieldTypeError + + switch fieldId { + case 1: + if fieldTypeId == thrift.STRUCT { + if err = p.ReadField1(iprot); err != nil { + goto ReadFieldError + } + } else if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } + default: + if err = iprot.Skip(fieldTypeId); err != nil { + goto SkipFieldError + } } if err = iprot.ReadFieldEnd(); err != nil { goto ReadFieldEndError @@ -80541,8 +81983,10 @@ ReadStructBeginError: return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) -SkipFieldTypeError: - return thrift.PrependError(fmt.Sprintf("%T skip field type %d error", p, fieldTypeId), err) +ReadFieldError: + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceForwardArgs[fieldId]), err) +SkipFieldError: + return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) ReadFieldEndError: return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) @@ -80550,11 +81994,25 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceFetchResourceArgs) Write(oprot thrift.TProtocol) (err error) { - if err = oprot.WriteStructBegin("fetchResource_args"); err != nil { +func (p *FrontendServiceForwardArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewTMasterOpRequest() + if err := _field.Read(iprot); err != nil { + return err + } + p.Params = _field + return nil +} + +func (p *FrontendServiceForwardArgs) Write(oprot thrift.TProtocol) (err error) { + var fieldId int16 + if err = oprot.WriteStructBegin("forward_args"); err != nil { goto WriteStructBeginError } if p != nil { + if err = p.writeField1(oprot); err != nil { + fieldId = 1 + goto WriteFieldError + } } if err = oprot.WriteFieldStop(); err != nil { goto WriteFieldStopError @@ -80565,61 +82023,91 @@ func (p *FrontendServiceFetchResourceArgs) Write(oprot thrift.TProtocol) (err er return nil WriteStructBeginError: return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) +WriteFieldError: + return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err) WriteFieldStopError: return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err) WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceFetchResourceArgs) String() string { +func (p *FrontendServiceForwardArgs) writeField1(oprot thrift.TProtocol) (err error) { + if err = oprot.WriteFieldBegin("params", thrift.STRUCT, 1); err != nil { + goto WriteFieldBeginError + } + if err := p.Params.Write(oprot); err != nil { + return err + } + if err = oprot.WriteFieldEnd(); err != nil { + goto WriteFieldEndError + } + return nil +WriteFieldBeginError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err) +WriteFieldEndError: + return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) +} + +func (p *FrontendServiceForwardArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceFetchResourceArgs(%+v)", *p) + return fmt.Sprintf("FrontendServiceForwardArgs(%+v)", *p) } -func (p *FrontendServiceFetchResourceArgs) DeepEqual(ano *FrontendServiceFetchResourceArgs) bool { +func (p *FrontendServiceForwardArgs) DeepEqual(ano *FrontendServiceForwardArgs) bool { if p == ano { return true } else if p == nil || ano == nil { return false } + if !p.Field1DeepEqual(ano.Params) { + return false + } return true } -type FrontendServiceFetchResourceResult struct { - Success *masterservice.TFetchResourceResult_ `thrift:"success,0,optional" frugal:"0,optional,masterservice.TFetchResourceResult_" json:"success,omitempty"` +func (p *FrontendServiceForwardArgs) Field1DeepEqual(src *TMasterOpRequest) bool { + + if !p.Params.DeepEqual(src) { + return false + } + return true } -func NewFrontendServiceFetchResourceResult() *FrontendServiceFetchResourceResult { - return &FrontendServiceFetchResourceResult{} +type FrontendServiceForwardResult struct { + Success *TMasterOpResult_ `thrift:"success,0,optional" frugal:"0,optional,TMasterOpResult_" json:"success,omitempty"` } -func (p *FrontendServiceFetchResourceResult) InitDefault() { +func NewFrontendServiceForwardResult() *FrontendServiceForwardResult { + return &FrontendServiceForwardResult{} } -var FrontendServiceFetchResourceResult_Success_DEFAULT *masterservice.TFetchResourceResult_ +func (p *FrontendServiceForwardResult) InitDefault() { +} -func (p *FrontendServiceFetchResourceResult) GetSuccess() (v *masterservice.TFetchResourceResult_) { +var FrontendServiceForwardResult_Success_DEFAULT *TMasterOpResult_ + +func (p *FrontendServiceForwardResult) GetSuccess() (v *TMasterOpResult_) { if !p.IsSetSuccess() { - return FrontendServiceFetchResourceResult_Success_DEFAULT + return FrontendServiceForwardResult_Success_DEFAULT } return p.Success } -func (p *FrontendServiceFetchResourceResult) SetSuccess(x interface{}) { - p.Success = x.(*masterservice.TFetchResourceResult_) +func (p *FrontendServiceForwardResult) SetSuccess(x interface{}) { + p.Success = x.(*TMasterOpResult_) } -var fieldIDToName_FrontendServiceFetchResourceResult = map[int16]string{ +var fieldIDToName_FrontendServiceForwardResult = map[int16]string{ 0: "success", } -func (p *FrontendServiceFetchResourceResult) IsSetSuccess() bool { +func (p *FrontendServiceForwardResult) IsSetSuccess() bool { return p.Success != nil } -func (p *FrontendServiceFetchResourceResult) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceForwardResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -80665,7 +82153,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceFetchResourceResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceForwardResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -80675,8 +82163,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceFetchResourceResult) ReadField0(iprot thrift.TProtocol) error { - _field := masterservice.NewTFetchResourceResult_() +func (p *FrontendServiceForwardResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewTMasterOpResult_() if err := _field.Read(iprot); err != nil { return err } @@ -80684,9 +82172,9 @@ func (p *FrontendServiceFetchResourceResult) ReadField0(iprot thrift.TProtocol) return nil } -func (p *FrontendServiceFetchResourceResult) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceForwardResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("fetchResource_result"); err != nil { + if err = oprot.WriteStructBegin("forward_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -80712,7 +82200,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceFetchResourceResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceForwardResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -80731,15 +82219,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *FrontendServiceFetchResourceResult) String() string { +func (p *FrontendServiceForwardResult) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceFetchResourceResult(%+v)", *p) + return fmt.Sprintf("FrontendServiceForwardResult(%+v)", *p) } -func (p *FrontendServiceFetchResourceResult) DeepEqual(ano *FrontendServiceFetchResourceResult) bool { +func (p *FrontendServiceForwardResult) DeepEqual(ano *FrontendServiceForwardResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -80751,7 +82239,7 @@ func (p *FrontendServiceFetchResourceResult) DeepEqual(ano *FrontendServiceFetch return true } -func (p *FrontendServiceFetchResourceResult) Field0DeepEqual(src *masterservice.TFetchResourceResult_) bool { +func (p *FrontendServiceForwardResult) Field0DeepEqual(src *TMasterOpResult_) bool { if !p.Success.DeepEqual(src) { return false @@ -80759,38 +82247,38 @@ func (p *FrontendServiceFetchResourceResult) Field0DeepEqual(src *masterservice. return true } -type FrontendServiceForwardArgs struct { - Params *TMasterOpRequest `thrift:"params,1" frugal:"1,default,TMasterOpRequest" json:"params"` +type FrontendServiceListTableStatusArgs struct { + Params *TGetTablesParams `thrift:"params,1" frugal:"1,default,TGetTablesParams" json:"params"` } -func NewFrontendServiceForwardArgs() *FrontendServiceForwardArgs { - return &FrontendServiceForwardArgs{} +func NewFrontendServiceListTableStatusArgs() *FrontendServiceListTableStatusArgs { + return &FrontendServiceListTableStatusArgs{} } -func (p *FrontendServiceForwardArgs) InitDefault() { +func (p *FrontendServiceListTableStatusArgs) InitDefault() { } -var FrontendServiceForwardArgs_Params_DEFAULT *TMasterOpRequest +var FrontendServiceListTableStatusArgs_Params_DEFAULT *TGetTablesParams -func (p *FrontendServiceForwardArgs) GetParams() (v *TMasterOpRequest) { +func (p *FrontendServiceListTableStatusArgs) GetParams() (v *TGetTablesParams) { if !p.IsSetParams() { - return FrontendServiceForwardArgs_Params_DEFAULT + return FrontendServiceListTableStatusArgs_Params_DEFAULT } return p.Params } -func (p *FrontendServiceForwardArgs) SetParams(val *TMasterOpRequest) { +func (p *FrontendServiceListTableStatusArgs) SetParams(val *TGetTablesParams) { p.Params = val } -var fieldIDToName_FrontendServiceForwardArgs = map[int16]string{ +var fieldIDToName_FrontendServiceListTableStatusArgs = map[int16]string{ 1: "params", } -func (p *FrontendServiceForwardArgs) IsSetParams() bool { +func (p *FrontendServiceListTableStatusArgs) IsSetParams() bool { return p.Params != nil } -func (p *FrontendServiceForwardArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListTableStatusArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -80836,7 +82324,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceForwardArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceListTableStatusArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -80846,8 +82334,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceForwardArgs) ReadField1(iprot thrift.TProtocol) error { - _field := NewTMasterOpRequest() +func (p *FrontendServiceListTableStatusArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewTGetTablesParams() if err := _field.Read(iprot); err != nil { return err } @@ -80855,9 +82343,9 @@ func (p *FrontendServiceForwardArgs) ReadField1(iprot thrift.TProtocol) error { return nil } -func (p *FrontendServiceForwardArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListTableStatusArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("forward_args"); err != nil { + if err = oprot.WriteStructBegin("listTableStatus_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -80883,7 +82371,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceForwardArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListTableStatusArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("params", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -80900,15 +82388,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *FrontendServiceForwardArgs) String() string { +func (p *FrontendServiceListTableStatusArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceForwardArgs(%+v)", *p) + return fmt.Sprintf("FrontendServiceListTableStatusArgs(%+v)", *p) } -func (p *FrontendServiceForwardArgs) DeepEqual(ano *FrontendServiceForwardArgs) bool { +func (p *FrontendServiceListTableStatusArgs) DeepEqual(ano *FrontendServiceListTableStatusArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -80920,7 +82408,7 @@ func (p *FrontendServiceForwardArgs) DeepEqual(ano *FrontendServiceForwardArgs) return true } -func (p *FrontendServiceForwardArgs) Field1DeepEqual(src *TMasterOpRequest) bool { +func (p *FrontendServiceListTableStatusArgs) Field1DeepEqual(src *TGetTablesParams) bool { if !p.Params.DeepEqual(src) { return false @@ -80928,38 +82416,38 @@ func (p *FrontendServiceForwardArgs) Field1DeepEqual(src *TMasterOpRequest) bool return true } -type FrontendServiceForwardResult struct { - Success *TMasterOpResult_ `thrift:"success,0,optional" frugal:"0,optional,TMasterOpResult_" json:"success,omitempty"` +type FrontendServiceListTableStatusResult struct { + Success *TListTableStatusResult_ `thrift:"success,0,optional" frugal:"0,optional,TListTableStatusResult_" json:"success,omitempty"` } -func NewFrontendServiceForwardResult() *FrontendServiceForwardResult { - return &FrontendServiceForwardResult{} +func NewFrontendServiceListTableStatusResult() *FrontendServiceListTableStatusResult { + return &FrontendServiceListTableStatusResult{} } -func (p *FrontendServiceForwardResult) InitDefault() { +func (p *FrontendServiceListTableStatusResult) InitDefault() { } -var FrontendServiceForwardResult_Success_DEFAULT *TMasterOpResult_ +var FrontendServiceListTableStatusResult_Success_DEFAULT *TListTableStatusResult_ -func (p *FrontendServiceForwardResult) GetSuccess() (v *TMasterOpResult_) { +func (p *FrontendServiceListTableStatusResult) GetSuccess() (v *TListTableStatusResult_) { if !p.IsSetSuccess() { - return FrontendServiceForwardResult_Success_DEFAULT + return FrontendServiceListTableStatusResult_Success_DEFAULT } return p.Success } -func (p *FrontendServiceForwardResult) SetSuccess(x interface{}) { - p.Success = x.(*TMasterOpResult_) +func (p *FrontendServiceListTableStatusResult) SetSuccess(x interface{}) { + p.Success = x.(*TListTableStatusResult_) } -var fieldIDToName_FrontendServiceForwardResult = map[int16]string{ +var fieldIDToName_FrontendServiceListTableStatusResult = map[int16]string{ 0: "success", } -func (p *FrontendServiceForwardResult) IsSetSuccess() bool { +func (p *FrontendServiceListTableStatusResult) IsSetSuccess() bool { return p.Success != nil } -func (p *FrontendServiceForwardResult) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListTableStatusResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -81005,7 +82493,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceForwardResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceListTableStatusResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -81015,8 +82503,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceForwardResult) ReadField0(iprot thrift.TProtocol) error { - _field := NewTMasterOpResult_() +func (p *FrontendServiceListTableStatusResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewTListTableStatusResult_() if err := _field.Read(iprot); err != nil { return err } @@ -81024,9 +82512,9 @@ func (p *FrontendServiceForwardResult) ReadField0(iprot thrift.TProtocol) error return nil } -func (p *FrontendServiceForwardResult) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListTableStatusResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("forward_result"); err != nil { + if err = oprot.WriteStructBegin("listTableStatus_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -81052,7 +82540,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceForwardResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListTableStatusResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -81071,15 +82559,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *FrontendServiceForwardResult) String() string { +func (p *FrontendServiceListTableStatusResult) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceForwardResult(%+v)", *p) + return fmt.Sprintf("FrontendServiceListTableStatusResult(%+v)", *p) } -func (p *FrontendServiceForwardResult) DeepEqual(ano *FrontendServiceForwardResult) bool { +func (p *FrontendServiceListTableStatusResult) DeepEqual(ano *FrontendServiceListTableStatusResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -81091,7 +82579,7 @@ func (p *FrontendServiceForwardResult) DeepEqual(ano *FrontendServiceForwardResu return true } -func (p *FrontendServiceForwardResult) Field0DeepEqual(src *TMasterOpResult_) bool { +func (p *FrontendServiceListTableStatusResult) Field0DeepEqual(src *TListTableStatusResult_) bool { if !p.Success.DeepEqual(src) { return false @@ -81099,38 +82587,38 @@ func (p *FrontendServiceForwardResult) Field0DeepEqual(src *TMasterOpResult_) bo return true } -type FrontendServiceListTableStatusArgs struct { +type FrontendServiceListTableMetadataNameIdsArgs struct { Params *TGetTablesParams `thrift:"params,1" frugal:"1,default,TGetTablesParams" json:"params"` } -func NewFrontendServiceListTableStatusArgs() *FrontendServiceListTableStatusArgs { - return &FrontendServiceListTableStatusArgs{} +func NewFrontendServiceListTableMetadataNameIdsArgs() *FrontendServiceListTableMetadataNameIdsArgs { + return &FrontendServiceListTableMetadataNameIdsArgs{} } -func (p *FrontendServiceListTableStatusArgs) InitDefault() { +func (p *FrontendServiceListTableMetadataNameIdsArgs) InitDefault() { } -var FrontendServiceListTableStatusArgs_Params_DEFAULT *TGetTablesParams +var FrontendServiceListTableMetadataNameIdsArgs_Params_DEFAULT *TGetTablesParams -func (p *FrontendServiceListTableStatusArgs) GetParams() (v *TGetTablesParams) { +func (p *FrontendServiceListTableMetadataNameIdsArgs) GetParams() (v *TGetTablesParams) { if !p.IsSetParams() { - return FrontendServiceListTableStatusArgs_Params_DEFAULT + return FrontendServiceListTableMetadataNameIdsArgs_Params_DEFAULT } return p.Params } -func (p *FrontendServiceListTableStatusArgs) SetParams(val *TGetTablesParams) { +func (p *FrontendServiceListTableMetadataNameIdsArgs) SetParams(val *TGetTablesParams) { p.Params = val } -var fieldIDToName_FrontendServiceListTableStatusArgs = map[int16]string{ +var fieldIDToName_FrontendServiceListTableMetadataNameIdsArgs = map[int16]string{ 1: "params", } -func (p *FrontendServiceListTableStatusArgs) IsSetParams() bool { +func (p *FrontendServiceListTableMetadataNameIdsArgs) IsSetParams() bool { return p.Params != nil } -func (p *FrontendServiceListTableStatusArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListTableMetadataNameIdsArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -81176,7 +82664,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceListTableStatusArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceListTableMetadataNameIdsArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -81186,7 +82674,7 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceListTableStatusArgs) ReadField1(iprot thrift.TProtocol) error { +func (p *FrontendServiceListTableMetadataNameIdsArgs) ReadField1(iprot thrift.TProtocol) error { _field := NewTGetTablesParams() if err := _field.Read(iprot); err != nil { return err @@ -81195,9 +82683,9 @@ func (p *FrontendServiceListTableStatusArgs) ReadField1(iprot thrift.TProtocol) return nil } -func (p *FrontendServiceListTableStatusArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListTableMetadataNameIdsArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("listTableStatus_args"); err != nil { + if err = oprot.WriteStructBegin("listTableMetadataNameIds_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -81223,7 +82711,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceListTableStatusArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListTableMetadataNameIdsArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("params", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -81240,15 +82728,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *FrontendServiceListTableStatusArgs) String() string { +func (p *FrontendServiceListTableMetadataNameIdsArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceListTableStatusArgs(%+v)", *p) + return fmt.Sprintf("FrontendServiceListTableMetadataNameIdsArgs(%+v)", *p) } -func (p *FrontendServiceListTableStatusArgs) DeepEqual(ano *FrontendServiceListTableStatusArgs) bool { +func (p *FrontendServiceListTableMetadataNameIdsArgs) DeepEqual(ano *FrontendServiceListTableMetadataNameIdsArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -81260,7 +82748,7 @@ func (p *FrontendServiceListTableStatusArgs) DeepEqual(ano *FrontendServiceListT return true } -func (p *FrontendServiceListTableStatusArgs) Field1DeepEqual(src *TGetTablesParams) bool { +func (p *FrontendServiceListTableMetadataNameIdsArgs) Field1DeepEqual(src *TGetTablesParams) bool { if !p.Params.DeepEqual(src) { return false @@ -81268,38 +82756,38 @@ func (p *FrontendServiceListTableStatusArgs) Field1DeepEqual(src *TGetTablesPara return true } -type FrontendServiceListTableStatusResult struct { - Success *TListTableStatusResult_ `thrift:"success,0,optional" frugal:"0,optional,TListTableStatusResult_" json:"success,omitempty"` +type FrontendServiceListTableMetadataNameIdsResult struct { + Success *TListTableMetadataNameIdsResult_ `thrift:"success,0,optional" frugal:"0,optional,TListTableMetadataNameIdsResult_" json:"success,omitempty"` } -func NewFrontendServiceListTableStatusResult() *FrontendServiceListTableStatusResult { - return &FrontendServiceListTableStatusResult{} +func NewFrontendServiceListTableMetadataNameIdsResult() *FrontendServiceListTableMetadataNameIdsResult { + return &FrontendServiceListTableMetadataNameIdsResult{} } -func (p *FrontendServiceListTableStatusResult) InitDefault() { +func (p *FrontendServiceListTableMetadataNameIdsResult) InitDefault() { } -var FrontendServiceListTableStatusResult_Success_DEFAULT *TListTableStatusResult_ +var FrontendServiceListTableMetadataNameIdsResult_Success_DEFAULT *TListTableMetadataNameIdsResult_ -func (p *FrontendServiceListTableStatusResult) GetSuccess() (v *TListTableStatusResult_) { +func (p *FrontendServiceListTableMetadataNameIdsResult) GetSuccess() (v *TListTableMetadataNameIdsResult_) { if !p.IsSetSuccess() { - return FrontendServiceListTableStatusResult_Success_DEFAULT + return FrontendServiceListTableMetadataNameIdsResult_Success_DEFAULT } return p.Success } -func (p *FrontendServiceListTableStatusResult) SetSuccess(x interface{}) { - p.Success = x.(*TListTableStatusResult_) +func (p *FrontendServiceListTableMetadataNameIdsResult) SetSuccess(x interface{}) { + p.Success = x.(*TListTableMetadataNameIdsResult_) } -var fieldIDToName_FrontendServiceListTableStatusResult = map[int16]string{ +var fieldIDToName_FrontendServiceListTableMetadataNameIdsResult = map[int16]string{ 0: "success", } -func (p *FrontendServiceListTableStatusResult) IsSetSuccess() bool { +func (p *FrontendServiceListTableMetadataNameIdsResult) IsSetSuccess() bool { return p.Success != nil } -func (p *FrontendServiceListTableStatusResult) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListTableMetadataNameIdsResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -81345,7 +82833,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceListTableStatusResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceListTableMetadataNameIdsResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -81355,8 +82843,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceListTableStatusResult) ReadField0(iprot thrift.TProtocol) error { - _field := NewTListTableStatusResult_() +func (p *FrontendServiceListTableMetadataNameIdsResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewTListTableMetadataNameIdsResult_() if err := _field.Read(iprot); err != nil { return err } @@ -81364,9 +82852,9 @@ func (p *FrontendServiceListTableStatusResult) ReadField0(iprot thrift.TProtocol return nil } -func (p *FrontendServiceListTableStatusResult) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListTableMetadataNameIdsResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("listTableStatus_result"); err != nil { + if err = oprot.WriteStructBegin("listTableMetadataNameIds_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -81392,7 +82880,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceListTableStatusResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListTableMetadataNameIdsResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -81411,15 +82899,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *FrontendServiceListTableStatusResult) String() string { +func (p *FrontendServiceListTableMetadataNameIdsResult) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceListTableStatusResult(%+v)", *p) + return fmt.Sprintf("FrontendServiceListTableMetadataNameIdsResult(%+v)", *p) } -func (p *FrontendServiceListTableStatusResult) DeepEqual(ano *FrontendServiceListTableStatusResult) bool { +func (p *FrontendServiceListTableMetadataNameIdsResult) DeepEqual(ano *FrontendServiceListTableMetadataNameIdsResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -81431,7 +82919,7 @@ func (p *FrontendServiceListTableStatusResult) DeepEqual(ano *FrontendServiceLis return true } -func (p *FrontendServiceListTableStatusResult) Field0DeepEqual(src *TListTableStatusResult_) bool { +func (p *FrontendServiceListTableMetadataNameIdsResult) Field0DeepEqual(src *TListTableMetadataNameIdsResult_) bool { if !p.Success.DeepEqual(src) { return false @@ -81439,38 +82927,38 @@ func (p *FrontendServiceListTableStatusResult) Field0DeepEqual(src *TListTableSt return true } -type FrontendServiceListTableMetadataNameIdsArgs struct { +type FrontendServiceListTablePrivilegeStatusArgs struct { Params *TGetTablesParams `thrift:"params,1" frugal:"1,default,TGetTablesParams" json:"params"` } -func NewFrontendServiceListTableMetadataNameIdsArgs() *FrontendServiceListTableMetadataNameIdsArgs { - return &FrontendServiceListTableMetadataNameIdsArgs{} +func NewFrontendServiceListTablePrivilegeStatusArgs() *FrontendServiceListTablePrivilegeStatusArgs { + return &FrontendServiceListTablePrivilegeStatusArgs{} } -func (p *FrontendServiceListTableMetadataNameIdsArgs) InitDefault() { +func (p *FrontendServiceListTablePrivilegeStatusArgs) InitDefault() { } -var FrontendServiceListTableMetadataNameIdsArgs_Params_DEFAULT *TGetTablesParams +var FrontendServiceListTablePrivilegeStatusArgs_Params_DEFAULT *TGetTablesParams -func (p *FrontendServiceListTableMetadataNameIdsArgs) GetParams() (v *TGetTablesParams) { +func (p *FrontendServiceListTablePrivilegeStatusArgs) GetParams() (v *TGetTablesParams) { if !p.IsSetParams() { - return FrontendServiceListTableMetadataNameIdsArgs_Params_DEFAULT + return FrontendServiceListTablePrivilegeStatusArgs_Params_DEFAULT } return p.Params } -func (p *FrontendServiceListTableMetadataNameIdsArgs) SetParams(val *TGetTablesParams) { +func (p *FrontendServiceListTablePrivilegeStatusArgs) SetParams(val *TGetTablesParams) { p.Params = val } -var fieldIDToName_FrontendServiceListTableMetadataNameIdsArgs = map[int16]string{ +var fieldIDToName_FrontendServiceListTablePrivilegeStatusArgs = map[int16]string{ 1: "params", } -func (p *FrontendServiceListTableMetadataNameIdsArgs) IsSetParams() bool { +func (p *FrontendServiceListTablePrivilegeStatusArgs) IsSetParams() bool { return p.Params != nil } -func (p *FrontendServiceListTableMetadataNameIdsArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListTablePrivilegeStatusArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -81516,7 +83004,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceListTableMetadataNameIdsArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceListTablePrivilegeStatusArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -81526,7 +83014,7 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceListTableMetadataNameIdsArgs) ReadField1(iprot thrift.TProtocol) error { +func (p *FrontendServiceListTablePrivilegeStatusArgs) ReadField1(iprot thrift.TProtocol) error { _field := NewTGetTablesParams() if err := _field.Read(iprot); err != nil { return err @@ -81535,9 +83023,9 @@ func (p *FrontendServiceListTableMetadataNameIdsArgs) ReadField1(iprot thrift.TP return nil } -func (p *FrontendServiceListTableMetadataNameIdsArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListTablePrivilegeStatusArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("listTableMetadataNameIds_args"); err != nil { + if err = oprot.WriteStructBegin("listTablePrivilegeStatus_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -81563,7 +83051,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceListTableMetadataNameIdsArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListTablePrivilegeStatusArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("params", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -81580,15 +83068,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *FrontendServiceListTableMetadataNameIdsArgs) String() string { +func (p *FrontendServiceListTablePrivilegeStatusArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceListTableMetadataNameIdsArgs(%+v)", *p) + return fmt.Sprintf("FrontendServiceListTablePrivilegeStatusArgs(%+v)", *p) } -func (p *FrontendServiceListTableMetadataNameIdsArgs) DeepEqual(ano *FrontendServiceListTableMetadataNameIdsArgs) bool { +func (p *FrontendServiceListTablePrivilegeStatusArgs) DeepEqual(ano *FrontendServiceListTablePrivilegeStatusArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -81600,7 +83088,7 @@ func (p *FrontendServiceListTableMetadataNameIdsArgs) DeepEqual(ano *FrontendSer return true } -func (p *FrontendServiceListTableMetadataNameIdsArgs) Field1DeepEqual(src *TGetTablesParams) bool { +func (p *FrontendServiceListTablePrivilegeStatusArgs) Field1DeepEqual(src *TGetTablesParams) bool { if !p.Params.DeepEqual(src) { return false @@ -81608,38 +83096,38 @@ func (p *FrontendServiceListTableMetadataNameIdsArgs) Field1DeepEqual(src *TGetT return true } -type FrontendServiceListTableMetadataNameIdsResult struct { - Success *TListTableMetadataNameIdsResult_ `thrift:"success,0,optional" frugal:"0,optional,TListTableMetadataNameIdsResult_" json:"success,omitempty"` +type FrontendServiceListTablePrivilegeStatusResult struct { + Success *TListPrivilegesResult_ `thrift:"success,0,optional" frugal:"0,optional,TListPrivilegesResult_" json:"success,omitempty"` } -func NewFrontendServiceListTableMetadataNameIdsResult() *FrontendServiceListTableMetadataNameIdsResult { - return &FrontendServiceListTableMetadataNameIdsResult{} +func NewFrontendServiceListTablePrivilegeStatusResult() *FrontendServiceListTablePrivilegeStatusResult { + return &FrontendServiceListTablePrivilegeStatusResult{} } -func (p *FrontendServiceListTableMetadataNameIdsResult) InitDefault() { +func (p *FrontendServiceListTablePrivilegeStatusResult) InitDefault() { } -var FrontendServiceListTableMetadataNameIdsResult_Success_DEFAULT *TListTableMetadataNameIdsResult_ +var FrontendServiceListTablePrivilegeStatusResult_Success_DEFAULT *TListPrivilegesResult_ -func (p *FrontendServiceListTableMetadataNameIdsResult) GetSuccess() (v *TListTableMetadataNameIdsResult_) { +func (p *FrontendServiceListTablePrivilegeStatusResult) GetSuccess() (v *TListPrivilegesResult_) { if !p.IsSetSuccess() { - return FrontendServiceListTableMetadataNameIdsResult_Success_DEFAULT + return FrontendServiceListTablePrivilegeStatusResult_Success_DEFAULT } return p.Success } -func (p *FrontendServiceListTableMetadataNameIdsResult) SetSuccess(x interface{}) { - p.Success = x.(*TListTableMetadataNameIdsResult_) +func (p *FrontendServiceListTablePrivilegeStatusResult) SetSuccess(x interface{}) { + p.Success = x.(*TListPrivilegesResult_) } -var fieldIDToName_FrontendServiceListTableMetadataNameIdsResult = map[int16]string{ +var fieldIDToName_FrontendServiceListTablePrivilegeStatusResult = map[int16]string{ 0: "success", } -func (p *FrontendServiceListTableMetadataNameIdsResult) IsSetSuccess() bool { +func (p *FrontendServiceListTablePrivilegeStatusResult) IsSetSuccess() bool { return p.Success != nil } -func (p *FrontendServiceListTableMetadataNameIdsResult) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListTablePrivilegeStatusResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -81685,7 +83173,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceListTableMetadataNameIdsResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceListTablePrivilegeStatusResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -81695,8 +83183,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceListTableMetadataNameIdsResult) ReadField0(iprot thrift.TProtocol) error { - _field := NewTListTableMetadataNameIdsResult_() +func (p *FrontendServiceListTablePrivilegeStatusResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewTListPrivilegesResult_() if err := _field.Read(iprot); err != nil { return err } @@ -81704,9 +83192,9 @@ func (p *FrontendServiceListTableMetadataNameIdsResult) ReadField0(iprot thrift. return nil } -func (p *FrontendServiceListTableMetadataNameIdsResult) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListTablePrivilegeStatusResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("listTableMetadataNameIds_result"); err != nil { + if err = oprot.WriteStructBegin("listTablePrivilegeStatus_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -81732,7 +83220,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceListTableMetadataNameIdsResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListTablePrivilegeStatusResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -81751,15 +83239,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *FrontendServiceListTableMetadataNameIdsResult) String() string { +func (p *FrontendServiceListTablePrivilegeStatusResult) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceListTableMetadataNameIdsResult(%+v)", *p) + return fmt.Sprintf("FrontendServiceListTablePrivilegeStatusResult(%+v)", *p) } -func (p *FrontendServiceListTableMetadataNameIdsResult) DeepEqual(ano *FrontendServiceListTableMetadataNameIdsResult) bool { +func (p *FrontendServiceListTablePrivilegeStatusResult) DeepEqual(ano *FrontendServiceListTablePrivilegeStatusResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -81771,7 +83259,7 @@ func (p *FrontendServiceListTableMetadataNameIdsResult) DeepEqual(ano *FrontendS return true } -func (p *FrontendServiceListTableMetadataNameIdsResult) Field0DeepEqual(src *TListTableMetadataNameIdsResult_) bool { +func (p *FrontendServiceListTablePrivilegeStatusResult) Field0DeepEqual(src *TListPrivilegesResult_) bool { if !p.Success.DeepEqual(src) { return false @@ -81779,38 +83267,38 @@ func (p *FrontendServiceListTableMetadataNameIdsResult) Field0DeepEqual(src *TLi return true } -type FrontendServiceListTablePrivilegeStatusArgs struct { +type FrontendServiceListSchemaPrivilegeStatusArgs struct { Params *TGetTablesParams `thrift:"params,1" frugal:"1,default,TGetTablesParams" json:"params"` } -func NewFrontendServiceListTablePrivilegeStatusArgs() *FrontendServiceListTablePrivilegeStatusArgs { - return &FrontendServiceListTablePrivilegeStatusArgs{} +func NewFrontendServiceListSchemaPrivilegeStatusArgs() *FrontendServiceListSchemaPrivilegeStatusArgs { + return &FrontendServiceListSchemaPrivilegeStatusArgs{} } -func (p *FrontendServiceListTablePrivilegeStatusArgs) InitDefault() { +func (p *FrontendServiceListSchemaPrivilegeStatusArgs) InitDefault() { } -var FrontendServiceListTablePrivilegeStatusArgs_Params_DEFAULT *TGetTablesParams +var FrontendServiceListSchemaPrivilegeStatusArgs_Params_DEFAULT *TGetTablesParams -func (p *FrontendServiceListTablePrivilegeStatusArgs) GetParams() (v *TGetTablesParams) { +func (p *FrontendServiceListSchemaPrivilegeStatusArgs) GetParams() (v *TGetTablesParams) { if !p.IsSetParams() { - return FrontendServiceListTablePrivilegeStatusArgs_Params_DEFAULT + return FrontendServiceListSchemaPrivilegeStatusArgs_Params_DEFAULT } return p.Params } -func (p *FrontendServiceListTablePrivilegeStatusArgs) SetParams(val *TGetTablesParams) { +func (p *FrontendServiceListSchemaPrivilegeStatusArgs) SetParams(val *TGetTablesParams) { p.Params = val } -var fieldIDToName_FrontendServiceListTablePrivilegeStatusArgs = map[int16]string{ +var fieldIDToName_FrontendServiceListSchemaPrivilegeStatusArgs = map[int16]string{ 1: "params", } -func (p *FrontendServiceListTablePrivilegeStatusArgs) IsSetParams() bool { +func (p *FrontendServiceListSchemaPrivilegeStatusArgs) IsSetParams() bool { return p.Params != nil } -func (p *FrontendServiceListTablePrivilegeStatusArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListSchemaPrivilegeStatusArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -81856,7 +83344,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceListTablePrivilegeStatusArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceListSchemaPrivilegeStatusArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -81866,7 +83354,7 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceListTablePrivilegeStatusArgs) ReadField1(iprot thrift.TProtocol) error { +func (p *FrontendServiceListSchemaPrivilegeStatusArgs) ReadField1(iprot thrift.TProtocol) error { _field := NewTGetTablesParams() if err := _field.Read(iprot); err != nil { return err @@ -81875,9 +83363,9 @@ func (p *FrontendServiceListTablePrivilegeStatusArgs) ReadField1(iprot thrift.TP return nil } -func (p *FrontendServiceListTablePrivilegeStatusArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListSchemaPrivilegeStatusArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("listTablePrivilegeStatus_args"); err != nil { + if err = oprot.WriteStructBegin("listSchemaPrivilegeStatus_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -81903,7 +83391,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceListTablePrivilegeStatusArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListSchemaPrivilegeStatusArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("params", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -81920,15 +83408,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *FrontendServiceListTablePrivilegeStatusArgs) String() string { +func (p *FrontendServiceListSchemaPrivilegeStatusArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceListTablePrivilegeStatusArgs(%+v)", *p) + return fmt.Sprintf("FrontendServiceListSchemaPrivilegeStatusArgs(%+v)", *p) } -func (p *FrontendServiceListTablePrivilegeStatusArgs) DeepEqual(ano *FrontendServiceListTablePrivilegeStatusArgs) bool { +func (p *FrontendServiceListSchemaPrivilegeStatusArgs) DeepEqual(ano *FrontendServiceListSchemaPrivilegeStatusArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -81940,7 +83428,7 @@ func (p *FrontendServiceListTablePrivilegeStatusArgs) DeepEqual(ano *FrontendSer return true } -func (p *FrontendServiceListTablePrivilegeStatusArgs) Field1DeepEqual(src *TGetTablesParams) bool { +func (p *FrontendServiceListSchemaPrivilegeStatusArgs) Field1DeepEqual(src *TGetTablesParams) bool { if !p.Params.DeepEqual(src) { return false @@ -81948,38 +83436,38 @@ func (p *FrontendServiceListTablePrivilegeStatusArgs) Field1DeepEqual(src *TGetT return true } -type FrontendServiceListTablePrivilegeStatusResult struct { +type FrontendServiceListSchemaPrivilegeStatusResult struct { Success *TListPrivilegesResult_ `thrift:"success,0,optional" frugal:"0,optional,TListPrivilegesResult_" json:"success,omitempty"` } -func NewFrontendServiceListTablePrivilegeStatusResult() *FrontendServiceListTablePrivilegeStatusResult { - return &FrontendServiceListTablePrivilegeStatusResult{} +func NewFrontendServiceListSchemaPrivilegeStatusResult() *FrontendServiceListSchemaPrivilegeStatusResult { + return &FrontendServiceListSchemaPrivilegeStatusResult{} } -func (p *FrontendServiceListTablePrivilegeStatusResult) InitDefault() { +func (p *FrontendServiceListSchemaPrivilegeStatusResult) InitDefault() { } -var FrontendServiceListTablePrivilegeStatusResult_Success_DEFAULT *TListPrivilegesResult_ +var FrontendServiceListSchemaPrivilegeStatusResult_Success_DEFAULT *TListPrivilegesResult_ -func (p *FrontendServiceListTablePrivilegeStatusResult) GetSuccess() (v *TListPrivilegesResult_) { +func (p *FrontendServiceListSchemaPrivilegeStatusResult) GetSuccess() (v *TListPrivilegesResult_) { if !p.IsSetSuccess() { - return FrontendServiceListTablePrivilegeStatusResult_Success_DEFAULT + return FrontendServiceListSchemaPrivilegeStatusResult_Success_DEFAULT } return p.Success } -func (p *FrontendServiceListTablePrivilegeStatusResult) SetSuccess(x interface{}) { +func (p *FrontendServiceListSchemaPrivilegeStatusResult) SetSuccess(x interface{}) { p.Success = x.(*TListPrivilegesResult_) } -var fieldIDToName_FrontendServiceListTablePrivilegeStatusResult = map[int16]string{ +var fieldIDToName_FrontendServiceListSchemaPrivilegeStatusResult = map[int16]string{ 0: "success", } -func (p *FrontendServiceListTablePrivilegeStatusResult) IsSetSuccess() bool { +func (p *FrontendServiceListSchemaPrivilegeStatusResult) IsSetSuccess() bool { return p.Success != nil } -func (p *FrontendServiceListTablePrivilegeStatusResult) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListSchemaPrivilegeStatusResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -82025,7 +83513,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceListTablePrivilegeStatusResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceListSchemaPrivilegeStatusResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -82035,7 +83523,7 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceListTablePrivilegeStatusResult) ReadField0(iprot thrift.TProtocol) error { +func (p *FrontendServiceListSchemaPrivilegeStatusResult) ReadField0(iprot thrift.TProtocol) error { _field := NewTListPrivilegesResult_() if err := _field.Read(iprot); err != nil { return err @@ -82044,9 +83532,9 @@ func (p *FrontendServiceListTablePrivilegeStatusResult) ReadField0(iprot thrift. return nil } -func (p *FrontendServiceListTablePrivilegeStatusResult) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListSchemaPrivilegeStatusResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("listTablePrivilegeStatus_result"); err != nil { + if err = oprot.WriteStructBegin("listSchemaPrivilegeStatus_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -82072,7 +83560,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceListTablePrivilegeStatusResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListSchemaPrivilegeStatusResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -82091,15 +83579,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *FrontendServiceListTablePrivilegeStatusResult) String() string { +func (p *FrontendServiceListSchemaPrivilegeStatusResult) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceListTablePrivilegeStatusResult(%+v)", *p) + return fmt.Sprintf("FrontendServiceListSchemaPrivilegeStatusResult(%+v)", *p) } -func (p *FrontendServiceListTablePrivilegeStatusResult) DeepEqual(ano *FrontendServiceListTablePrivilegeStatusResult) bool { +func (p *FrontendServiceListSchemaPrivilegeStatusResult) DeepEqual(ano *FrontendServiceListSchemaPrivilegeStatusResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -82111,7 +83599,7 @@ func (p *FrontendServiceListTablePrivilegeStatusResult) DeepEqual(ano *FrontendS return true } -func (p *FrontendServiceListTablePrivilegeStatusResult) Field0DeepEqual(src *TListPrivilegesResult_) bool { +func (p *FrontendServiceListSchemaPrivilegeStatusResult) Field0DeepEqual(src *TListPrivilegesResult_) bool { if !p.Success.DeepEqual(src) { return false @@ -82119,38 +83607,38 @@ func (p *FrontendServiceListTablePrivilegeStatusResult) Field0DeepEqual(src *TLi return true } -type FrontendServiceListSchemaPrivilegeStatusArgs struct { +type FrontendServiceListUserPrivilegeStatusArgs struct { Params *TGetTablesParams `thrift:"params,1" frugal:"1,default,TGetTablesParams" json:"params"` } -func NewFrontendServiceListSchemaPrivilegeStatusArgs() *FrontendServiceListSchemaPrivilegeStatusArgs { - return &FrontendServiceListSchemaPrivilegeStatusArgs{} +func NewFrontendServiceListUserPrivilegeStatusArgs() *FrontendServiceListUserPrivilegeStatusArgs { + return &FrontendServiceListUserPrivilegeStatusArgs{} } -func (p *FrontendServiceListSchemaPrivilegeStatusArgs) InitDefault() { +func (p *FrontendServiceListUserPrivilegeStatusArgs) InitDefault() { } -var FrontendServiceListSchemaPrivilegeStatusArgs_Params_DEFAULT *TGetTablesParams +var FrontendServiceListUserPrivilegeStatusArgs_Params_DEFAULT *TGetTablesParams -func (p *FrontendServiceListSchemaPrivilegeStatusArgs) GetParams() (v *TGetTablesParams) { +func (p *FrontendServiceListUserPrivilegeStatusArgs) GetParams() (v *TGetTablesParams) { if !p.IsSetParams() { - return FrontendServiceListSchemaPrivilegeStatusArgs_Params_DEFAULT + return FrontendServiceListUserPrivilegeStatusArgs_Params_DEFAULT } return p.Params } -func (p *FrontendServiceListSchemaPrivilegeStatusArgs) SetParams(val *TGetTablesParams) { +func (p *FrontendServiceListUserPrivilegeStatusArgs) SetParams(val *TGetTablesParams) { p.Params = val } -var fieldIDToName_FrontendServiceListSchemaPrivilegeStatusArgs = map[int16]string{ +var fieldIDToName_FrontendServiceListUserPrivilegeStatusArgs = map[int16]string{ 1: "params", } -func (p *FrontendServiceListSchemaPrivilegeStatusArgs) IsSetParams() bool { +func (p *FrontendServiceListUserPrivilegeStatusArgs) IsSetParams() bool { return p.Params != nil } -func (p *FrontendServiceListSchemaPrivilegeStatusArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListUserPrivilegeStatusArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -82196,7 +83684,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceListSchemaPrivilegeStatusArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceListUserPrivilegeStatusArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -82206,7 +83694,7 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceListSchemaPrivilegeStatusArgs) ReadField1(iprot thrift.TProtocol) error { +func (p *FrontendServiceListUserPrivilegeStatusArgs) ReadField1(iprot thrift.TProtocol) error { _field := NewTGetTablesParams() if err := _field.Read(iprot); err != nil { return err @@ -82215,9 +83703,9 @@ func (p *FrontendServiceListSchemaPrivilegeStatusArgs) ReadField1(iprot thrift.T return nil } -func (p *FrontendServiceListSchemaPrivilegeStatusArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListUserPrivilegeStatusArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("listSchemaPrivilegeStatus_args"); err != nil { + if err = oprot.WriteStructBegin("listUserPrivilegeStatus_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -82243,7 +83731,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceListSchemaPrivilegeStatusArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListUserPrivilegeStatusArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("params", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -82260,15 +83748,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *FrontendServiceListSchemaPrivilegeStatusArgs) String() string { +func (p *FrontendServiceListUserPrivilegeStatusArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceListSchemaPrivilegeStatusArgs(%+v)", *p) + return fmt.Sprintf("FrontendServiceListUserPrivilegeStatusArgs(%+v)", *p) } -func (p *FrontendServiceListSchemaPrivilegeStatusArgs) DeepEqual(ano *FrontendServiceListSchemaPrivilegeStatusArgs) bool { +func (p *FrontendServiceListUserPrivilegeStatusArgs) DeepEqual(ano *FrontendServiceListUserPrivilegeStatusArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -82280,7 +83768,7 @@ func (p *FrontendServiceListSchemaPrivilegeStatusArgs) DeepEqual(ano *FrontendSe return true } -func (p *FrontendServiceListSchemaPrivilegeStatusArgs) Field1DeepEqual(src *TGetTablesParams) bool { +func (p *FrontendServiceListUserPrivilegeStatusArgs) Field1DeepEqual(src *TGetTablesParams) bool { if !p.Params.DeepEqual(src) { return false @@ -82288,38 +83776,38 @@ func (p *FrontendServiceListSchemaPrivilegeStatusArgs) Field1DeepEqual(src *TGet return true } -type FrontendServiceListSchemaPrivilegeStatusResult struct { +type FrontendServiceListUserPrivilegeStatusResult struct { Success *TListPrivilegesResult_ `thrift:"success,0,optional" frugal:"0,optional,TListPrivilegesResult_" json:"success,omitempty"` } -func NewFrontendServiceListSchemaPrivilegeStatusResult() *FrontendServiceListSchemaPrivilegeStatusResult { - return &FrontendServiceListSchemaPrivilegeStatusResult{} +func NewFrontendServiceListUserPrivilegeStatusResult() *FrontendServiceListUserPrivilegeStatusResult { + return &FrontendServiceListUserPrivilegeStatusResult{} } -func (p *FrontendServiceListSchemaPrivilegeStatusResult) InitDefault() { +func (p *FrontendServiceListUserPrivilegeStatusResult) InitDefault() { } -var FrontendServiceListSchemaPrivilegeStatusResult_Success_DEFAULT *TListPrivilegesResult_ +var FrontendServiceListUserPrivilegeStatusResult_Success_DEFAULT *TListPrivilegesResult_ -func (p *FrontendServiceListSchemaPrivilegeStatusResult) GetSuccess() (v *TListPrivilegesResult_) { +func (p *FrontendServiceListUserPrivilegeStatusResult) GetSuccess() (v *TListPrivilegesResult_) { if !p.IsSetSuccess() { - return FrontendServiceListSchemaPrivilegeStatusResult_Success_DEFAULT + return FrontendServiceListUserPrivilegeStatusResult_Success_DEFAULT } return p.Success } -func (p *FrontendServiceListSchemaPrivilegeStatusResult) SetSuccess(x interface{}) { +func (p *FrontendServiceListUserPrivilegeStatusResult) SetSuccess(x interface{}) { p.Success = x.(*TListPrivilegesResult_) } -var fieldIDToName_FrontendServiceListSchemaPrivilegeStatusResult = map[int16]string{ +var fieldIDToName_FrontendServiceListUserPrivilegeStatusResult = map[int16]string{ 0: "success", } -func (p *FrontendServiceListSchemaPrivilegeStatusResult) IsSetSuccess() bool { +func (p *FrontendServiceListUserPrivilegeStatusResult) IsSetSuccess() bool { return p.Success != nil } -func (p *FrontendServiceListSchemaPrivilegeStatusResult) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListUserPrivilegeStatusResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -82365,7 +83853,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceListSchemaPrivilegeStatusResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceListUserPrivilegeStatusResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -82375,7 +83863,7 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceListSchemaPrivilegeStatusResult) ReadField0(iprot thrift.TProtocol) error { +func (p *FrontendServiceListUserPrivilegeStatusResult) ReadField0(iprot thrift.TProtocol) error { _field := NewTListPrivilegesResult_() if err := _field.Read(iprot); err != nil { return err @@ -82384,9 +83872,9 @@ func (p *FrontendServiceListSchemaPrivilegeStatusResult) ReadField0(iprot thrift return nil } -func (p *FrontendServiceListSchemaPrivilegeStatusResult) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListUserPrivilegeStatusResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("listSchemaPrivilegeStatus_result"); err != nil { + if err = oprot.WriteStructBegin("listUserPrivilegeStatus_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -82412,7 +83900,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceListSchemaPrivilegeStatusResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceListUserPrivilegeStatusResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -82431,15 +83919,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *FrontendServiceListSchemaPrivilegeStatusResult) String() string { +func (p *FrontendServiceListUserPrivilegeStatusResult) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceListSchemaPrivilegeStatusResult(%+v)", *p) + return fmt.Sprintf("FrontendServiceListUserPrivilegeStatusResult(%+v)", *p) } -func (p *FrontendServiceListSchemaPrivilegeStatusResult) DeepEqual(ano *FrontendServiceListSchemaPrivilegeStatusResult) bool { +func (p *FrontendServiceListUserPrivilegeStatusResult) DeepEqual(ano *FrontendServiceListUserPrivilegeStatusResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -82451,7 +83939,7 @@ func (p *FrontendServiceListSchemaPrivilegeStatusResult) DeepEqual(ano *Frontend return true } -func (p *FrontendServiceListSchemaPrivilegeStatusResult) Field0DeepEqual(src *TListPrivilegesResult_) bool { +func (p *FrontendServiceListUserPrivilegeStatusResult) Field0DeepEqual(src *TListPrivilegesResult_) bool { if !p.Success.DeepEqual(src) { return false @@ -82459,38 +83947,38 @@ func (p *FrontendServiceListSchemaPrivilegeStatusResult) Field0DeepEqual(src *TL return true } -type FrontendServiceListUserPrivilegeStatusArgs struct { - Params *TGetTablesParams `thrift:"params,1" frugal:"1,default,TGetTablesParams" json:"params"` +type FrontendServiceUpdateExportTaskStatusArgs struct { + Request *TUpdateExportTaskStatusRequest `thrift:"request,1" frugal:"1,default,TUpdateExportTaskStatusRequest" json:"request"` } -func NewFrontendServiceListUserPrivilegeStatusArgs() *FrontendServiceListUserPrivilegeStatusArgs { - return &FrontendServiceListUserPrivilegeStatusArgs{} +func NewFrontendServiceUpdateExportTaskStatusArgs() *FrontendServiceUpdateExportTaskStatusArgs { + return &FrontendServiceUpdateExportTaskStatusArgs{} } -func (p *FrontendServiceListUserPrivilegeStatusArgs) InitDefault() { +func (p *FrontendServiceUpdateExportTaskStatusArgs) InitDefault() { } -var FrontendServiceListUserPrivilegeStatusArgs_Params_DEFAULT *TGetTablesParams +var FrontendServiceUpdateExportTaskStatusArgs_Request_DEFAULT *TUpdateExportTaskStatusRequest -func (p *FrontendServiceListUserPrivilegeStatusArgs) GetParams() (v *TGetTablesParams) { - if !p.IsSetParams() { - return FrontendServiceListUserPrivilegeStatusArgs_Params_DEFAULT +func (p *FrontendServiceUpdateExportTaskStatusArgs) GetRequest() (v *TUpdateExportTaskStatusRequest) { + if !p.IsSetRequest() { + return FrontendServiceUpdateExportTaskStatusArgs_Request_DEFAULT } - return p.Params + return p.Request } -func (p *FrontendServiceListUserPrivilegeStatusArgs) SetParams(val *TGetTablesParams) { - p.Params = val +func (p *FrontendServiceUpdateExportTaskStatusArgs) SetRequest(val *TUpdateExportTaskStatusRequest) { + p.Request = val } -var fieldIDToName_FrontendServiceListUserPrivilegeStatusArgs = map[int16]string{ - 1: "params", +var fieldIDToName_FrontendServiceUpdateExportTaskStatusArgs = map[int16]string{ + 1: "request", } -func (p *FrontendServiceListUserPrivilegeStatusArgs) IsSetParams() bool { - return p.Params != nil +func (p *FrontendServiceUpdateExportTaskStatusArgs) IsSetRequest() bool { + return p.Request != nil } -func (p *FrontendServiceListUserPrivilegeStatusArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceUpdateExportTaskStatusArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -82536,7 +84024,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceListUserPrivilegeStatusArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceUpdateExportTaskStatusArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -82546,18 +84034,18 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceListUserPrivilegeStatusArgs) ReadField1(iprot thrift.TProtocol) error { - _field := NewTGetTablesParams() +func (p *FrontendServiceUpdateExportTaskStatusArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewTUpdateExportTaskStatusRequest() if err := _field.Read(iprot); err != nil { return err } - p.Params = _field + p.Request = _field return nil } -func (p *FrontendServiceListUserPrivilegeStatusArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceUpdateExportTaskStatusArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("listUserPrivilegeStatus_args"); err != nil { + if err = oprot.WriteStructBegin("updateExportTaskStatus_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -82583,11 +84071,11 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceListUserPrivilegeStatusArgs) writeField1(oprot thrift.TProtocol) (err error) { - if err = oprot.WriteFieldBegin("params", thrift.STRUCT, 1); err != nil { +func (p *FrontendServiceUpdateExportTaskStatusArgs) writeField1(oprot thrift.TProtocol) (err error) { + if err = oprot.WriteFieldBegin("request", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } - if err := p.Params.Write(oprot); err != nil { + if err := p.Request.Write(oprot); err != nil { return err } if err = oprot.WriteFieldEnd(); err != nil { @@ -82600,66 +84088,66 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *FrontendServiceListUserPrivilegeStatusArgs) String() string { +func (p *FrontendServiceUpdateExportTaskStatusArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceListUserPrivilegeStatusArgs(%+v)", *p) + return fmt.Sprintf("FrontendServiceUpdateExportTaskStatusArgs(%+v)", *p) } -func (p *FrontendServiceListUserPrivilegeStatusArgs) DeepEqual(ano *FrontendServiceListUserPrivilegeStatusArgs) bool { +func (p *FrontendServiceUpdateExportTaskStatusArgs) DeepEqual(ano *FrontendServiceUpdateExportTaskStatusArgs) bool { if p == ano { return true } else if p == nil || ano == nil { return false } - if !p.Field1DeepEqual(ano.Params) { + if !p.Field1DeepEqual(ano.Request) { return false } return true } -func (p *FrontendServiceListUserPrivilegeStatusArgs) Field1DeepEqual(src *TGetTablesParams) bool { +func (p *FrontendServiceUpdateExportTaskStatusArgs) Field1DeepEqual(src *TUpdateExportTaskStatusRequest) bool { - if !p.Params.DeepEqual(src) { + if !p.Request.DeepEqual(src) { return false } return true } -type FrontendServiceListUserPrivilegeStatusResult struct { - Success *TListPrivilegesResult_ `thrift:"success,0,optional" frugal:"0,optional,TListPrivilegesResult_" json:"success,omitempty"` +type FrontendServiceUpdateExportTaskStatusResult struct { + Success *TFeResult_ `thrift:"success,0,optional" frugal:"0,optional,TFeResult_" json:"success,omitempty"` } -func NewFrontendServiceListUserPrivilegeStatusResult() *FrontendServiceListUserPrivilegeStatusResult { - return &FrontendServiceListUserPrivilegeStatusResult{} +func NewFrontendServiceUpdateExportTaskStatusResult() *FrontendServiceUpdateExportTaskStatusResult { + return &FrontendServiceUpdateExportTaskStatusResult{} } -func (p *FrontendServiceListUserPrivilegeStatusResult) InitDefault() { +func (p *FrontendServiceUpdateExportTaskStatusResult) InitDefault() { } -var FrontendServiceListUserPrivilegeStatusResult_Success_DEFAULT *TListPrivilegesResult_ +var FrontendServiceUpdateExportTaskStatusResult_Success_DEFAULT *TFeResult_ -func (p *FrontendServiceListUserPrivilegeStatusResult) GetSuccess() (v *TListPrivilegesResult_) { +func (p *FrontendServiceUpdateExportTaskStatusResult) GetSuccess() (v *TFeResult_) { if !p.IsSetSuccess() { - return FrontendServiceListUserPrivilegeStatusResult_Success_DEFAULT + return FrontendServiceUpdateExportTaskStatusResult_Success_DEFAULT } return p.Success } -func (p *FrontendServiceListUserPrivilegeStatusResult) SetSuccess(x interface{}) { - p.Success = x.(*TListPrivilegesResult_) +func (p *FrontendServiceUpdateExportTaskStatusResult) SetSuccess(x interface{}) { + p.Success = x.(*TFeResult_) } -var fieldIDToName_FrontendServiceListUserPrivilegeStatusResult = map[int16]string{ +var fieldIDToName_FrontendServiceUpdateExportTaskStatusResult = map[int16]string{ 0: "success", } -func (p *FrontendServiceListUserPrivilegeStatusResult) IsSetSuccess() bool { +func (p *FrontendServiceUpdateExportTaskStatusResult) IsSetSuccess() bool { return p.Success != nil } -func (p *FrontendServiceListUserPrivilegeStatusResult) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceUpdateExportTaskStatusResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -82705,7 +84193,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceListUserPrivilegeStatusResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceUpdateExportTaskStatusResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -82715,8 +84203,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceListUserPrivilegeStatusResult) ReadField0(iprot thrift.TProtocol) error { - _field := NewTListPrivilegesResult_() +func (p *FrontendServiceUpdateExportTaskStatusResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewTFeResult_() if err := _field.Read(iprot); err != nil { return err } @@ -82724,9 +84212,9 @@ func (p *FrontendServiceListUserPrivilegeStatusResult) ReadField0(iprot thrift.T return nil } -func (p *FrontendServiceListUserPrivilegeStatusResult) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceUpdateExportTaskStatusResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("listUserPrivilegeStatus_result"); err != nil { + if err = oprot.WriteStructBegin("updateExportTaskStatus_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -82752,7 +84240,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceListUserPrivilegeStatusResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceUpdateExportTaskStatusResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -82771,15 +84259,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *FrontendServiceListUserPrivilegeStatusResult) String() string { +func (p *FrontendServiceUpdateExportTaskStatusResult) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceListUserPrivilegeStatusResult(%+v)", *p) + return fmt.Sprintf("FrontendServiceUpdateExportTaskStatusResult(%+v)", *p) } -func (p *FrontendServiceListUserPrivilegeStatusResult) DeepEqual(ano *FrontendServiceListUserPrivilegeStatusResult) bool { +func (p *FrontendServiceUpdateExportTaskStatusResult) DeepEqual(ano *FrontendServiceUpdateExportTaskStatusResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -82791,7 +84279,7 @@ func (p *FrontendServiceListUserPrivilegeStatusResult) DeepEqual(ano *FrontendSe return true } -func (p *FrontendServiceListUserPrivilegeStatusResult) Field0DeepEqual(src *TListPrivilegesResult_) bool { +func (p *FrontendServiceUpdateExportTaskStatusResult) Field0DeepEqual(src *TFeResult_) bool { if !p.Success.DeepEqual(src) { return false @@ -82799,38 +84287,38 @@ func (p *FrontendServiceListUserPrivilegeStatusResult) Field0DeepEqual(src *TLis return true } -type FrontendServiceUpdateExportTaskStatusArgs struct { - Request *TUpdateExportTaskStatusRequest `thrift:"request,1" frugal:"1,default,TUpdateExportTaskStatusRequest" json:"request"` +type FrontendServiceLoadTxnBeginArgs struct { + Request *TLoadTxnBeginRequest `thrift:"request,1" frugal:"1,default,TLoadTxnBeginRequest" json:"request"` } -func NewFrontendServiceUpdateExportTaskStatusArgs() *FrontendServiceUpdateExportTaskStatusArgs { - return &FrontendServiceUpdateExportTaskStatusArgs{} +func NewFrontendServiceLoadTxnBeginArgs() *FrontendServiceLoadTxnBeginArgs { + return &FrontendServiceLoadTxnBeginArgs{} } -func (p *FrontendServiceUpdateExportTaskStatusArgs) InitDefault() { +func (p *FrontendServiceLoadTxnBeginArgs) InitDefault() { } -var FrontendServiceUpdateExportTaskStatusArgs_Request_DEFAULT *TUpdateExportTaskStatusRequest +var FrontendServiceLoadTxnBeginArgs_Request_DEFAULT *TLoadTxnBeginRequest -func (p *FrontendServiceUpdateExportTaskStatusArgs) GetRequest() (v *TUpdateExportTaskStatusRequest) { +func (p *FrontendServiceLoadTxnBeginArgs) GetRequest() (v *TLoadTxnBeginRequest) { if !p.IsSetRequest() { - return FrontendServiceUpdateExportTaskStatusArgs_Request_DEFAULT + return FrontendServiceLoadTxnBeginArgs_Request_DEFAULT } return p.Request } -func (p *FrontendServiceUpdateExportTaskStatusArgs) SetRequest(val *TUpdateExportTaskStatusRequest) { +func (p *FrontendServiceLoadTxnBeginArgs) SetRequest(val *TLoadTxnBeginRequest) { p.Request = val } -var fieldIDToName_FrontendServiceUpdateExportTaskStatusArgs = map[int16]string{ +var fieldIDToName_FrontendServiceLoadTxnBeginArgs = map[int16]string{ 1: "request", } -func (p *FrontendServiceUpdateExportTaskStatusArgs) IsSetRequest() bool { +func (p *FrontendServiceLoadTxnBeginArgs) IsSetRequest() bool { return p.Request != nil } -func (p *FrontendServiceUpdateExportTaskStatusArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnBeginArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -82876,7 +84364,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceUpdateExportTaskStatusArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceLoadTxnBeginArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -82886,8 +84374,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceUpdateExportTaskStatusArgs) ReadField1(iprot thrift.TProtocol) error { - _field := NewTUpdateExportTaskStatusRequest() +func (p *FrontendServiceLoadTxnBeginArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewTLoadTxnBeginRequest() if err := _field.Read(iprot); err != nil { return err } @@ -82895,9 +84383,9 @@ func (p *FrontendServiceUpdateExportTaskStatusArgs) ReadField1(iprot thrift.TPro return nil } -func (p *FrontendServiceUpdateExportTaskStatusArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnBeginArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("updateExportTaskStatus_args"); err != nil { + if err = oprot.WriteStructBegin("loadTxnBegin_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -82923,7 +84411,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceUpdateExportTaskStatusArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnBeginArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("request", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -82940,15 +84428,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *FrontendServiceUpdateExportTaskStatusArgs) String() string { +func (p *FrontendServiceLoadTxnBeginArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceUpdateExportTaskStatusArgs(%+v)", *p) + return fmt.Sprintf("FrontendServiceLoadTxnBeginArgs(%+v)", *p) } -func (p *FrontendServiceUpdateExportTaskStatusArgs) DeepEqual(ano *FrontendServiceUpdateExportTaskStatusArgs) bool { +func (p *FrontendServiceLoadTxnBeginArgs) DeepEqual(ano *FrontendServiceLoadTxnBeginArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -82960,7 +84448,7 @@ func (p *FrontendServiceUpdateExportTaskStatusArgs) DeepEqual(ano *FrontendServi return true } -func (p *FrontendServiceUpdateExportTaskStatusArgs) Field1DeepEqual(src *TUpdateExportTaskStatusRequest) bool { +func (p *FrontendServiceLoadTxnBeginArgs) Field1DeepEqual(src *TLoadTxnBeginRequest) bool { if !p.Request.DeepEqual(src) { return false @@ -82968,38 +84456,38 @@ func (p *FrontendServiceUpdateExportTaskStatusArgs) Field1DeepEqual(src *TUpdate return true } -type FrontendServiceUpdateExportTaskStatusResult struct { - Success *TFeResult_ `thrift:"success,0,optional" frugal:"0,optional,TFeResult_" json:"success,omitempty"` +type FrontendServiceLoadTxnBeginResult struct { + Success *TLoadTxnBeginResult_ `thrift:"success,0,optional" frugal:"0,optional,TLoadTxnBeginResult_" json:"success,omitempty"` } -func NewFrontendServiceUpdateExportTaskStatusResult() *FrontendServiceUpdateExportTaskStatusResult { - return &FrontendServiceUpdateExportTaskStatusResult{} +func NewFrontendServiceLoadTxnBeginResult() *FrontendServiceLoadTxnBeginResult { + return &FrontendServiceLoadTxnBeginResult{} } -func (p *FrontendServiceUpdateExportTaskStatusResult) InitDefault() { +func (p *FrontendServiceLoadTxnBeginResult) InitDefault() { } -var FrontendServiceUpdateExportTaskStatusResult_Success_DEFAULT *TFeResult_ +var FrontendServiceLoadTxnBeginResult_Success_DEFAULT *TLoadTxnBeginResult_ -func (p *FrontendServiceUpdateExportTaskStatusResult) GetSuccess() (v *TFeResult_) { +func (p *FrontendServiceLoadTxnBeginResult) GetSuccess() (v *TLoadTxnBeginResult_) { if !p.IsSetSuccess() { - return FrontendServiceUpdateExportTaskStatusResult_Success_DEFAULT + return FrontendServiceLoadTxnBeginResult_Success_DEFAULT } return p.Success } -func (p *FrontendServiceUpdateExportTaskStatusResult) SetSuccess(x interface{}) { - p.Success = x.(*TFeResult_) +func (p *FrontendServiceLoadTxnBeginResult) SetSuccess(x interface{}) { + p.Success = x.(*TLoadTxnBeginResult_) } -var fieldIDToName_FrontendServiceUpdateExportTaskStatusResult = map[int16]string{ +var fieldIDToName_FrontendServiceLoadTxnBeginResult = map[int16]string{ 0: "success", } -func (p *FrontendServiceUpdateExportTaskStatusResult) IsSetSuccess() bool { +func (p *FrontendServiceLoadTxnBeginResult) IsSetSuccess() bool { return p.Success != nil } -func (p *FrontendServiceUpdateExportTaskStatusResult) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnBeginResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -83045,7 +84533,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceUpdateExportTaskStatusResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceLoadTxnBeginResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -83055,8 +84543,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceUpdateExportTaskStatusResult) ReadField0(iprot thrift.TProtocol) error { - _field := NewTFeResult_() +func (p *FrontendServiceLoadTxnBeginResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewTLoadTxnBeginResult_() if err := _field.Read(iprot); err != nil { return err } @@ -83064,9 +84552,9 @@ func (p *FrontendServiceUpdateExportTaskStatusResult) ReadField0(iprot thrift.TP return nil } -func (p *FrontendServiceUpdateExportTaskStatusResult) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnBeginResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("updateExportTaskStatus_result"); err != nil { + if err = oprot.WriteStructBegin("loadTxnBegin_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -83092,7 +84580,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceUpdateExportTaskStatusResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnBeginResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -83111,15 +84599,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *FrontendServiceUpdateExportTaskStatusResult) String() string { +func (p *FrontendServiceLoadTxnBeginResult) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceUpdateExportTaskStatusResult(%+v)", *p) + return fmt.Sprintf("FrontendServiceLoadTxnBeginResult(%+v)", *p) } -func (p *FrontendServiceUpdateExportTaskStatusResult) DeepEqual(ano *FrontendServiceUpdateExportTaskStatusResult) bool { +func (p *FrontendServiceLoadTxnBeginResult) DeepEqual(ano *FrontendServiceLoadTxnBeginResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -83131,7 +84619,7 @@ func (p *FrontendServiceUpdateExportTaskStatusResult) DeepEqual(ano *FrontendSer return true } -func (p *FrontendServiceUpdateExportTaskStatusResult) Field0DeepEqual(src *TFeResult_) bool { +func (p *FrontendServiceLoadTxnBeginResult) Field0DeepEqual(src *TLoadTxnBeginResult_) bool { if !p.Success.DeepEqual(src) { return false @@ -83139,38 +84627,38 @@ func (p *FrontendServiceUpdateExportTaskStatusResult) Field0DeepEqual(src *TFeRe return true } -type FrontendServiceLoadTxnBeginArgs struct { - Request *TLoadTxnBeginRequest `thrift:"request,1" frugal:"1,default,TLoadTxnBeginRequest" json:"request"` +type FrontendServiceLoadTxnPreCommitArgs struct { + Request *TLoadTxnCommitRequest `thrift:"request,1" frugal:"1,default,TLoadTxnCommitRequest" json:"request"` } -func NewFrontendServiceLoadTxnBeginArgs() *FrontendServiceLoadTxnBeginArgs { - return &FrontendServiceLoadTxnBeginArgs{} +func NewFrontendServiceLoadTxnPreCommitArgs() *FrontendServiceLoadTxnPreCommitArgs { + return &FrontendServiceLoadTxnPreCommitArgs{} } -func (p *FrontendServiceLoadTxnBeginArgs) InitDefault() { +func (p *FrontendServiceLoadTxnPreCommitArgs) InitDefault() { } -var FrontendServiceLoadTxnBeginArgs_Request_DEFAULT *TLoadTxnBeginRequest +var FrontendServiceLoadTxnPreCommitArgs_Request_DEFAULT *TLoadTxnCommitRequest -func (p *FrontendServiceLoadTxnBeginArgs) GetRequest() (v *TLoadTxnBeginRequest) { +func (p *FrontendServiceLoadTxnPreCommitArgs) GetRequest() (v *TLoadTxnCommitRequest) { if !p.IsSetRequest() { - return FrontendServiceLoadTxnBeginArgs_Request_DEFAULT + return FrontendServiceLoadTxnPreCommitArgs_Request_DEFAULT } return p.Request } -func (p *FrontendServiceLoadTxnBeginArgs) SetRequest(val *TLoadTxnBeginRequest) { +func (p *FrontendServiceLoadTxnPreCommitArgs) SetRequest(val *TLoadTxnCommitRequest) { p.Request = val } -var fieldIDToName_FrontendServiceLoadTxnBeginArgs = map[int16]string{ +var fieldIDToName_FrontendServiceLoadTxnPreCommitArgs = map[int16]string{ 1: "request", } -func (p *FrontendServiceLoadTxnBeginArgs) IsSetRequest() bool { +func (p *FrontendServiceLoadTxnPreCommitArgs) IsSetRequest() bool { return p.Request != nil } -func (p *FrontendServiceLoadTxnBeginArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnPreCommitArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -83216,7 +84704,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceLoadTxnBeginArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceLoadTxnPreCommitArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -83226,8 +84714,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceLoadTxnBeginArgs) ReadField1(iprot thrift.TProtocol) error { - _field := NewTLoadTxnBeginRequest() +func (p *FrontendServiceLoadTxnPreCommitArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewTLoadTxnCommitRequest() if err := _field.Read(iprot); err != nil { return err } @@ -83235,9 +84723,9 @@ func (p *FrontendServiceLoadTxnBeginArgs) ReadField1(iprot thrift.TProtocol) err return nil } -func (p *FrontendServiceLoadTxnBeginArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnPreCommitArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("loadTxnBegin_args"); err != nil { + if err = oprot.WriteStructBegin("loadTxnPreCommit_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -83263,7 +84751,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceLoadTxnBeginArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnPreCommitArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("request", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -83280,15 +84768,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *FrontendServiceLoadTxnBeginArgs) String() string { +func (p *FrontendServiceLoadTxnPreCommitArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceLoadTxnBeginArgs(%+v)", *p) + return fmt.Sprintf("FrontendServiceLoadTxnPreCommitArgs(%+v)", *p) } -func (p *FrontendServiceLoadTxnBeginArgs) DeepEqual(ano *FrontendServiceLoadTxnBeginArgs) bool { +func (p *FrontendServiceLoadTxnPreCommitArgs) DeepEqual(ano *FrontendServiceLoadTxnPreCommitArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -83300,7 +84788,7 @@ func (p *FrontendServiceLoadTxnBeginArgs) DeepEqual(ano *FrontendServiceLoadTxnB return true } -func (p *FrontendServiceLoadTxnBeginArgs) Field1DeepEqual(src *TLoadTxnBeginRequest) bool { +func (p *FrontendServiceLoadTxnPreCommitArgs) Field1DeepEqual(src *TLoadTxnCommitRequest) bool { if !p.Request.DeepEqual(src) { return false @@ -83308,38 +84796,38 @@ func (p *FrontendServiceLoadTxnBeginArgs) Field1DeepEqual(src *TLoadTxnBeginRequ return true } -type FrontendServiceLoadTxnBeginResult struct { - Success *TLoadTxnBeginResult_ `thrift:"success,0,optional" frugal:"0,optional,TLoadTxnBeginResult_" json:"success,omitempty"` +type FrontendServiceLoadTxnPreCommitResult struct { + Success *TLoadTxnCommitResult_ `thrift:"success,0,optional" frugal:"0,optional,TLoadTxnCommitResult_" json:"success,omitempty"` } -func NewFrontendServiceLoadTxnBeginResult() *FrontendServiceLoadTxnBeginResult { - return &FrontendServiceLoadTxnBeginResult{} +func NewFrontendServiceLoadTxnPreCommitResult() *FrontendServiceLoadTxnPreCommitResult { + return &FrontendServiceLoadTxnPreCommitResult{} } -func (p *FrontendServiceLoadTxnBeginResult) InitDefault() { +func (p *FrontendServiceLoadTxnPreCommitResult) InitDefault() { } -var FrontendServiceLoadTxnBeginResult_Success_DEFAULT *TLoadTxnBeginResult_ +var FrontendServiceLoadTxnPreCommitResult_Success_DEFAULT *TLoadTxnCommitResult_ -func (p *FrontendServiceLoadTxnBeginResult) GetSuccess() (v *TLoadTxnBeginResult_) { +func (p *FrontendServiceLoadTxnPreCommitResult) GetSuccess() (v *TLoadTxnCommitResult_) { if !p.IsSetSuccess() { - return FrontendServiceLoadTxnBeginResult_Success_DEFAULT + return FrontendServiceLoadTxnPreCommitResult_Success_DEFAULT } return p.Success } -func (p *FrontendServiceLoadTxnBeginResult) SetSuccess(x interface{}) { - p.Success = x.(*TLoadTxnBeginResult_) +func (p *FrontendServiceLoadTxnPreCommitResult) SetSuccess(x interface{}) { + p.Success = x.(*TLoadTxnCommitResult_) } -var fieldIDToName_FrontendServiceLoadTxnBeginResult = map[int16]string{ +var fieldIDToName_FrontendServiceLoadTxnPreCommitResult = map[int16]string{ 0: "success", } -func (p *FrontendServiceLoadTxnBeginResult) IsSetSuccess() bool { +func (p *FrontendServiceLoadTxnPreCommitResult) IsSetSuccess() bool { return p.Success != nil } -func (p *FrontendServiceLoadTxnBeginResult) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnPreCommitResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -83385,7 +84873,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceLoadTxnBeginResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceLoadTxnPreCommitResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -83395,8 +84883,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceLoadTxnBeginResult) ReadField0(iprot thrift.TProtocol) error { - _field := NewTLoadTxnBeginResult_() +func (p *FrontendServiceLoadTxnPreCommitResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewTLoadTxnCommitResult_() if err := _field.Read(iprot); err != nil { return err } @@ -83404,9 +84892,9 @@ func (p *FrontendServiceLoadTxnBeginResult) ReadField0(iprot thrift.TProtocol) e return nil } -func (p *FrontendServiceLoadTxnBeginResult) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnPreCommitResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("loadTxnBegin_result"); err != nil { + if err = oprot.WriteStructBegin("loadTxnPreCommit_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -83432,7 +84920,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceLoadTxnBeginResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnPreCommitResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -83451,15 +84939,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *FrontendServiceLoadTxnBeginResult) String() string { +func (p *FrontendServiceLoadTxnPreCommitResult) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceLoadTxnBeginResult(%+v)", *p) + return fmt.Sprintf("FrontendServiceLoadTxnPreCommitResult(%+v)", *p) } -func (p *FrontendServiceLoadTxnBeginResult) DeepEqual(ano *FrontendServiceLoadTxnBeginResult) bool { +func (p *FrontendServiceLoadTxnPreCommitResult) DeepEqual(ano *FrontendServiceLoadTxnPreCommitResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -83471,7 +84959,7 @@ func (p *FrontendServiceLoadTxnBeginResult) DeepEqual(ano *FrontendServiceLoadTx return true } -func (p *FrontendServiceLoadTxnBeginResult) Field0DeepEqual(src *TLoadTxnBeginResult_) bool { +func (p *FrontendServiceLoadTxnPreCommitResult) Field0DeepEqual(src *TLoadTxnCommitResult_) bool { if !p.Success.DeepEqual(src) { return false @@ -83479,38 +84967,38 @@ func (p *FrontendServiceLoadTxnBeginResult) Field0DeepEqual(src *TLoadTxnBeginRe return true } -type FrontendServiceLoadTxnPreCommitArgs struct { - Request *TLoadTxnCommitRequest `thrift:"request,1" frugal:"1,default,TLoadTxnCommitRequest" json:"request"` +type FrontendServiceLoadTxn2PCArgs struct { + Request *TLoadTxn2PCRequest `thrift:"request,1" frugal:"1,default,TLoadTxn2PCRequest" json:"request"` } -func NewFrontendServiceLoadTxnPreCommitArgs() *FrontendServiceLoadTxnPreCommitArgs { - return &FrontendServiceLoadTxnPreCommitArgs{} +func NewFrontendServiceLoadTxn2PCArgs() *FrontendServiceLoadTxn2PCArgs { + return &FrontendServiceLoadTxn2PCArgs{} } -func (p *FrontendServiceLoadTxnPreCommitArgs) InitDefault() { +func (p *FrontendServiceLoadTxn2PCArgs) InitDefault() { } -var FrontendServiceLoadTxnPreCommitArgs_Request_DEFAULT *TLoadTxnCommitRequest +var FrontendServiceLoadTxn2PCArgs_Request_DEFAULT *TLoadTxn2PCRequest -func (p *FrontendServiceLoadTxnPreCommitArgs) GetRequest() (v *TLoadTxnCommitRequest) { +func (p *FrontendServiceLoadTxn2PCArgs) GetRequest() (v *TLoadTxn2PCRequest) { if !p.IsSetRequest() { - return FrontendServiceLoadTxnPreCommitArgs_Request_DEFAULT + return FrontendServiceLoadTxn2PCArgs_Request_DEFAULT } return p.Request } -func (p *FrontendServiceLoadTxnPreCommitArgs) SetRequest(val *TLoadTxnCommitRequest) { +func (p *FrontendServiceLoadTxn2PCArgs) SetRequest(val *TLoadTxn2PCRequest) { p.Request = val } -var fieldIDToName_FrontendServiceLoadTxnPreCommitArgs = map[int16]string{ +var fieldIDToName_FrontendServiceLoadTxn2PCArgs = map[int16]string{ 1: "request", } -func (p *FrontendServiceLoadTxnPreCommitArgs) IsSetRequest() bool { +func (p *FrontendServiceLoadTxn2PCArgs) IsSetRequest() bool { return p.Request != nil } -func (p *FrontendServiceLoadTxnPreCommitArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxn2PCArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -83556,7 +85044,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceLoadTxnPreCommitArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceLoadTxn2PCArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -83566,8 +85054,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceLoadTxnPreCommitArgs) ReadField1(iprot thrift.TProtocol) error { - _field := NewTLoadTxnCommitRequest() +func (p *FrontendServiceLoadTxn2PCArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewTLoadTxn2PCRequest() if err := _field.Read(iprot); err != nil { return err } @@ -83575,9 +85063,9 @@ func (p *FrontendServiceLoadTxnPreCommitArgs) ReadField1(iprot thrift.TProtocol) return nil } -func (p *FrontendServiceLoadTxnPreCommitArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxn2PCArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("loadTxnPreCommit_args"); err != nil { + if err = oprot.WriteStructBegin("loadTxn2PC_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -83603,7 +85091,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceLoadTxnPreCommitArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxn2PCArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("request", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -83620,15 +85108,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *FrontendServiceLoadTxnPreCommitArgs) String() string { +func (p *FrontendServiceLoadTxn2PCArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceLoadTxnPreCommitArgs(%+v)", *p) + return fmt.Sprintf("FrontendServiceLoadTxn2PCArgs(%+v)", *p) } -func (p *FrontendServiceLoadTxnPreCommitArgs) DeepEqual(ano *FrontendServiceLoadTxnPreCommitArgs) bool { +func (p *FrontendServiceLoadTxn2PCArgs) DeepEqual(ano *FrontendServiceLoadTxn2PCArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -83640,7 +85128,7 @@ func (p *FrontendServiceLoadTxnPreCommitArgs) DeepEqual(ano *FrontendServiceLoad return true } -func (p *FrontendServiceLoadTxnPreCommitArgs) Field1DeepEqual(src *TLoadTxnCommitRequest) bool { +func (p *FrontendServiceLoadTxn2PCArgs) Field1DeepEqual(src *TLoadTxn2PCRequest) bool { if !p.Request.DeepEqual(src) { return false @@ -83648,38 +85136,38 @@ func (p *FrontendServiceLoadTxnPreCommitArgs) Field1DeepEqual(src *TLoadTxnCommi return true } -type FrontendServiceLoadTxnPreCommitResult struct { - Success *TLoadTxnCommitResult_ `thrift:"success,0,optional" frugal:"0,optional,TLoadTxnCommitResult_" json:"success,omitempty"` +type FrontendServiceLoadTxn2PCResult struct { + Success *TLoadTxn2PCResult_ `thrift:"success,0,optional" frugal:"0,optional,TLoadTxn2PCResult_" json:"success,omitempty"` } -func NewFrontendServiceLoadTxnPreCommitResult() *FrontendServiceLoadTxnPreCommitResult { - return &FrontendServiceLoadTxnPreCommitResult{} +func NewFrontendServiceLoadTxn2PCResult() *FrontendServiceLoadTxn2PCResult { + return &FrontendServiceLoadTxn2PCResult{} } -func (p *FrontendServiceLoadTxnPreCommitResult) InitDefault() { +func (p *FrontendServiceLoadTxn2PCResult) InitDefault() { } -var FrontendServiceLoadTxnPreCommitResult_Success_DEFAULT *TLoadTxnCommitResult_ +var FrontendServiceLoadTxn2PCResult_Success_DEFAULT *TLoadTxn2PCResult_ -func (p *FrontendServiceLoadTxnPreCommitResult) GetSuccess() (v *TLoadTxnCommitResult_) { +func (p *FrontendServiceLoadTxn2PCResult) GetSuccess() (v *TLoadTxn2PCResult_) { if !p.IsSetSuccess() { - return FrontendServiceLoadTxnPreCommitResult_Success_DEFAULT + return FrontendServiceLoadTxn2PCResult_Success_DEFAULT } return p.Success } -func (p *FrontendServiceLoadTxnPreCommitResult) SetSuccess(x interface{}) { - p.Success = x.(*TLoadTxnCommitResult_) +func (p *FrontendServiceLoadTxn2PCResult) SetSuccess(x interface{}) { + p.Success = x.(*TLoadTxn2PCResult_) } -var fieldIDToName_FrontendServiceLoadTxnPreCommitResult = map[int16]string{ +var fieldIDToName_FrontendServiceLoadTxn2PCResult = map[int16]string{ 0: "success", } -func (p *FrontendServiceLoadTxnPreCommitResult) IsSetSuccess() bool { +func (p *FrontendServiceLoadTxn2PCResult) IsSetSuccess() bool { return p.Success != nil } -func (p *FrontendServiceLoadTxnPreCommitResult) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxn2PCResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -83725,7 +85213,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceLoadTxnPreCommitResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceLoadTxn2PCResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -83735,8 +85223,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceLoadTxnPreCommitResult) ReadField0(iprot thrift.TProtocol) error { - _field := NewTLoadTxnCommitResult_() +func (p *FrontendServiceLoadTxn2PCResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewTLoadTxn2PCResult_() if err := _field.Read(iprot); err != nil { return err } @@ -83744,9 +85232,9 @@ func (p *FrontendServiceLoadTxnPreCommitResult) ReadField0(iprot thrift.TProtoco return nil } -func (p *FrontendServiceLoadTxnPreCommitResult) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxn2PCResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("loadTxnPreCommit_result"); err != nil { + if err = oprot.WriteStructBegin("loadTxn2PC_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -83772,7 +85260,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceLoadTxnPreCommitResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxn2PCResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -83791,15 +85279,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *FrontendServiceLoadTxnPreCommitResult) String() string { +func (p *FrontendServiceLoadTxn2PCResult) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceLoadTxnPreCommitResult(%+v)", *p) + return fmt.Sprintf("FrontendServiceLoadTxn2PCResult(%+v)", *p) } -func (p *FrontendServiceLoadTxnPreCommitResult) DeepEqual(ano *FrontendServiceLoadTxnPreCommitResult) bool { +func (p *FrontendServiceLoadTxn2PCResult) DeepEqual(ano *FrontendServiceLoadTxn2PCResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -83811,7 +85299,7 @@ func (p *FrontendServiceLoadTxnPreCommitResult) DeepEqual(ano *FrontendServiceLo return true } -func (p *FrontendServiceLoadTxnPreCommitResult) Field0DeepEqual(src *TLoadTxnCommitResult_) bool { +func (p *FrontendServiceLoadTxn2PCResult) Field0DeepEqual(src *TLoadTxn2PCResult_) bool { if !p.Success.DeepEqual(src) { return false @@ -83819,38 +85307,38 @@ func (p *FrontendServiceLoadTxnPreCommitResult) Field0DeepEqual(src *TLoadTxnCom return true } -type FrontendServiceLoadTxn2PCArgs struct { - Request *TLoadTxn2PCRequest `thrift:"request,1" frugal:"1,default,TLoadTxn2PCRequest" json:"request"` +type FrontendServiceLoadTxnCommitArgs struct { + Request *TLoadTxnCommitRequest `thrift:"request,1" frugal:"1,default,TLoadTxnCommitRequest" json:"request"` } -func NewFrontendServiceLoadTxn2PCArgs() *FrontendServiceLoadTxn2PCArgs { - return &FrontendServiceLoadTxn2PCArgs{} +func NewFrontendServiceLoadTxnCommitArgs() *FrontendServiceLoadTxnCommitArgs { + return &FrontendServiceLoadTxnCommitArgs{} } -func (p *FrontendServiceLoadTxn2PCArgs) InitDefault() { +func (p *FrontendServiceLoadTxnCommitArgs) InitDefault() { } -var FrontendServiceLoadTxn2PCArgs_Request_DEFAULT *TLoadTxn2PCRequest +var FrontendServiceLoadTxnCommitArgs_Request_DEFAULT *TLoadTxnCommitRequest -func (p *FrontendServiceLoadTxn2PCArgs) GetRequest() (v *TLoadTxn2PCRequest) { +func (p *FrontendServiceLoadTxnCommitArgs) GetRequest() (v *TLoadTxnCommitRequest) { if !p.IsSetRequest() { - return FrontendServiceLoadTxn2PCArgs_Request_DEFAULT + return FrontendServiceLoadTxnCommitArgs_Request_DEFAULT } return p.Request } -func (p *FrontendServiceLoadTxn2PCArgs) SetRequest(val *TLoadTxn2PCRequest) { +func (p *FrontendServiceLoadTxnCommitArgs) SetRequest(val *TLoadTxnCommitRequest) { p.Request = val } -var fieldIDToName_FrontendServiceLoadTxn2PCArgs = map[int16]string{ +var fieldIDToName_FrontendServiceLoadTxnCommitArgs = map[int16]string{ 1: "request", } -func (p *FrontendServiceLoadTxn2PCArgs) IsSetRequest() bool { +func (p *FrontendServiceLoadTxnCommitArgs) IsSetRequest() bool { return p.Request != nil } -func (p *FrontendServiceLoadTxn2PCArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnCommitArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -83896,7 +85384,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceLoadTxn2PCArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceLoadTxnCommitArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -83906,8 +85394,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceLoadTxn2PCArgs) ReadField1(iprot thrift.TProtocol) error { - _field := NewTLoadTxn2PCRequest() +func (p *FrontendServiceLoadTxnCommitArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewTLoadTxnCommitRequest() if err := _field.Read(iprot); err != nil { return err } @@ -83915,9 +85403,9 @@ func (p *FrontendServiceLoadTxn2PCArgs) ReadField1(iprot thrift.TProtocol) error return nil } -func (p *FrontendServiceLoadTxn2PCArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnCommitArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("loadTxn2PC_args"); err != nil { + if err = oprot.WriteStructBegin("loadTxnCommit_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -83943,7 +85431,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceLoadTxn2PCArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnCommitArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("request", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -83960,15 +85448,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *FrontendServiceLoadTxn2PCArgs) String() string { +func (p *FrontendServiceLoadTxnCommitArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceLoadTxn2PCArgs(%+v)", *p) + return fmt.Sprintf("FrontendServiceLoadTxnCommitArgs(%+v)", *p) } -func (p *FrontendServiceLoadTxn2PCArgs) DeepEqual(ano *FrontendServiceLoadTxn2PCArgs) bool { +func (p *FrontendServiceLoadTxnCommitArgs) DeepEqual(ano *FrontendServiceLoadTxnCommitArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -83980,7 +85468,7 @@ func (p *FrontendServiceLoadTxn2PCArgs) DeepEqual(ano *FrontendServiceLoadTxn2PC return true } -func (p *FrontendServiceLoadTxn2PCArgs) Field1DeepEqual(src *TLoadTxn2PCRequest) bool { +func (p *FrontendServiceLoadTxnCommitArgs) Field1DeepEqual(src *TLoadTxnCommitRequest) bool { if !p.Request.DeepEqual(src) { return false @@ -83988,38 +85476,38 @@ func (p *FrontendServiceLoadTxn2PCArgs) Field1DeepEqual(src *TLoadTxn2PCRequest) return true } -type FrontendServiceLoadTxn2PCResult struct { - Success *TLoadTxn2PCResult_ `thrift:"success,0,optional" frugal:"0,optional,TLoadTxn2PCResult_" json:"success,omitempty"` +type FrontendServiceLoadTxnCommitResult struct { + Success *TLoadTxnCommitResult_ `thrift:"success,0,optional" frugal:"0,optional,TLoadTxnCommitResult_" json:"success,omitempty"` } -func NewFrontendServiceLoadTxn2PCResult() *FrontendServiceLoadTxn2PCResult { - return &FrontendServiceLoadTxn2PCResult{} +func NewFrontendServiceLoadTxnCommitResult() *FrontendServiceLoadTxnCommitResult { + return &FrontendServiceLoadTxnCommitResult{} } -func (p *FrontendServiceLoadTxn2PCResult) InitDefault() { +func (p *FrontendServiceLoadTxnCommitResult) InitDefault() { } -var FrontendServiceLoadTxn2PCResult_Success_DEFAULT *TLoadTxn2PCResult_ +var FrontendServiceLoadTxnCommitResult_Success_DEFAULT *TLoadTxnCommitResult_ -func (p *FrontendServiceLoadTxn2PCResult) GetSuccess() (v *TLoadTxn2PCResult_) { +func (p *FrontendServiceLoadTxnCommitResult) GetSuccess() (v *TLoadTxnCommitResult_) { if !p.IsSetSuccess() { - return FrontendServiceLoadTxn2PCResult_Success_DEFAULT + return FrontendServiceLoadTxnCommitResult_Success_DEFAULT } return p.Success } -func (p *FrontendServiceLoadTxn2PCResult) SetSuccess(x interface{}) { - p.Success = x.(*TLoadTxn2PCResult_) +func (p *FrontendServiceLoadTxnCommitResult) SetSuccess(x interface{}) { + p.Success = x.(*TLoadTxnCommitResult_) } -var fieldIDToName_FrontendServiceLoadTxn2PCResult = map[int16]string{ +var fieldIDToName_FrontendServiceLoadTxnCommitResult = map[int16]string{ 0: "success", } -func (p *FrontendServiceLoadTxn2PCResult) IsSetSuccess() bool { +func (p *FrontendServiceLoadTxnCommitResult) IsSetSuccess() bool { return p.Success != nil } -func (p *FrontendServiceLoadTxn2PCResult) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnCommitResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -84065,7 +85553,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceLoadTxn2PCResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceLoadTxnCommitResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -84075,8 +85563,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceLoadTxn2PCResult) ReadField0(iprot thrift.TProtocol) error { - _field := NewTLoadTxn2PCResult_() +func (p *FrontendServiceLoadTxnCommitResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewTLoadTxnCommitResult_() if err := _field.Read(iprot); err != nil { return err } @@ -84084,9 +85572,9 @@ func (p *FrontendServiceLoadTxn2PCResult) ReadField0(iprot thrift.TProtocol) err return nil } -func (p *FrontendServiceLoadTxn2PCResult) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnCommitResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("loadTxn2PC_result"); err != nil { + if err = oprot.WriteStructBegin("loadTxnCommit_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -84112,7 +85600,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceLoadTxn2PCResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnCommitResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -84131,15 +85619,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *FrontendServiceLoadTxn2PCResult) String() string { +func (p *FrontendServiceLoadTxnCommitResult) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceLoadTxn2PCResult(%+v)", *p) + return fmt.Sprintf("FrontendServiceLoadTxnCommitResult(%+v)", *p) } -func (p *FrontendServiceLoadTxn2PCResult) DeepEqual(ano *FrontendServiceLoadTxn2PCResult) bool { +func (p *FrontendServiceLoadTxnCommitResult) DeepEqual(ano *FrontendServiceLoadTxnCommitResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -84151,7 +85639,7 @@ func (p *FrontendServiceLoadTxn2PCResult) DeepEqual(ano *FrontendServiceLoadTxn2 return true } -func (p *FrontendServiceLoadTxn2PCResult) Field0DeepEqual(src *TLoadTxn2PCResult_) bool { +func (p *FrontendServiceLoadTxnCommitResult) Field0DeepEqual(src *TLoadTxnCommitResult_) bool { if !p.Success.DeepEqual(src) { return false @@ -84159,38 +85647,38 @@ func (p *FrontendServiceLoadTxn2PCResult) Field0DeepEqual(src *TLoadTxn2PCResult return true } -type FrontendServiceLoadTxnCommitArgs struct { - Request *TLoadTxnCommitRequest `thrift:"request,1" frugal:"1,default,TLoadTxnCommitRequest" json:"request"` +type FrontendServiceLoadTxnRollbackArgs struct { + Request *TLoadTxnRollbackRequest `thrift:"request,1" frugal:"1,default,TLoadTxnRollbackRequest" json:"request"` } -func NewFrontendServiceLoadTxnCommitArgs() *FrontendServiceLoadTxnCommitArgs { - return &FrontendServiceLoadTxnCommitArgs{} +func NewFrontendServiceLoadTxnRollbackArgs() *FrontendServiceLoadTxnRollbackArgs { + return &FrontendServiceLoadTxnRollbackArgs{} } -func (p *FrontendServiceLoadTxnCommitArgs) InitDefault() { +func (p *FrontendServiceLoadTxnRollbackArgs) InitDefault() { } -var FrontendServiceLoadTxnCommitArgs_Request_DEFAULT *TLoadTxnCommitRequest +var FrontendServiceLoadTxnRollbackArgs_Request_DEFAULT *TLoadTxnRollbackRequest -func (p *FrontendServiceLoadTxnCommitArgs) GetRequest() (v *TLoadTxnCommitRequest) { +func (p *FrontendServiceLoadTxnRollbackArgs) GetRequest() (v *TLoadTxnRollbackRequest) { if !p.IsSetRequest() { - return FrontendServiceLoadTxnCommitArgs_Request_DEFAULT + return FrontendServiceLoadTxnRollbackArgs_Request_DEFAULT } return p.Request } -func (p *FrontendServiceLoadTxnCommitArgs) SetRequest(val *TLoadTxnCommitRequest) { +func (p *FrontendServiceLoadTxnRollbackArgs) SetRequest(val *TLoadTxnRollbackRequest) { p.Request = val } -var fieldIDToName_FrontendServiceLoadTxnCommitArgs = map[int16]string{ +var fieldIDToName_FrontendServiceLoadTxnRollbackArgs = map[int16]string{ 1: "request", } -func (p *FrontendServiceLoadTxnCommitArgs) IsSetRequest() bool { +func (p *FrontendServiceLoadTxnRollbackArgs) IsSetRequest() bool { return p.Request != nil } -func (p *FrontendServiceLoadTxnCommitArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnRollbackArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -84236,7 +85724,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceLoadTxnCommitArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceLoadTxnRollbackArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -84246,8 +85734,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceLoadTxnCommitArgs) ReadField1(iprot thrift.TProtocol) error { - _field := NewTLoadTxnCommitRequest() +func (p *FrontendServiceLoadTxnRollbackArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewTLoadTxnRollbackRequest() if err := _field.Read(iprot); err != nil { return err } @@ -84255,9 +85743,9 @@ func (p *FrontendServiceLoadTxnCommitArgs) ReadField1(iprot thrift.TProtocol) er return nil } -func (p *FrontendServiceLoadTxnCommitArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnRollbackArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("loadTxnCommit_args"); err != nil { + if err = oprot.WriteStructBegin("loadTxnRollback_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -84283,7 +85771,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceLoadTxnCommitArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnRollbackArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("request", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -84300,15 +85788,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *FrontendServiceLoadTxnCommitArgs) String() string { +func (p *FrontendServiceLoadTxnRollbackArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceLoadTxnCommitArgs(%+v)", *p) + return fmt.Sprintf("FrontendServiceLoadTxnRollbackArgs(%+v)", *p) } -func (p *FrontendServiceLoadTxnCommitArgs) DeepEqual(ano *FrontendServiceLoadTxnCommitArgs) bool { +func (p *FrontendServiceLoadTxnRollbackArgs) DeepEqual(ano *FrontendServiceLoadTxnRollbackArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -84320,7 +85808,7 @@ func (p *FrontendServiceLoadTxnCommitArgs) DeepEqual(ano *FrontendServiceLoadTxn return true } -func (p *FrontendServiceLoadTxnCommitArgs) Field1DeepEqual(src *TLoadTxnCommitRequest) bool { +func (p *FrontendServiceLoadTxnRollbackArgs) Field1DeepEqual(src *TLoadTxnRollbackRequest) bool { if !p.Request.DeepEqual(src) { return false @@ -84328,38 +85816,38 @@ func (p *FrontendServiceLoadTxnCommitArgs) Field1DeepEqual(src *TLoadTxnCommitRe return true } -type FrontendServiceLoadTxnCommitResult struct { - Success *TLoadTxnCommitResult_ `thrift:"success,0,optional" frugal:"0,optional,TLoadTxnCommitResult_" json:"success,omitempty"` +type FrontendServiceLoadTxnRollbackResult struct { + Success *TLoadTxnRollbackResult_ `thrift:"success,0,optional" frugal:"0,optional,TLoadTxnRollbackResult_" json:"success,omitempty"` } -func NewFrontendServiceLoadTxnCommitResult() *FrontendServiceLoadTxnCommitResult { - return &FrontendServiceLoadTxnCommitResult{} +func NewFrontendServiceLoadTxnRollbackResult() *FrontendServiceLoadTxnRollbackResult { + return &FrontendServiceLoadTxnRollbackResult{} } -func (p *FrontendServiceLoadTxnCommitResult) InitDefault() { +func (p *FrontendServiceLoadTxnRollbackResult) InitDefault() { } -var FrontendServiceLoadTxnCommitResult_Success_DEFAULT *TLoadTxnCommitResult_ +var FrontendServiceLoadTxnRollbackResult_Success_DEFAULT *TLoadTxnRollbackResult_ -func (p *FrontendServiceLoadTxnCommitResult) GetSuccess() (v *TLoadTxnCommitResult_) { +func (p *FrontendServiceLoadTxnRollbackResult) GetSuccess() (v *TLoadTxnRollbackResult_) { if !p.IsSetSuccess() { - return FrontendServiceLoadTxnCommitResult_Success_DEFAULT + return FrontendServiceLoadTxnRollbackResult_Success_DEFAULT } return p.Success } -func (p *FrontendServiceLoadTxnCommitResult) SetSuccess(x interface{}) { - p.Success = x.(*TLoadTxnCommitResult_) +func (p *FrontendServiceLoadTxnRollbackResult) SetSuccess(x interface{}) { + p.Success = x.(*TLoadTxnRollbackResult_) } -var fieldIDToName_FrontendServiceLoadTxnCommitResult = map[int16]string{ +var fieldIDToName_FrontendServiceLoadTxnRollbackResult = map[int16]string{ 0: "success", } -func (p *FrontendServiceLoadTxnCommitResult) IsSetSuccess() bool { +func (p *FrontendServiceLoadTxnRollbackResult) IsSetSuccess() bool { return p.Success != nil } -func (p *FrontendServiceLoadTxnCommitResult) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnRollbackResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -84405,7 +85893,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceLoadTxnCommitResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceLoadTxnRollbackResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -84415,8 +85903,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceLoadTxnCommitResult) ReadField0(iprot thrift.TProtocol) error { - _field := NewTLoadTxnCommitResult_() +func (p *FrontendServiceLoadTxnRollbackResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewTLoadTxnRollbackResult_() if err := _field.Read(iprot); err != nil { return err } @@ -84424,9 +85912,9 @@ func (p *FrontendServiceLoadTxnCommitResult) ReadField0(iprot thrift.TProtocol) return nil } -func (p *FrontendServiceLoadTxnCommitResult) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnRollbackResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("loadTxnCommit_result"); err != nil { + if err = oprot.WriteStructBegin("loadTxnRollback_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -84452,7 +85940,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceLoadTxnCommitResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceLoadTxnRollbackResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -84471,15 +85959,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *FrontendServiceLoadTxnCommitResult) String() string { +func (p *FrontendServiceLoadTxnRollbackResult) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceLoadTxnCommitResult(%+v)", *p) + return fmt.Sprintf("FrontendServiceLoadTxnRollbackResult(%+v)", *p) } -func (p *FrontendServiceLoadTxnCommitResult) DeepEqual(ano *FrontendServiceLoadTxnCommitResult) bool { +func (p *FrontendServiceLoadTxnRollbackResult) DeepEqual(ano *FrontendServiceLoadTxnRollbackResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -84491,7 +85979,7 @@ func (p *FrontendServiceLoadTxnCommitResult) DeepEqual(ano *FrontendServiceLoadT return true } -func (p *FrontendServiceLoadTxnCommitResult) Field0DeepEqual(src *TLoadTxnCommitResult_) bool { +func (p *FrontendServiceLoadTxnRollbackResult) Field0DeepEqual(src *TLoadTxnRollbackResult_) bool { if !p.Success.DeepEqual(src) { return false @@ -84499,38 +85987,38 @@ func (p *FrontendServiceLoadTxnCommitResult) Field0DeepEqual(src *TLoadTxnCommit return true } -type FrontendServiceLoadTxnRollbackArgs struct { - Request *TLoadTxnRollbackRequest `thrift:"request,1" frugal:"1,default,TLoadTxnRollbackRequest" json:"request"` +type FrontendServiceBeginTxnArgs struct { + Request *TBeginTxnRequest `thrift:"request,1" frugal:"1,default,TBeginTxnRequest" json:"request"` } -func NewFrontendServiceLoadTxnRollbackArgs() *FrontendServiceLoadTxnRollbackArgs { - return &FrontendServiceLoadTxnRollbackArgs{} +func NewFrontendServiceBeginTxnArgs() *FrontendServiceBeginTxnArgs { + return &FrontendServiceBeginTxnArgs{} } -func (p *FrontendServiceLoadTxnRollbackArgs) InitDefault() { +func (p *FrontendServiceBeginTxnArgs) InitDefault() { } -var FrontendServiceLoadTxnRollbackArgs_Request_DEFAULT *TLoadTxnRollbackRequest +var FrontendServiceBeginTxnArgs_Request_DEFAULT *TBeginTxnRequest -func (p *FrontendServiceLoadTxnRollbackArgs) GetRequest() (v *TLoadTxnRollbackRequest) { +func (p *FrontendServiceBeginTxnArgs) GetRequest() (v *TBeginTxnRequest) { if !p.IsSetRequest() { - return FrontendServiceLoadTxnRollbackArgs_Request_DEFAULT + return FrontendServiceBeginTxnArgs_Request_DEFAULT } return p.Request } -func (p *FrontendServiceLoadTxnRollbackArgs) SetRequest(val *TLoadTxnRollbackRequest) { +func (p *FrontendServiceBeginTxnArgs) SetRequest(val *TBeginTxnRequest) { p.Request = val } -var fieldIDToName_FrontendServiceLoadTxnRollbackArgs = map[int16]string{ +var fieldIDToName_FrontendServiceBeginTxnArgs = map[int16]string{ 1: "request", } -func (p *FrontendServiceLoadTxnRollbackArgs) IsSetRequest() bool { +func (p *FrontendServiceBeginTxnArgs) IsSetRequest() bool { return p.Request != nil } -func (p *FrontendServiceLoadTxnRollbackArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceBeginTxnArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -84576,7 +86064,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceLoadTxnRollbackArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceBeginTxnArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -84586,8 +86074,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceLoadTxnRollbackArgs) ReadField1(iprot thrift.TProtocol) error { - _field := NewTLoadTxnRollbackRequest() +func (p *FrontendServiceBeginTxnArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewTBeginTxnRequest() if err := _field.Read(iprot); err != nil { return err } @@ -84595,9 +86083,9 @@ func (p *FrontendServiceLoadTxnRollbackArgs) ReadField1(iprot thrift.TProtocol) return nil } -func (p *FrontendServiceLoadTxnRollbackArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceBeginTxnArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("loadTxnRollback_args"); err != nil { + if err = oprot.WriteStructBegin("beginTxn_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -84623,7 +86111,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceLoadTxnRollbackArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceBeginTxnArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("request", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -84640,15 +86128,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *FrontendServiceLoadTxnRollbackArgs) String() string { +func (p *FrontendServiceBeginTxnArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceLoadTxnRollbackArgs(%+v)", *p) + return fmt.Sprintf("FrontendServiceBeginTxnArgs(%+v)", *p) } -func (p *FrontendServiceLoadTxnRollbackArgs) DeepEqual(ano *FrontendServiceLoadTxnRollbackArgs) bool { +func (p *FrontendServiceBeginTxnArgs) DeepEqual(ano *FrontendServiceBeginTxnArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -84660,7 +86148,7 @@ func (p *FrontendServiceLoadTxnRollbackArgs) DeepEqual(ano *FrontendServiceLoadT return true } -func (p *FrontendServiceLoadTxnRollbackArgs) Field1DeepEqual(src *TLoadTxnRollbackRequest) bool { +func (p *FrontendServiceBeginTxnArgs) Field1DeepEqual(src *TBeginTxnRequest) bool { if !p.Request.DeepEqual(src) { return false @@ -84668,38 +86156,38 @@ func (p *FrontendServiceLoadTxnRollbackArgs) Field1DeepEqual(src *TLoadTxnRollba return true } -type FrontendServiceLoadTxnRollbackResult struct { - Success *TLoadTxnRollbackResult_ `thrift:"success,0,optional" frugal:"0,optional,TLoadTxnRollbackResult_" json:"success,omitempty"` +type FrontendServiceBeginTxnResult struct { + Success *TBeginTxnResult_ `thrift:"success,0,optional" frugal:"0,optional,TBeginTxnResult_" json:"success,omitempty"` } -func NewFrontendServiceLoadTxnRollbackResult() *FrontendServiceLoadTxnRollbackResult { - return &FrontendServiceLoadTxnRollbackResult{} +func NewFrontendServiceBeginTxnResult() *FrontendServiceBeginTxnResult { + return &FrontendServiceBeginTxnResult{} } -func (p *FrontendServiceLoadTxnRollbackResult) InitDefault() { +func (p *FrontendServiceBeginTxnResult) InitDefault() { } -var FrontendServiceLoadTxnRollbackResult_Success_DEFAULT *TLoadTxnRollbackResult_ +var FrontendServiceBeginTxnResult_Success_DEFAULT *TBeginTxnResult_ -func (p *FrontendServiceLoadTxnRollbackResult) GetSuccess() (v *TLoadTxnRollbackResult_) { +func (p *FrontendServiceBeginTxnResult) GetSuccess() (v *TBeginTxnResult_) { if !p.IsSetSuccess() { - return FrontendServiceLoadTxnRollbackResult_Success_DEFAULT + return FrontendServiceBeginTxnResult_Success_DEFAULT } return p.Success } -func (p *FrontendServiceLoadTxnRollbackResult) SetSuccess(x interface{}) { - p.Success = x.(*TLoadTxnRollbackResult_) +func (p *FrontendServiceBeginTxnResult) SetSuccess(x interface{}) { + p.Success = x.(*TBeginTxnResult_) } -var fieldIDToName_FrontendServiceLoadTxnRollbackResult = map[int16]string{ +var fieldIDToName_FrontendServiceBeginTxnResult = map[int16]string{ 0: "success", } -func (p *FrontendServiceLoadTxnRollbackResult) IsSetSuccess() bool { +func (p *FrontendServiceBeginTxnResult) IsSetSuccess() bool { return p.Success != nil } -func (p *FrontendServiceLoadTxnRollbackResult) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceBeginTxnResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -84745,7 +86233,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceLoadTxnRollbackResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceBeginTxnResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -84755,8 +86243,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceLoadTxnRollbackResult) ReadField0(iprot thrift.TProtocol) error { - _field := NewTLoadTxnRollbackResult_() +func (p *FrontendServiceBeginTxnResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewTBeginTxnResult_() if err := _field.Read(iprot); err != nil { return err } @@ -84764,9 +86252,9 @@ func (p *FrontendServiceLoadTxnRollbackResult) ReadField0(iprot thrift.TProtocol return nil } -func (p *FrontendServiceLoadTxnRollbackResult) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceBeginTxnResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("loadTxnRollback_result"); err != nil { + if err = oprot.WriteStructBegin("beginTxn_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -84792,7 +86280,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceLoadTxnRollbackResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceBeginTxnResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -84811,15 +86299,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *FrontendServiceLoadTxnRollbackResult) String() string { +func (p *FrontendServiceBeginTxnResult) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceLoadTxnRollbackResult(%+v)", *p) + return fmt.Sprintf("FrontendServiceBeginTxnResult(%+v)", *p) } -func (p *FrontendServiceLoadTxnRollbackResult) DeepEqual(ano *FrontendServiceLoadTxnRollbackResult) bool { +func (p *FrontendServiceBeginTxnResult) DeepEqual(ano *FrontendServiceBeginTxnResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -84831,7 +86319,7 @@ func (p *FrontendServiceLoadTxnRollbackResult) DeepEqual(ano *FrontendServiceLoa return true } -func (p *FrontendServiceLoadTxnRollbackResult) Field0DeepEqual(src *TLoadTxnRollbackResult_) bool { +func (p *FrontendServiceBeginTxnResult) Field0DeepEqual(src *TBeginTxnResult_) bool { if !p.Success.DeepEqual(src) { return false @@ -84839,38 +86327,38 @@ func (p *FrontendServiceLoadTxnRollbackResult) Field0DeepEqual(src *TLoadTxnRoll return true } -type FrontendServiceBeginTxnArgs struct { - Request *TBeginTxnRequest `thrift:"request,1" frugal:"1,default,TBeginTxnRequest" json:"request"` +type FrontendServiceCommitTxnArgs struct { + Request *TCommitTxnRequest `thrift:"request,1" frugal:"1,default,TCommitTxnRequest" json:"request"` } -func NewFrontendServiceBeginTxnArgs() *FrontendServiceBeginTxnArgs { - return &FrontendServiceBeginTxnArgs{} +func NewFrontendServiceCommitTxnArgs() *FrontendServiceCommitTxnArgs { + return &FrontendServiceCommitTxnArgs{} } -func (p *FrontendServiceBeginTxnArgs) InitDefault() { +func (p *FrontendServiceCommitTxnArgs) InitDefault() { } -var FrontendServiceBeginTxnArgs_Request_DEFAULT *TBeginTxnRequest +var FrontendServiceCommitTxnArgs_Request_DEFAULT *TCommitTxnRequest -func (p *FrontendServiceBeginTxnArgs) GetRequest() (v *TBeginTxnRequest) { +func (p *FrontendServiceCommitTxnArgs) GetRequest() (v *TCommitTxnRequest) { if !p.IsSetRequest() { - return FrontendServiceBeginTxnArgs_Request_DEFAULT + return FrontendServiceCommitTxnArgs_Request_DEFAULT } return p.Request } -func (p *FrontendServiceBeginTxnArgs) SetRequest(val *TBeginTxnRequest) { +func (p *FrontendServiceCommitTxnArgs) SetRequest(val *TCommitTxnRequest) { p.Request = val } -var fieldIDToName_FrontendServiceBeginTxnArgs = map[int16]string{ +var fieldIDToName_FrontendServiceCommitTxnArgs = map[int16]string{ 1: "request", } -func (p *FrontendServiceBeginTxnArgs) IsSetRequest() bool { +func (p *FrontendServiceCommitTxnArgs) IsSetRequest() bool { return p.Request != nil } -func (p *FrontendServiceBeginTxnArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceCommitTxnArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -84916,7 +86404,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceBeginTxnArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceCommitTxnArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -84926,8 +86414,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceBeginTxnArgs) ReadField1(iprot thrift.TProtocol) error { - _field := NewTBeginTxnRequest() +func (p *FrontendServiceCommitTxnArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewTCommitTxnRequest() if err := _field.Read(iprot); err != nil { return err } @@ -84935,9 +86423,9 @@ func (p *FrontendServiceBeginTxnArgs) ReadField1(iprot thrift.TProtocol) error { return nil } -func (p *FrontendServiceBeginTxnArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceCommitTxnArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("beginTxn_args"); err != nil { + if err = oprot.WriteStructBegin("commitTxn_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -84963,7 +86451,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceBeginTxnArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceCommitTxnArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("request", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -84980,15 +86468,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *FrontendServiceBeginTxnArgs) String() string { +func (p *FrontendServiceCommitTxnArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceBeginTxnArgs(%+v)", *p) + return fmt.Sprintf("FrontendServiceCommitTxnArgs(%+v)", *p) } -func (p *FrontendServiceBeginTxnArgs) DeepEqual(ano *FrontendServiceBeginTxnArgs) bool { +func (p *FrontendServiceCommitTxnArgs) DeepEqual(ano *FrontendServiceCommitTxnArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -85000,7 +86488,7 @@ func (p *FrontendServiceBeginTxnArgs) DeepEqual(ano *FrontendServiceBeginTxnArgs return true } -func (p *FrontendServiceBeginTxnArgs) Field1DeepEqual(src *TBeginTxnRequest) bool { +func (p *FrontendServiceCommitTxnArgs) Field1DeepEqual(src *TCommitTxnRequest) bool { if !p.Request.DeepEqual(src) { return false @@ -85008,38 +86496,38 @@ func (p *FrontendServiceBeginTxnArgs) Field1DeepEqual(src *TBeginTxnRequest) boo return true } -type FrontendServiceBeginTxnResult struct { - Success *TBeginTxnResult_ `thrift:"success,0,optional" frugal:"0,optional,TBeginTxnResult_" json:"success,omitempty"` +type FrontendServiceCommitTxnResult struct { + Success *TCommitTxnResult_ `thrift:"success,0,optional" frugal:"0,optional,TCommitTxnResult_" json:"success,omitempty"` } -func NewFrontendServiceBeginTxnResult() *FrontendServiceBeginTxnResult { - return &FrontendServiceBeginTxnResult{} +func NewFrontendServiceCommitTxnResult() *FrontendServiceCommitTxnResult { + return &FrontendServiceCommitTxnResult{} } -func (p *FrontendServiceBeginTxnResult) InitDefault() { +func (p *FrontendServiceCommitTxnResult) InitDefault() { } -var FrontendServiceBeginTxnResult_Success_DEFAULT *TBeginTxnResult_ +var FrontendServiceCommitTxnResult_Success_DEFAULT *TCommitTxnResult_ -func (p *FrontendServiceBeginTxnResult) GetSuccess() (v *TBeginTxnResult_) { +func (p *FrontendServiceCommitTxnResult) GetSuccess() (v *TCommitTxnResult_) { if !p.IsSetSuccess() { - return FrontendServiceBeginTxnResult_Success_DEFAULT + return FrontendServiceCommitTxnResult_Success_DEFAULT } return p.Success } -func (p *FrontendServiceBeginTxnResult) SetSuccess(x interface{}) { - p.Success = x.(*TBeginTxnResult_) +func (p *FrontendServiceCommitTxnResult) SetSuccess(x interface{}) { + p.Success = x.(*TCommitTxnResult_) } -var fieldIDToName_FrontendServiceBeginTxnResult = map[int16]string{ +var fieldIDToName_FrontendServiceCommitTxnResult = map[int16]string{ 0: "success", } -func (p *FrontendServiceBeginTxnResult) IsSetSuccess() bool { +func (p *FrontendServiceCommitTxnResult) IsSetSuccess() bool { return p.Success != nil } -func (p *FrontendServiceBeginTxnResult) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceCommitTxnResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -85085,7 +86573,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceBeginTxnResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceCommitTxnResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -85095,8 +86583,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceBeginTxnResult) ReadField0(iprot thrift.TProtocol) error { - _field := NewTBeginTxnResult_() +func (p *FrontendServiceCommitTxnResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewTCommitTxnResult_() if err := _field.Read(iprot); err != nil { return err } @@ -85104,9 +86592,9 @@ func (p *FrontendServiceBeginTxnResult) ReadField0(iprot thrift.TProtocol) error return nil } -func (p *FrontendServiceBeginTxnResult) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceCommitTxnResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("beginTxn_result"); err != nil { + if err = oprot.WriteStructBegin("commitTxn_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -85132,7 +86620,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceBeginTxnResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceCommitTxnResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -85151,15 +86639,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *FrontendServiceBeginTxnResult) String() string { +func (p *FrontendServiceCommitTxnResult) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceBeginTxnResult(%+v)", *p) + return fmt.Sprintf("FrontendServiceCommitTxnResult(%+v)", *p) } -func (p *FrontendServiceBeginTxnResult) DeepEqual(ano *FrontendServiceBeginTxnResult) bool { +func (p *FrontendServiceCommitTxnResult) DeepEqual(ano *FrontendServiceCommitTxnResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -85171,7 +86659,7 @@ func (p *FrontendServiceBeginTxnResult) DeepEqual(ano *FrontendServiceBeginTxnRe return true } -func (p *FrontendServiceBeginTxnResult) Field0DeepEqual(src *TBeginTxnResult_) bool { +func (p *FrontendServiceCommitTxnResult) Field0DeepEqual(src *TCommitTxnResult_) bool { if !p.Success.DeepEqual(src) { return false @@ -85179,38 +86667,38 @@ func (p *FrontendServiceBeginTxnResult) Field0DeepEqual(src *TBeginTxnResult_) b return true } -type FrontendServiceCommitTxnArgs struct { - Request *TCommitTxnRequest `thrift:"request,1" frugal:"1,default,TCommitTxnRequest" json:"request"` +type FrontendServiceRollbackTxnArgs struct { + Request *TRollbackTxnRequest `thrift:"request,1" frugal:"1,default,TRollbackTxnRequest" json:"request"` } -func NewFrontendServiceCommitTxnArgs() *FrontendServiceCommitTxnArgs { - return &FrontendServiceCommitTxnArgs{} +func NewFrontendServiceRollbackTxnArgs() *FrontendServiceRollbackTxnArgs { + return &FrontendServiceRollbackTxnArgs{} } -func (p *FrontendServiceCommitTxnArgs) InitDefault() { +func (p *FrontendServiceRollbackTxnArgs) InitDefault() { } -var FrontendServiceCommitTxnArgs_Request_DEFAULT *TCommitTxnRequest +var FrontendServiceRollbackTxnArgs_Request_DEFAULT *TRollbackTxnRequest -func (p *FrontendServiceCommitTxnArgs) GetRequest() (v *TCommitTxnRequest) { +func (p *FrontendServiceRollbackTxnArgs) GetRequest() (v *TRollbackTxnRequest) { if !p.IsSetRequest() { - return FrontendServiceCommitTxnArgs_Request_DEFAULT + return FrontendServiceRollbackTxnArgs_Request_DEFAULT } return p.Request } -func (p *FrontendServiceCommitTxnArgs) SetRequest(val *TCommitTxnRequest) { +func (p *FrontendServiceRollbackTxnArgs) SetRequest(val *TRollbackTxnRequest) { p.Request = val } -var fieldIDToName_FrontendServiceCommitTxnArgs = map[int16]string{ +var fieldIDToName_FrontendServiceRollbackTxnArgs = map[int16]string{ 1: "request", } -func (p *FrontendServiceCommitTxnArgs) IsSetRequest() bool { +func (p *FrontendServiceRollbackTxnArgs) IsSetRequest() bool { return p.Request != nil } -func (p *FrontendServiceCommitTxnArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceRollbackTxnArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -85256,7 +86744,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceCommitTxnArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceRollbackTxnArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -85266,8 +86754,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceCommitTxnArgs) ReadField1(iprot thrift.TProtocol) error { - _field := NewTCommitTxnRequest() +func (p *FrontendServiceRollbackTxnArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewTRollbackTxnRequest() if err := _field.Read(iprot); err != nil { return err } @@ -85275,9 +86763,9 @@ func (p *FrontendServiceCommitTxnArgs) ReadField1(iprot thrift.TProtocol) error return nil } -func (p *FrontendServiceCommitTxnArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceRollbackTxnArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("commitTxn_args"); err != nil { + if err = oprot.WriteStructBegin("rollbackTxn_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -85303,7 +86791,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceCommitTxnArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceRollbackTxnArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("request", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -85320,15 +86808,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *FrontendServiceCommitTxnArgs) String() string { +func (p *FrontendServiceRollbackTxnArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceCommitTxnArgs(%+v)", *p) + return fmt.Sprintf("FrontendServiceRollbackTxnArgs(%+v)", *p) } -func (p *FrontendServiceCommitTxnArgs) DeepEqual(ano *FrontendServiceCommitTxnArgs) bool { +func (p *FrontendServiceRollbackTxnArgs) DeepEqual(ano *FrontendServiceRollbackTxnArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -85340,7 +86828,7 @@ func (p *FrontendServiceCommitTxnArgs) DeepEqual(ano *FrontendServiceCommitTxnAr return true } -func (p *FrontendServiceCommitTxnArgs) Field1DeepEqual(src *TCommitTxnRequest) bool { +func (p *FrontendServiceRollbackTxnArgs) Field1DeepEqual(src *TRollbackTxnRequest) bool { if !p.Request.DeepEqual(src) { return false @@ -85348,38 +86836,38 @@ func (p *FrontendServiceCommitTxnArgs) Field1DeepEqual(src *TCommitTxnRequest) b return true } -type FrontendServiceCommitTxnResult struct { - Success *TCommitTxnResult_ `thrift:"success,0,optional" frugal:"0,optional,TCommitTxnResult_" json:"success,omitempty"` +type FrontendServiceRollbackTxnResult struct { + Success *TRollbackTxnResult_ `thrift:"success,0,optional" frugal:"0,optional,TRollbackTxnResult_" json:"success,omitempty"` } -func NewFrontendServiceCommitTxnResult() *FrontendServiceCommitTxnResult { - return &FrontendServiceCommitTxnResult{} +func NewFrontendServiceRollbackTxnResult() *FrontendServiceRollbackTxnResult { + return &FrontendServiceRollbackTxnResult{} } -func (p *FrontendServiceCommitTxnResult) InitDefault() { +func (p *FrontendServiceRollbackTxnResult) InitDefault() { } -var FrontendServiceCommitTxnResult_Success_DEFAULT *TCommitTxnResult_ +var FrontendServiceRollbackTxnResult_Success_DEFAULT *TRollbackTxnResult_ -func (p *FrontendServiceCommitTxnResult) GetSuccess() (v *TCommitTxnResult_) { +func (p *FrontendServiceRollbackTxnResult) GetSuccess() (v *TRollbackTxnResult_) { if !p.IsSetSuccess() { - return FrontendServiceCommitTxnResult_Success_DEFAULT + return FrontendServiceRollbackTxnResult_Success_DEFAULT } return p.Success } -func (p *FrontendServiceCommitTxnResult) SetSuccess(x interface{}) { - p.Success = x.(*TCommitTxnResult_) +func (p *FrontendServiceRollbackTxnResult) SetSuccess(x interface{}) { + p.Success = x.(*TRollbackTxnResult_) } -var fieldIDToName_FrontendServiceCommitTxnResult = map[int16]string{ +var fieldIDToName_FrontendServiceRollbackTxnResult = map[int16]string{ 0: "success", } -func (p *FrontendServiceCommitTxnResult) IsSetSuccess() bool { +func (p *FrontendServiceRollbackTxnResult) IsSetSuccess() bool { return p.Success != nil } -func (p *FrontendServiceCommitTxnResult) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceRollbackTxnResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -85425,7 +86913,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceCommitTxnResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceRollbackTxnResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -85435,8 +86923,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceCommitTxnResult) ReadField0(iprot thrift.TProtocol) error { - _field := NewTCommitTxnResult_() +func (p *FrontendServiceRollbackTxnResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewTRollbackTxnResult_() if err := _field.Read(iprot); err != nil { return err } @@ -85444,9 +86932,9 @@ func (p *FrontendServiceCommitTxnResult) ReadField0(iprot thrift.TProtocol) erro return nil } -func (p *FrontendServiceCommitTxnResult) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceRollbackTxnResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("commitTxn_result"); err != nil { + if err = oprot.WriteStructBegin("rollbackTxn_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -85472,7 +86960,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceCommitTxnResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceRollbackTxnResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -85491,15 +86979,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *FrontendServiceCommitTxnResult) String() string { +func (p *FrontendServiceRollbackTxnResult) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceCommitTxnResult(%+v)", *p) + return fmt.Sprintf("FrontendServiceRollbackTxnResult(%+v)", *p) } -func (p *FrontendServiceCommitTxnResult) DeepEqual(ano *FrontendServiceCommitTxnResult) bool { +func (p *FrontendServiceRollbackTxnResult) DeepEqual(ano *FrontendServiceRollbackTxnResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -85511,7 +86999,7 @@ func (p *FrontendServiceCommitTxnResult) DeepEqual(ano *FrontendServiceCommitTxn return true } -func (p *FrontendServiceCommitTxnResult) Field0DeepEqual(src *TCommitTxnResult_) bool { +func (p *FrontendServiceRollbackTxnResult) Field0DeepEqual(src *TRollbackTxnResult_) bool { if !p.Success.DeepEqual(src) { return false @@ -85519,38 +87007,38 @@ func (p *FrontendServiceCommitTxnResult) Field0DeepEqual(src *TCommitTxnResult_) return true } -type FrontendServiceRollbackTxnArgs struct { - Request *TRollbackTxnRequest `thrift:"request,1" frugal:"1,default,TRollbackTxnRequest" json:"request"` +type FrontendServiceGetBinlogArgs struct { + Request *TGetBinlogRequest `thrift:"request,1" frugal:"1,default,TGetBinlogRequest" json:"request"` } -func NewFrontendServiceRollbackTxnArgs() *FrontendServiceRollbackTxnArgs { - return &FrontendServiceRollbackTxnArgs{} +func NewFrontendServiceGetBinlogArgs() *FrontendServiceGetBinlogArgs { + return &FrontendServiceGetBinlogArgs{} } -func (p *FrontendServiceRollbackTxnArgs) InitDefault() { +func (p *FrontendServiceGetBinlogArgs) InitDefault() { } -var FrontendServiceRollbackTxnArgs_Request_DEFAULT *TRollbackTxnRequest +var FrontendServiceGetBinlogArgs_Request_DEFAULT *TGetBinlogRequest -func (p *FrontendServiceRollbackTxnArgs) GetRequest() (v *TRollbackTxnRequest) { +func (p *FrontendServiceGetBinlogArgs) GetRequest() (v *TGetBinlogRequest) { if !p.IsSetRequest() { - return FrontendServiceRollbackTxnArgs_Request_DEFAULT + return FrontendServiceGetBinlogArgs_Request_DEFAULT } return p.Request } -func (p *FrontendServiceRollbackTxnArgs) SetRequest(val *TRollbackTxnRequest) { +func (p *FrontendServiceGetBinlogArgs) SetRequest(val *TGetBinlogRequest) { p.Request = val } -var fieldIDToName_FrontendServiceRollbackTxnArgs = map[int16]string{ +var fieldIDToName_FrontendServiceGetBinlogArgs = map[int16]string{ 1: "request", } -func (p *FrontendServiceRollbackTxnArgs) IsSetRequest() bool { +func (p *FrontendServiceGetBinlogArgs) IsSetRequest() bool { return p.Request != nil } -func (p *FrontendServiceRollbackTxnArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceGetBinlogArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -85596,7 +87084,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceRollbackTxnArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceGetBinlogArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -85606,8 +87094,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceRollbackTxnArgs) ReadField1(iprot thrift.TProtocol) error { - _field := NewTRollbackTxnRequest() +func (p *FrontendServiceGetBinlogArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewTGetBinlogRequest() if err := _field.Read(iprot); err != nil { return err } @@ -85615,9 +87103,9 @@ func (p *FrontendServiceRollbackTxnArgs) ReadField1(iprot thrift.TProtocol) erro return nil } -func (p *FrontendServiceRollbackTxnArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceGetBinlogArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("rollbackTxn_args"); err != nil { + if err = oprot.WriteStructBegin("getBinlog_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -85643,7 +87131,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceRollbackTxnArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceGetBinlogArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("request", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -85660,15 +87148,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *FrontendServiceRollbackTxnArgs) String() string { +func (p *FrontendServiceGetBinlogArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceRollbackTxnArgs(%+v)", *p) + return fmt.Sprintf("FrontendServiceGetBinlogArgs(%+v)", *p) } -func (p *FrontendServiceRollbackTxnArgs) DeepEqual(ano *FrontendServiceRollbackTxnArgs) bool { +func (p *FrontendServiceGetBinlogArgs) DeepEqual(ano *FrontendServiceGetBinlogArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -85680,7 +87168,7 @@ func (p *FrontendServiceRollbackTxnArgs) DeepEqual(ano *FrontendServiceRollbackT return true } -func (p *FrontendServiceRollbackTxnArgs) Field1DeepEqual(src *TRollbackTxnRequest) bool { +func (p *FrontendServiceGetBinlogArgs) Field1DeepEqual(src *TGetBinlogRequest) bool { if !p.Request.DeepEqual(src) { return false @@ -85688,38 +87176,38 @@ func (p *FrontendServiceRollbackTxnArgs) Field1DeepEqual(src *TRollbackTxnReques return true } -type FrontendServiceRollbackTxnResult struct { - Success *TRollbackTxnResult_ `thrift:"success,0,optional" frugal:"0,optional,TRollbackTxnResult_" json:"success,omitempty"` +type FrontendServiceGetBinlogResult struct { + Success *TGetBinlogResult_ `thrift:"success,0,optional" frugal:"0,optional,TGetBinlogResult_" json:"success,omitempty"` } -func NewFrontendServiceRollbackTxnResult() *FrontendServiceRollbackTxnResult { - return &FrontendServiceRollbackTxnResult{} +func NewFrontendServiceGetBinlogResult() *FrontendServiceGetBinlogResult { + return &FrontendServiceGetBinlogResult{} } -func (p *FrontendServiceRollbackTxnResult) InitDefault() { +func (p *FrontendServiceGetBinlogResult) InitDefault() { } -var FrontendServiceRollbackTxnResult_Success_DEFAULT *TRollbackTxnResult_ +var FrontendServiceGetBinlogResult_Success_DEFAULT *TGetBinlogResult_ -func (p *FrontendServiceRollbackTxnResult) GetSuccess() (v *TRollbackTxnResult_) { +func (p *FrontendServiceGetBinlogResult) GetSuccess() (v *TGetBinlogResult_) { if !p.IsSetSuccess() { - return FrontendServiceRollbackTxnResult_Success_DEFAULT + return FrontendServiceGetBinlogResult_Success_DEFAULT } return p.Success } -func (p *FrontendServiceRollbackTxnResult) SetSuccess(x interface{}) { - p.Success = x.(*TRollbackTxnResult_) +func (p *FrontendServiceGetBinlogResult) SetSuccess(x interface{}) { + p.Success = x.(*TGetBinlogResult_) } -var fieldIDToName_FrontendServiceRollbackTxnResult = map[int16]string{ +var fieldIDToName_FrontendServiceGetBinlogResult = map[int16]string{ 0: "success", } -func (p *FrontendServiceRollbackTxnResult) IsSetSuccess() bool { +func (p *FrontendServiceGetBinlogResult) IsSetSuccess() bool { return p.Success != nil } -func (p *FrontendServiceRollbackTxnResult) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceGetBinlogResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -85765,7 +87253,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceRollbackTxnResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceGetBinlogResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -85775,8 +87263,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceRollbackTxnResult) ReadField0(iprot thrift.TProtocol) error { - _field := NewTRollbackTxnResult_() +func (p *FrontendServiceGetBinlogResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewTGetBinlogResult_() if err := _field.Read(iprot); err != nil { return err } @@ -85784,9 +87272,9 @@ func (p *FrontendServiceRollbackTxnResult) ReadField0(iprot thrift.TProtocol) er return nil } -func (p *FrontendServiceRollbackTxnResult) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceGetBinlogResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("rollbackTxn_result"); err != nil { + if err = oprot.WriteStructBegin("getBinlog_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -85812,7 +87300,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceRollbackTxnResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceGetBinlogResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -85831,15 +87319,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *FrontendServiceRollbackTxnResult) String() string { +func (p *FrontendServiceGetBinlogResult) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceRollbackTxnResult(%+v)", *p) + return fmt.Sprintf("FrontendServiceGetBinlogResult(%+v)", *p) } -func (p *FrontendServiceRollbackTxnResult) DeepEqual(ano *FrontendServiceRollbackTxnResult) bool { +func (p *FrontendServiceGetBinlogResult) DeepEqual(ano *FrontendServiceGetBinlogResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -85851,7 +87339,7 @@ func (p *FrontendServiceRollbackTxnResult) DeepEqual(ano *FrontendServiceRollbac return true } -func (p *FrontendServiceRollbackTxnResult) Field0DeepEqual(src *TRollbackTxnResult_) bool { +func (p *FrontendServiceGetBinlogResult) Field0DeepEqual(src *TGetBinlogResult_) bool { if !p.Success.DeepEqual(src) { return false @@ -85859,38 +87347,38 @@ func (p *FrontendServiceRollbackTxnResult) Field0DeepEqual(src *TRollbackTxnResu return true } -type FrontendServiceGetBinlogArgs struct { - Request *TGetBinlogRequest `thrift:"request,1" frugal:"1,default,TGetBinlogRequest" json:"request"` +type FrontendServiceGetSnapshotArgs struct { + Request *TGetSnapshotRequest `thrift:"request,1" frugal:"1,default,TGetSnapshotRequest" json:"request"` } -func NewFrontendServiceGetBinlogArgs() *FrontendServiceGetBinlogArgs { - return &FrontendServiceGetBinlogArgs{} +func NewFrontendServiceGetSnapshotArgs() *FrontendServiceGetSnapshotArgs { + return &FrontendServiceGetSnapshotArgs{} } -func (p *FrontendServiceGetBinlogArgs) InitDefault() { +func (p *FrontendServiceGetSnapshotArgs) InitDefault() { } -var FrontendServiceGetBinlogArgs_Request_DEFAULT *TGetBinlogRequest +var FrontendServiceGetSnapshotArgs_Request_DEFAULT *TGetSnapshotRequest -func (p *FrontendServiceGetBinlogArgs) GetRequest() (v *TGetBinlogRequest) { +func (p *FrontendServiceGetSnapshotArgs) GetRequest() (v *TGetSnapshotRequest) { if !p.IsSetRequest() { - return FrontendServiceGetBinlogArgs_Request_DEFAULT + return FrontendServiceGetSnapshotArgs_Request_DEFAULT } return p.Request } -func (p *FrontendServiceGetBinlogArgs) SetRequest(val *TGetBinlogRequest) { +func (p *FrontendServiceGetSnapshotArgs) SetRequest(val *TGetSnapshotRequest) { p.Request = val } -var fieldIDToName_FrontendServiceGetBinlogArgs = map[int16]string{ +var fieldIDToName_FrontendServiceGetSnapshotArgs = map[int16]string{ 1: "request", } -func (p *FrontendServiceGetBinlogArgs) IsSetRequest() bool { +func (p *FrontendServiceGetSnapshotArgs) IsSetRequest() bool { return p.Request != nil } -func (p *FrontendServiceGetBinlogArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceGetSnapshotArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -85936,7 +87424,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceGetBinlogArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceGetSnapshotArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -85946,8 +87434,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceGetBinlogArgs) ReadField1(iprot thrift.TProtocol) error { - _field := NewTGetBinlogRequest() +func (p *FrontendServiceGetSnapshotArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewTGetSnapshotRequest() if err := _field.Read(iprot); err != nil { return err } @@ -85955,9 +87443,9 @@ func (p *FrontendServiceGetBinlogArgs) ReadField1(iprot thrift.TProtocol) error return nil } -func (p *FrontendServiceGetBinlogArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceGetSnapshotArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("getBinlog_args"); err != nil { + if err = oprot.WriteStructBegin("getSnapshot_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -85983,7 +87471,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceGetBinlogArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceGetSnapshotArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("request", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -86000,15 +87488,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *FrontendServiceGetBinlogArgs) String() string { +func (p *FrontendServiceGetSnapshotArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceGetBinlogArgs(%+v)", *p) + return fmt.Sprintf("FrontendServiceGetSnapshotArgs(%+v)", *p) } -func (p *FrontendServiceGetBinlogArgs) DeepEqual(ano *FrontendServiceGetBinlogArgs) bool { +func (p *FrontendServiceGetSnapshotArgs) DeepEqual(ano *FrontendServiceGetSnapshotArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -86020,7 +87508,7 @@ func (p *FrontendServiceGetBinlogArgs) DeepEqual(ano *FrontendServiceGetBinlogAr return true } -func (p *FrontendServiceGetBinlogArgs) Field1DeepEqual(src *TGetBinlogRequest) bool { +func (p *FrontendServiceGetSnapshotArgs) Field1DeepEqual(src *TGetSnapshotRequest) bool { if !p.Request.DeepEqual(src) { return false @@ -86028,38 +87516,38 @@ func (p *FrontendServiceGetBinlogArgs) Field1DeepEqual(src *TGetBinlogRequest) b return true } -type FrontendServiceGetBinlogResult struct { - Success *TGetBinlogResult_ `thrift:"success,0,optional" frugal:"0,optional,TGetBinlogResult_" json:"success,omitempty"` +type FrontendServiceGetSnapshotResult struct { + Success *TGetSnapshotResult_ `thrift:"success,0,optional" frugal:"0,optional,TGetSnapshotResult_" json:"success,omitempty"` } -func NewFrontendServiceGetBinlogResult() *FrontendServiceGetBinlogResult { - return &FrontendServiceGetBinlogResult{} +func NewFrontendServiceGetSnapshotResult() *FrontendServiceGetSnapshotResult { + return &FrontendServiceGetSnapshotResult{} } -func (p *FrontendServiceGetBinlogResult) InitDefault() { +func (p *FrontendServiceGetSnapshotResult) InitDefault() { } -var FrontendServiceGetBinlogResult_Success_DEFAULT *TGetBinlogResult_ +var FrontendServiceGetSnapshotResult_Success_DEFAULT *TGetSnapshotResult_ -func (p *FrontendServiceGetBinlogResult) GetSuccess() (v *TGetBinlogResult_) { +func (p *FrontendServiceGetSnapshotResult) GetSuccess() (v *TGetSnapshotResult_) { if !p.IsSetSuccess() { - return FrontendServiceGetBinlogResult_Success_DEFAULT + return FrontendServiceGetSnapshotResult_Success_DEFAULT } return p.Success } -func (p *FrontendServiceGetBinlogResult) SetSuccess(x interface{}) { - p.Success = x.(*TGetBinlogResult_) +func (p *FrontendServiceGetSnapshotResult) SetSuccess(x interface{}) { + p.Success = x.(*TGetSnapshotResult_) } -var fieldIDToName_FrontendServiceGetBinlogResult = map[int16]string{ +var fieldIDToName_FrontendServiceGetSnapshotResult = map[int16]string{ 0: "success", } -func (p *FrontendServiceGetBinlogResult) IsSetSuccess() bool { +func (p *FrontendServiceGetSnapshotResult) IsSetSuccess() bool { return p.Success != nil } -func (p *FrontendServiceGetBinlogResult) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceGetSnapshotResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -86105,7 +87593,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceGetBinlogResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceGetSnapshotResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -86115,8 +87603,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceGetBinlogResult) ReadField0(iprot thrift.TProtocol) error { - _field := NewTGetBinlogResult_() +func (p *FrontendServiceGetSnapshotResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewTGetSnapshotResult_() if err := _field.Read(iprot); err != nil { return err } @@ -86124,9 +87612,9 @@ func (p *FrontendServiceGetBinlogResult) ReadField0(iprot thrift.TProtocol) erro return nil } -func (p *FrontendServiceGetBinlogResult) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceGetSnapshotResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("getBinlog_result"); err != nil { + if err = oprot.WriteStructBegin("getSnapshot_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -86152,7 +87640,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceGetBinlogResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceGetSnapshotResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -86171,15 +87659,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *FrontendServiceGetBinlogResult) String() string { +func (p *FrontendServiceGetSnapshotResult) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceGetBinlogResult(%+v)", *p) + return fmt.Sprintf("FrontendServiceGetSnapshotResult(%+v)", *p) } -func (p *FrontendServiceGetBinlogResult) DeepEqual(ano *FrontendServiceGetBinlogResult) bool { +func (p *FrontendServiceGetSnapshotResult) DeepEqual(ano *FrontendServiceGetSnapshotResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -86191,7 +87679,7 @@ func (p *FrontendServiceGetBinlogResult) DeepEqual(ano *FrontendServiceGetBinlog return true } -func (p *FrontendServiceGetBinlogResult) Field0DeepEqual(src *TGetBinlogResult_) bool { +func (p *FrontendServiceGetSnapshotResult) Field0DeepEqual(src *TGetSnapshotResult_) bool { if !p.Success.DeepEqual(src) { return false @@ -86199,38 +87687,38 @@ func (p *FrontendServiceGetBinlogResult) Field0DeepEqual(src *TGetBinlogResult_) return true } -type FrontendServiceGetSnapshotArgs struct { - Request *TGetSnapshotRequest `thrift:"request,1" frugal:"1,default,TGetSnapshotRequest" json:"request"` +type FrontendServiceGetGlobalSnapshotArgs struct { + Request *TGetGlobalSnapshotRequest `thrift:"request,1" frugal:"1,default,TGetGlobalSnapshotRequest" json:"request"` } -func NewFrontendServiceGetSnapshotArgs() *FrontendServiceGetSnapshotArgs { - return &FrontendServiceGetSnapshotArgs{} +func NewFrontendServiceGetGlobalSnapshotArgs() *FrontendServiceGetGlobalSnapshotArgs { + return &FrontendServiceGetGlobalSnapshotArgs{} } -func (p *FrontendServiceGetSnapshotArgs) InitDefault() { +func (p *FrontendServiceGetGlobalSnapshotArgs) InitDefault() { } -var FrontendServiceGetSnapshotArgs_Request_DEFAULT *TGetSnapshotRequest +var FrontendServiceGetGlobalSnapshotArgs_Request_DEFAULT *TGetGlobalSnapshotRequest -func (p *FrontendServiceGetSnapshotArgs) GetRequest() (v *TGetSnapshotRequest) { +func (p *FrontendServiceGetGlobalSnapshotArgs) GetRequest() (v *TGetGlobalSnapshotRequest) { if !p.IsSetRequest() { - return FrontendServiceGetSnapshotArgs_Request_DEFAULT + return FrontendServiceGetGlobalSnapshotArgs_Request_DEFAULT } return p.Request } -func (p *FrontendServiceGetSnapshotArgs) SetRequest(val *TGetSnapshotRequest) { +func (p *FrontendServiceGetGlobalSnapshotArgs) SetRequest(val *TGetGlobalSnapshotRequest) { p.Request = val } -var fieldIDToName_FrontendServiceGetSnapshotArgs = map[int16]string{ +var fieldIDToName_FrontendServiceGetGlobalSnapshotArgs = map[int16]string{ 1: "request", } -func (p *FrontendServiceGetSnapshotArgs) IsSetRequest() bool { +func (p *FrontendServiceGetGlobalSnapshotArgs) IsSetRequest() bool { return p.Request != nil } -func (p *FrontendServiceGetSnapshotArgs) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceGetGlobalSnapshotArgs) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -86276,7 +87764,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceGetSnapshotArgs[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceGetGlobalSnapshotArgs[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -86286,8 +87774,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceGetSnapshotArgs) ReadField1(iprot thrift.TProtocol) error { - _field := NewTGetSnapshotRequest() +func (p *FrontendServiceGetGlobalSnapshotArgs) ReadField1(iprot thrift.TProtocol) error { + _field := NewTGetGlobalSnapshotRequest() if err := _field.Read(iprot); err != nil { return err } @@ -86295,9 +87783,9 @@ func (p *FrontendServiceGetSnapshotArgs) ReadField1(iprot thrift.TProtocol) erro return nil } -func (p *FrontendServiceGetSnapshotArgs) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceGetGlobalSnapshotArgs) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("getSnapshot_args"); err != nil { + if err = oprot.WriteStructBegin("getGlobalSnapshot_args"); err != nil { goto WriteStructBeginError } if p != nil { @@ -86323,7 +87811,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceGetSnapshotArgs) writeField1(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceGetGlobalSnapshotArgs) writeField1(oprot thrift.TProtocol) (err error) { if err = oprot.WriteFieldBegin("request", thrift.STRUCT, 1); err != nil { goto WriteFieldBeginError } @@ -86340,15 +87828,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err) } -func (p *FrontendServiceGetSnapshotArgs) String() string { +func (p *FrontendServiceGetGlobalSnapshotArgs) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceGetSnapshotArgs(%+v)", *p) + return fmt.Sprintf("FrontendServiceGetGlobalSnapshotArgs(%+v)", *p) } -func (p *FrontendServiceGetSnapshotArgs) DeepEqual(ano *FrontendServiceGetSnapshotArgs) bool { +func (p *FrontendServiceGetGlobalSnapshotArgs) DeepEqual(ano *FrontendServiceGetGlobalSnapshotArgs) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -86360,7 +87848,7 @@ func (p *FrontendServiceGetSnapshotArgs) DeepEqual(ano *FrontendServiceGetSnapsh return true } -func (p *FrontendServiceGetSnapshotArgs) Field1DeepEqual(src *TGetSnapshotRequest) bool { +func (p *FrontendServiceGetGlobalSnapshotArgs) Field1DeepEqual(src *TGetGlobalSnapshotRequest) bool { if !p.Request.DeepEqual(src) { return false @@ -86368,38 +87856,38 @@ func (p *FrontendServiceGetSnapshotArgs) Field1DeepEqual(src *TGetSnapshotReques return true } -type FrontendServiceGetSnapshotResult struct { - Success *TGetSnapshotResult_ `thrift:"success,0,optional" frugal:"0,optional,TGetSnapshotResult_" json:"success,omitempty"` +type FrontendServiceGetGlobalSnapshotResult struct { + Success *TGetGlobalSnapshotResult_ `thrift:"success,0,optional" frugal:"0,optional,TGetGlobalSnapshotResult_" json:"success,omitempty"` } -func NewFrontendServiceGetSnapshotResult() *FrontendServiceGetSnapshotResult { - return &FrontendServiceGetSnapshotResult{} +func NewFrontendServiceGetGlobalSnapshotResult() *FrontendServiceGetGlobalSnapshotResult { + return &FrontendServiceGetGlobalSnapshotResult{} } -func (p *FrontendServiceGetSnapshotResult) InitDefault() { +func (p *FrontendServiceGetGlobalSnapshotResult) InitDefault() { } -var FrontendServiceGetSnapshotResult_Success_DEFAULT *TGetSnapshotResult_ +var FrontendServiceGetGlobalSnapshotResult_Success_DEFAULT *TGetGlobalSnapshotResult_ -func (p *FrontendServiceGetSnapshotResult) GetSuccess() (v *TGetSnapshotResult_) { +func (p *FrontendServiceGetGlobalSnapshotResult) GetSuccess() (v *TGetGlobalSnapshotResult_) { if !p.IsSetSuccess() { - return FrontendServiceGetSnapshotResult_Success_DEFAULT + return FrontendServiceGetGlobalSnapshotResult_Success_DEFAULT } return p.Success } -func (p *FrontendServiceGetSnapshotResult) SetSuccess(x interface{}) { - p.Success = x.(*TGetSnapshotResult_) +func (p *FrontendServiceGetGlobalSnapshotResult) SetSuccess(x interface{}) { + p.Success = x.(*TGetGlobalSnapshotResult_) } -var fieldIDToName_FrontendServiceGetSnapshotResult = map[int16]string{ +var fieldIDToName_FrontendServiceGetGlobalSnapshotResult = map[int16]string{ 0: "success", } -func (p *FrontendServiceGetSnapshotResult) IsSetSuccess() bool { +func (p *FrontendServiceGetGlobalSnapshotResult) IsSetSuccess() bool { return p.Success != nil } -func (p *FrontendServiceGetSnapshotResult) Read(iprot thrift.TProtocol) (err error) { +func (p *FrontendServiceGetGlobalSnapshotResult) Read(iprot thrift.TProtocol) (err error) { var fieldTypeId thrift.TType var fieldId int16 @@ -86445,7 +87933,7 @@ ReadStructBeginError: ReadFieldBeginError: return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) ReadFieldError: - return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceGetSnapshotResult[fieldId]), err) + return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceGetGlobalSnapshotResult[fieldId]), err) SkipFieldError: return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) @@ -86455,8 +87943,8 @@ ReadStructEndError: return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) } -func (p *FrontendServiceGetSnapshotResult) ReadField0(iprot thrift.TProtocol) error { - _field := NewTGetSnapshotResult_() +func (p *FrontendServiceGetGlobalSnapshotResult) ReadField0(iprot thrift.TProtocol) error { + _field := NewTGetGlobalSnapshotResult_() if err := _field.Read(iprot); err != nil { return err } @@ -86464,9 +87952,9 @@ func (p *FrontendServiceGetSnapshotResult) ReadField0(iprot thrift.TProtocol) er return nil } -func (p *FrontendServiceGetSnapshotResult) Write(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceGetGlobalSnapshotResult) Write(oprot thrift.TProtocol) (err error) { var fieldId int16 - if err = oprot.WriteStructBegin("getSnapshot_result"); err != nil { + if err = oprot.WriteStructBegin("getGlobalSnapshot_result"); err != nil { goto WriteStructBeginError } if p != nil { @@ -86492,7 +87980,7 @@ WriteStructEndError: return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err) } -func (p *FrontendServiceGetSnapshotResult) writeField0(oprot thrift.TProtocol) (err error) { +func (p *FrontendServiceGetGlobalSnapshotResult) writeField0(oprot thrift.TProtocol) (err error) { if p.IsSetSuccess() { if err = oprot.WriteFieldBegin("success", thrift.STRUCT, 0); err != nil { goto WriteFieldBeginError @@ -86511,15 +87999,15 @@ WriteFieldEndError: return thrift.PrependError(fmt.Sprintf("%T write field 0 end error: ", p), err) } -func (p *FrontendServiceGetSnapshotResult) String() string { +func (p *FrontendServiceGetGlobalSnapshotResult) String() string { if p == nil { return "" } - return fmt.Sprintf("FrontendServiceGetSnapshotResult(%+v)", *p) + return fmt.Sprintf("FrontendServiceGetGlobalSnapshotResult(%+v)", *p) } -func (p *FrontendServiceGetSnapshotResult) DeepEqual(ano *FrontendServiceGetSnapshotResult) bool { +func (p *FrontendServiceGetGlobalSnapshotResult) DeepEqual(ano *FrontendServiceGetGlobalSnapshotResult) bool { if p == ano { return true } else if p == nil || ano == nil { @@ -86531,7 +88019,7 @@ func (p *FrontendServiceGetSnapshotResult) DeepEqual(ano *FrontendServiceGetSnap return true } -func (p *FrontendServiceGetSnapshotResult) Field0DeepEqual(src *TGetSnapshotResult_) bool { +func (p *FrontendServiceGetGlobalSnapshotResult) Field0DeepEqual(src *TGetGlobalSnapshotResult_) bool { if !p.Success.DeepEqual(src) { return false diff --git a/pkg/rpc/kitex_gen/frontendservice/frontendservice/client.go b/pkg/rpc/kitex_gen/frontendservice/frontendservice/client.go index a3cc2f1b..f6b59f5e 100644 --- a/pkg/rpc/kitex_gen/frontendservice/frontendservice/client.go +++ b/pkg/rpc/kitex_gen/frontendservice/frontendservice/client.go @@ -38,6 +38,7 @@ type Client interface { RollbackTxn(ctx context.Context, request *frontendservice.TRollbackTxnRequest, callOptions ...callopt.Option) (r *frontendservice.TRollbackTxnResult_, err error) GetBinlog(ctx context.Context, request *frontendservice.TGetBinlogRequest, callOptions ...callopt.Option) (r *frontendservice.TGetBinlogResult_, err error) GetSnapshot(ctx context.Context, request *frontendservice.TGetSnapshotRequest, callOptions ...callopt.Option) (r *frontendservice.TGetSnapshotResult_, err error) + GetGlobalSnapshot(ctx context.Context, request *frontendservice.TGetGlobalSnapshotRequest, callOptions ...callopt.Option) (r *frontendservice.TGetGlobalSnapshotResult_, err error) RestoreSnapshot(ctx context.Context, request *frontendservice.TRestoreSnapshotRequest, callOptions ...callopt.Option) (r *frontendservice.TRestoreSnapshotResult_, err error) LockBinlog(ctx context.Context, request *frontendservice.TLockBinlogRequest, callOptions ...callopt.Option) (r *frontendservice.TLockBinlogResult_, err error) WaitingTxnStatus(ctx context.Context, request *frontendservice.TWaitingTxnStatusRequest, callOptions ...callopt.Option) (r *frontendservice.TWaitingTxnStatusResult_, err error) @@ -231,6 +232,11 @@ func (p *kFrontendServiceClient) GetSnapshot(ctx context.Context, request *front return p.kClient.GetSnapshot(ctx, request) } +func (p *kFrontendServiceClient) GetGlobalSnapshot(ctx context.Context, request *frontendservice.TGetGlobalSnapshotRequest, callOptions ...callopt.Option) (r *frontendservice.TGetGlobalSnapshotResult_, err error) { + ctx = client.NewCtxWithCallOptions(ctx, callOptions) + return p.kClient.GetGlobalSnapshot(ctx, request) +} + func (p *kFrontendServiceClient) RestoreSnapshot(ctx context.Context, request *frontendservice.TRestoreSnapshotRequest, callOptions ...callopt.Option) (r *frontendservice.TRestoreSnapshotResult_, err error) { ctx = client.NewCtxWithCallOptions(ctx, callOptions) return p.kClient.RestoreSnapshot(ctx, request) diff --git a/pkg/rpc/kitex_gen/frontendservice/frontendservice/frontendservice.go b/pkg/rpc/kitex_gen/frontendservice/frontendservice/frontendservice.go index 536209f7..d5aad21c 100644 --- a/pkg/rpc/kitex_gen/frontendservice/frontendservice/frontendservice.go +++ b/pkg/rpc/kitex_gen/frontendservice/frontendservice/frontendservice.go @@ -46,6 +46,7 @@ func NewServiceInfo() *kitex.ServiceInfo { "rollbackTxn": kitex.NewMethodInfo(rollbackTxnHandler, newFrontendServiceRollbackTxnArgs, newFrontendServiceRollbackTxnResult, false), "getBinlog": kitex.NewMethodInfo(getBinlogHandler, newFrontendServiceGetBinlogArgs, newFrontendServiceGetBinlogResult, false), "getSnapshot": kitex.NewMethodInfo(getSnapshotHandler, newFrontendServiceGetSnapshotArgs, newFrontendServiceGetSnapshotResult, false), + "getGlobalSnapshot": kitex.NewMethodInfo(getGlobalSnapshotHandler, newFrontendServiceGetGlobalSnapshotArgs, newFrontendServiceGetGlobalSnapshotResult, false), "restoreSnapshot": kitex.NewMethodInfo(restoreSnapshotHandler, newFrontendServiceRestoreSnapshotArgs, newFrontendServiceRestoreSnapshotResult, false), "lockBinlog": kitex.NewMethodInfo(lockBinlogHandler, newFrontendServiceLockBinlogArgs, newFrontendServiceLockBinlogResult, false), "waitingTxnStatus": kitex.NewMethodInfo(waitingTxnStatusHandler, newFrontendServiceWaitingTxnStatusArgs, newFrontendServiceWaitingTxnStatusResult, false), @@ -549,6 +550,24 @@ func newFrontendServiceGetSnapshotResult() interface{} { return frontendservice.NewFrontendServiceGetSnapshotResult() } +func getGlobalSnapshotHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { + realArg := arg.(*frontendservice.FrontendServiceGetGlobalSnapshotArgs) + realResult := result.(*frontendservice.FrontendServiceGetGlobalSnapshotResult) + success, err := handler.(frontendservice.FrontendService).GetGlobalSnapshot(ctx, realArg.Request) + if err != nil { + return err + } + realResult.Success = success + return nil +} +func newFrontendServiceGetGlobalSnapshotArgs() interface{} { + return frontendservice.NewFrontendServiceGetGlobalSnapshotArgs() +} + +func newFrontendServiceGetGlobalSnapshotResult() interface{} { + return frontendservice.NewFrontendServiceGetGlobalSnapshotResult() +} + func restoreSnapshotHandler(ctx context.Context, handler interface{}, arg, result interface{}) error { realArg := arg.(*frontendservice.FrontendServiceRestoreSnapshotArgs) realResult := result.(*frontendservice.FrontendServiceRestoreSnapshotResult) @@ -1474,6 +1493,16 @@ func (p *kClient) GetSnapshot(ctx context.Context, request *frontendservice.TGet return _result.GetSuccess(), nil } +func (p *kClient) GetGlobalSnapshot(ctx context.Context, request *frontendservice.TGetGlobalSnapshotRequest) (r *frontendservice.TGetGlobalSnapshotResult_, err error) { + var _args frontendservice.FrontendServiceGetGlobalSnapshotArgs + _args.Request = request + var _result frontendservice.FrontendServiceGetGlobalSnapshotResult + if err = p.c.Call(ctx, "getGlobalSnapshot", &_args, &_result); err != nil { + return + } + return _result.GetSuccess(), nil +} + func (p *kClient) RestoreSnapshot(ctx context.Context, request *frontendservice.TRestoreSnapshotRequest) (r *frontendservice.TRestoreSnapshotResult_, err error) { var _args frontendservice.FrontendServiceRestoreSnapshotArgs _args.Request = request diff --git a/pkg/rpc/kitex_gen/frontendservice/k-FrontendService.go b/pkg/rpc/kitex_gen/frontendservice/k-FrontendService.go index 2b756ca5..7a86e8c9 100644 --- a/pkg/rpc/kitex_gen/frontendservice/k-FrontendService.go +++ b/pkg/rpc/kitex_gen/frontendservice/k-FrontendService.go @@ -38865,6 +38865,781 @@ func (p *TGetSnapshotResult_) field7Length() int { return l } +func (p *TGetGlobalSnapshotRequest) FastRead(buf []byte) (int, error) { + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + _, l, err = bthrift.Binary.ReadStructBegin(buf) + offset += l + if err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, l, err = bthrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 1: + if fieldTypeId == thrift.STRING { + l, err = p.FastReadField1(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 2: + if fieldTypeId == thrift.STRING { + l, err = p.FastReadField2(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 3: + if fieldTypeId == thrift.STRING { + l, err = p.FastReadField3(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 4: + if fieldTypeId == thrift.STRING { + l, err = p.FastReadField4(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 5: + if fieldTypeId == thrift.STRING { + l, err = p.FastReadField5(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 6: + if fieldTypeId == thrift.STRING { + l, err = p.FastReadField6(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 7: + if fieldTypeId == thrift.I32 { + l, err = p.FastReadField7(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + + l, err = bthrift.Binary.ReadFieldEnd(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldEndError + } + } + l, err = bthrift.Binary.ReadStructEnd(buf[offset:]) + offset += l + if err != nil { + goto ReadStructEndError + } + + return offset, nil +ReadStructBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_TGetGlobalSnapshotRequest[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +ReadFieldEndError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return offset, thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *TGetGlobalSnapshotRequest) FastReadField1(buf []byte) (int, error) { + offset := 0 + + if v, l, err := bthrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + p.Cluster = &v + + } + return offset, nil +} + +func (p *TGetGlobalSnapshotRequest) FastReadField2(buf []byte) (int, error) { + offset := 0 + + if v, l, err := bthrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + p.User = &v + + } + return offset, nil +} + +func (p *TGetGlobalSnapshotRequest) FastReadField3(buf []byte) (int, error) { + offset := 0 + + if v, l, err := bthrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + p.Passwd = &v + + } + return offset, nil +} + +func (p *TGetGlobalSnapshotRequest) FastReadField4(buf []byte) (int, error) { + offset := 0 + + if v, l, err := bthrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + p.Token = &v + + } + return offset, nil +} + +func (p *TGetGlobalSnapshotRequest) FastReadField5(buf []byte) (int, error) { + offset := 0 + + if v, l, err := bthrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + p.LabelName = &v + + } + return offset, nil +} + +func (p *TGetGlobalSnapshotRequest) FastReadField6(buf []byte) (int, error) { + offset := 0 + + if v, l, err := bthrift.Binary.ReadString(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + p.SnapshotName = &v + + } + return offset, nil +} + +func (p *TGetGlobalSnapshotRequest) FastReadField7(buf []byte) (int, error) { + offset := 0 + + if v, l, err := bthrift.Binary.ReadI32(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + + tmp := TSnapshotType(v) + p.SnapshotType = &tmp + + } + return offset, nil +} + +// for compatibility +func (p *TGetGlobalSnapshotRequest) FastWrite(buf []byte) int { + return 0 +} + +func (p *TGetGlobalSnapshotRequest) FastWriteNocopy(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + offset += bthrift.Binary.WriteStructBegin(buf[offset:], "TGetGlobalSnapshotRequest") + if p != nil { + offset += p.fastWriteField1(buf[offset:], binaryWriter) + offset += p.fastWriteField2(buf[offset:], binaryWriter) + offset += p.fastWriteField3(buf[offset:], binaryWriter) + offset += p.fastWriteField4(buf[offset:], binaryWriter) + offset += p.fastWriteField5(buf[offset:], binaryWriter) + offset += p.fastWriteField6(buf[offset:], binaryWriter) + offset += p.fastWriteField7(buf[offset:], binaryWriter) + } + offset += bthrift.Binary.WriteFieldStop(buf[offset:]) + offset += bthrift.Binary.WriteStructEnd(buf[offset:]) + return offset +} + +func (p *TGetGlobalSnapshotRequest) BLength() int { + l := 0 + l += bthrift.Binary.StructBeginLength("TGetGlobalSnapshotRequest") + if p != nil { + l += p.field1Length() + l += p.field2Length() + l += p.field3Length() + l += p.field4Length() + l += p.field5Length() + l += p.field6Length() + l += p.field7Length() + } + l += bthrift.Binary.FieldStopLength() + l += bthrift.Binary.StructEndLength() + return l +} + +func (p *TGetGlobalSnapshotRequest) fastWriteField1(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + if p.IsSetCluster() { + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "cluster", thrift.STRING, 1) + offset += bthrift.Binary.WriteStringNocopy(buf[offset:], binaryWriter, *p.Cluster) + + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + } + return offset +} + +func (p *TGetGlobalSnapshotRequest) fastWriteField2(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + if p.IsSetUser() { + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "user", thrift.STRING, 2) + offset += bthrift.Binary.WriteStringNocopy(buf[offset:], binaryWriter, *p.User) + + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + } + return offset +} + +func (p *TGetGlobalSnapshotRequest) fastWriteField3(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + if p.IsSetPasswd() { + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "passwd", thrift.STRING, 3) + offset += bthrift.Binary.WriteStringNocopy(buf[offset:], binaryWriter, *p.Passwd) + + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + } + return offset +} + +func (p *TGetGlobalSnapshotRequest) fastWriteField4(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + if p.IsSetToken() { + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "token", thrift.STRING, 4) + offset += bthrift.Binary.WriteStringNocopy(buf[offset:], binaryWriter, *p.Token) + + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + } + return offset +} + +func (p *TGetGlobalSnapshotRequest) fastWriteField5(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + if p.IsSetLabelName() { + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "label_name", thrift.STRING, 5) + offset += bthrift.Binary.WriteStringNocopy(buf[offset:], binaryWriter, *p.LabelName) + + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + } + return offset +} + +func (p *TGetGlobalSnapshotRequest) fastWriteField6(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + if p.IsSetSnapshotName() { + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "snapshot_name", thrift.STRING, 6) + offset += bthrift.Binary.WriteStringNocopy(buf[offset:], binaryWriter, *p.SnapshotName) + + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + } + return offset +} + +func (p *TGetGlobalSnapshotRequest) fastWriteField7(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + if p.IsSetSnapshotType() { + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "snapshot_type", thrift.I32, 7) + offset += bthrift.Binary.WriteI32(buf[offset:], int32(*p.SnapshotType)) + + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + } + return offset +} + +func (p *TGetGlobalSnapshotRequest) field1Length() int { + l := 0 + if p.IsSetCluster() { + l += bthrift.Binary.FieldBeginLength("cluster", thrift.STRING, 1) + l += bthrift.Binary.StringLengthNocopy(*p.Cluster) + + l += bthrift.Binary.FieldEndLength() + } + return l +} + +func (p *TGetGlobalSnapshotRequest) field2Length() int { + l := 0 + if p.IsSetUser() { + l += bthrift.Binary.FieldBeginLength("user", thrift.STRING, 2) + l += bthrift.Binary.StringLengthNocopy(*p.User) + + l += bthrift.Binary.FieldEndLength() + } + return l +} + +func (p *TGetGlobalSnapshotRequest) field3Length() int { + l := 0 + if p.IsSetPasswd() { + l += bthrift.Binary.FieldBeginLength("passwd", thrift.STRING, 3) + l += bthrift.Binary.StringLengthNocopy(*p.Passwd) + + l += bthrift.Binary.FieldEndLength() + } + return l +} + +func (p *TGetGlobalSnapshotRequest) field4Length() int { + l := 0 + if p.IsSetToken() { + l += bthrift.Binary.FieldBeginLength("token", thrift.STRING, 4) + l += bthrift.Binary.StringLengthNocopy(*p.Token) + + l += bthrift.Binary.FieldEndLength() + } + return l +} + +func (p *TGetGlobalSnapshotRequest) field5Length() int { + l := 0 + if p.IsSetLabelName() { + l += bthrift.Binary.FieldBeginLength("label_name", thrift.STRING, 5) + l += bthrift.Binary.StringLengthNocopy(*p.LabelName) + + l += bthrift.Binary.FieldEndLength() + } + return l +} + +func (p *TGetGlobalSnapshotRequest) field6Length() int { + l := 0 + if p.IsSetSnapshotName() { + l += bthrift.Binary.FieldBeginLength("snapshot_name", thrift.STRING, 6) + l += bthrift.Binary.StringLengthNocopy(*p.SnapshotName) + + l += bthrift.Binary.FieldEndLength() + } + return l +} + +func (p *TGetGlobalSnapshotRequest) field7Length() int { + l := 0 + if p.IsSetSnapshotType() { + l += bthrift.Binary.FieldBeginLength("snapshot_type", thrift.I32, 7) + l += bthrift.Binary.I32Length(int32(*p.SnapshotType)) + + l += bthrift.Binary.FieldEndLength() + } + return l +} + +func (p *TGetGlobalSnapshotResult_) FastRead(buf []byte) (int, error) { + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + _, l, err = bthrift.Binary.ReadStructBegin(buf) + offset += l + if err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, l, err = bthrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 1: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField1(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 2: + if fieldTypeId == thrift.STRING { + l, err = p.FastReadField2(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 3: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField3(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 4: + if fieldTypeId == thrift.I64 { + l, err = p.FastReadField4(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + case 5: + if fieldTypeId == thrift.I64 { + l, err = p.FastReadField5(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + + l, err = bthrift.Binary.ReadFieldEnd(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldEndError + } + } + l, err = bthrift.Binary.ReadStructEnd(buf[offset:]) + offset += l + if err != nil { + goto ReadStructEndError + } + + return offset, nil +ReadStructBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_TGetGlobalSnapshotResult_[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +ReadFieldEndError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return offset, thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *TGetGlobalSnapshotResult_) FastReadField1(buf []byte) (int, error) { + offset := 0 + + tmp := status.NewTStatus() + if l, err := tmp.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.Status = tmp + return offset, nil +} + +func (p *TGetGlobalSnapshotResult_) FastReadField2(buf []byte) (int, error) { + offset := 0 + + if v, l, err := bthrift.Binary.ReadBinary(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + + p.GlobalInfo = []byte(v) + + } + return offset, nil +} + +func (p *TGetGlobalSnapshotResult_) FastReadField3(buf []byte) (int, error) { + offset := 0 + + tmp := types.NewTNetworkAddress() + if l, err := tmp.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.MasterAddress = tmp + return offset, nil +} + +func (p *TGetGlobalSnapshotResult_) FastReadField4(buf []byte) (int, error) { + offset := 0 + + if v, l, err := bthrift.Binary.ReadI64(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + p.ExpiredAt = &v + + } + return offset, nil +} + +func (p *TGetGlobalSnapshotResult_) FastReadField5(buf []byte) (int, error) { + offset := 0 + + if v, l, err := bthrift.Binary.ReadI64(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + p.CommitSeq = &v + + } + return offset, nil +} + +// for compatibility +func (p *TGetGlobalSnapshotResult_) FastWrite(buf []byte) int { + return 0 +} + +func (p *TGetGlobalSnapshotResult_) FastWriteNocopy(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + offset += bthrift.Binary.WriteStructBegin(buf[offset:], "TGetGlobalSnapshotResult") + if p != nil { + offset += p.fastWriteField4(buf[offset:], binaryWriter) + offset += p.fastWriteField5(buf[offset:], binaryWriter) + offset += p.fastWriteField1(buf[offset:], binaryWriter) + offset += p.fastWriteField2(buf[offset:], binaryWriter) + offset += p.fastWriteField3(buf[offset:], binaryWriter) + } + offset += bthrift.Binary.WriteFieldStop(buf[offset:]) + offset += bthrift.Binary.WriteStructEnd(buf[offset:]) + return offset +} + +func (p *TGetGlobalSnapshotResult_) BLength() int { + l := 0 + l += bthrift.Binary.StructBeginLength("TGetGlobalSnapshotResult") + if p != nil { + l += p.field1Length() + l += p.field2Length() + l += p.field3Length() + l += p.field4Length() + l += p.field5Length() + } + l += bthrift.Binary.FieldStopLength() + l += bthrift.Binary.StructEndLength() + return l +} + +func (p *TGetGlobalSnapshotResult_) fastWriteField1(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + if p.IsSetStatus() { + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "status", thrift.STRUCT, 1) + offset += p.Status.FastWriteNocopy(buf[offset:], binaryWriter) + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + } + return offset +} + +func (p *TGetGlobalSnapshotResult_) fastWriteField2(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + if p.IsSetGlobalInfo() { + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "global_info", thrift.STRING, 2) + offset += bthrift.Binary.WriteBinaryNocopy(buf[offset:], binaryWriter, []byte(p.GlobalInfo)) + + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + } + return offset +} + +func (p *TGetGlobalSnapshotResult_) fastWriteField3(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + if p.IsSetMasterAddress() { + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "master_address", thrift.STRUCT, 3) + offset += p.MasterAddress.FastWriteNocopy(buf[offset:], binaryWriter) + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + } + return offset +} + +func (p *TGetGlobalSnapshotResult_) fastWriteField4(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + if p.IsSetExpiredAt() { + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "expiredAt", thrift.I64, 4) + offset += bthrift.Binary.WriteI64(buf[offset:], *p.ExpiredAt) + + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + } + return offset +} + +func (p *TGetGlobalSnapshotResult_) fastWriteField5(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + if p.IsSetCommitSeq() { + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "commit_seq", thrift.I64, 5) + offset += bthrift.Binary.WriteI64(buf[offset:], *p.CommitSeq) + + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + } + return offset +} + +func (p *TGetGlobalSnapshotResult_) field1Length() int { + l := 0 + if p.IsSetStatus() { + l += bthrift.Binary.FieldBeginLength("status", thrift.STRUCT, 1) + l += p.Status.BLength() + l += bthrift.Binary.FieldEndLength() + } + return l +} + +func (p *TGetGlobalSnapshotResult_) field2Length() int { + l := 0 + if p.IsSetGlobalInfo() { + l += bthrift.Binary.FieldBeginLength("global_info", thrift.STRING, 2) + l += bthrift.Binary.BinaryLengthNocopy([]byte(p.GlobalInfo)) + + l += bthrift.Binary.FieldEndLength() + } + return l +} + +func (p *TGetGlobalSnapshotResult_) field3Length() int { + l := 0 + if p.IsSetMasterAddress() { + l += bthrift.Binary.FieldBeginLength("master_address", thrift.STRUCT, 3) + l += p.MasterAddress.BLength() + l += bthrift.Binary.FieldEndLength() + } + return l +} + +func (p *TGetGlobalSnapshotResult_) field4Length() int { + l := 0 + if p.IsSetExpiredAt() { + l += bthrift.Binary.FieldBeginLength("expiredAt", thrift.I64, 4) + l += bthrift.Binary.I64Length(*p.ExpiredAt) + + l += bthrift.Binary.FieldEndLength() + } + return l +} + +func (p *TGetGlobalSnapshotResult_) field5Length() int { + l := 0 + if p.IsSetCommitSeq() { + l += bthrift.Binary.FieldBeginLength("commit_seq", thrift.I64, 5) + l += bthrift.Binary.I64Length(*p.CommitSeq) + + l += bthrift.Binary.FieldEndLength() + } + return l +} + func (p *TTableRef) FastRead(buf []byte) (int, error) { var err error var offset int @@ -60453,6 +61228,264 @@ func (p *FrontendServiceGetSnapshotResult) field0Length() int { return l } +func (p *FrontendServiceGetGlobalSnapshotArgs) FastRead(buf []byte) (int, error) { + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + _, l, err = bthrift.Binary.ReadStructBegin(buf) + offset += l + if err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, l, err = bthrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 1: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField1(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + + l, err = bthrift.Binary.ReadFieldEnd(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldEndError + } + } + l, err = bthrift.Binary.ReadStructEnd(buf[offset:]) + offset += l + if err != nil { + goto ReadStructEndError + } + + return offset, nil +ReadStructBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceGetGlobalSnapshotArgs[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +ReadFieldEndError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return offset, thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *FrontendServiceGetGlobalSnapshotArgs) FastReadField1(buf []byte) (int, error) { + offset := 0 + + tmp := NewTGetGlobalSnapshotRequest() + if l, err := tmp.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.Request = tmp + return offset, nil +} + +// for compatibility +func (p *FrontendServiceGetGlobalSnapshotArgs) FastWrite(buf []byte) int { + return 0 +} + +func (p *FrontendServiceGetGlobalSnapshotArgs) FastWriteNocopy(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + offset += bthrift.Binary.WriteStructBegin(buf[offset:], "getGlobalSnapshot_args") + if p != nil { + offset += p.fastWriteField1(buf[offset:], binaryWriter) + } + offset += bthrift.Binary.WriteFieldStop(buf[offset:]) + offset += bthrift.Binary.WriteStructEnd(buf[offset:]) + return offset +} + +func (p *FrontendServiceGetGlobalSnapshotArgs) BLength() int { + l := 0 + l += bthrift.Binary.StructBeginLength("getGlobalSnapshot_args") + if p != nil { + l += p.field1Length() + } + l += bthrift.Binary.FieldStopLength() + l += bthrift.Binary.StructEndLength() + return l +} + +func (p *FrontendServiceGetGlobalSnapshotArgs) fastWriteField1(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "request", thrift.STRUCT, 1) + offset += p.Request.FastWriteNocopy(buf[offset:], binaryWriter) + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + return offset +} + +func (p *FrontendServiceGetGlobalSnapshotArgs) field1Length() int { + l := 0 + l += bthrift.Binary.FieldBeginLength("request", thrift.STRUCT, 1) + l += p.Request.BLength() + l += bthrift.Binary.FieldEndLength() + return l +} + +func (p *FrontendServiceGetGlobalSnapshotResult) FastRead(buf []byte) (int, error) { + var err error + var offset int + var l int + var fieldTypeId thrift.TType + var fieldId int16 + _, l, err = bthrift.Binary.ReadStructBegin(buf) + offset += l + if err != nil { + goto ReadStructBeginError + } + + for { + _, fieldTypeId, fieldId, l, err = bthrift.Binary.ReadFieldBegin(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldBeginError + } + if fieldTypeId == thrift.STOP { + break + } + switch fieldId { + case 0: + if fieldTypeId == thrift.STRUCT { + l, err = p.FastReadField0(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldError + } + } else { + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + default: + l, err = bthrift.Binary.Skip(buf[offset:], fieldTypeId) + offset += l + if err != nil { + goto SkipFieldError + } + } + + l, err = bthrift.Binary.ReadFieldEnd(buf[offset:]) + offset += l + if err != nil { + goto ReadFieldEndError + } + } + l, err = bthrift.Binary.ReadStructEnd(buf[offset:]) + offset += l + if err != nil { + goto ReadStructEndError + } + + return offset, nil +ReadStructBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err) +ReadFieldBeginError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err) +ReadFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_FrontendServiceGetGlobalSnapshotResult[fieldId]), err) +SkipFieldError: + return offset, thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err) +ReadFieldEndError: + return offset, thrift.PrependError(fmt.Sprintf("%T read field end error", p), err) +ReadStructEndError: + return offset, thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) +} + +func (p *FrontendServiceGetGlobalSnapshotResult) FastReadField0(buf []byte) (int, error) { + offset := 0 + + tmp := NewTGetGlobalSnapshotResult_() + if l, err := tmp.FastRead(buf[offset:]); err != nil { + return offset, err + } else { + offset += l + } + p.Success = tmp + return offset, nil +} + +// for compatibility +func (p *FrontendServiceGetGlobalSnapshotResult) FastWrite(buf []byte) int { + return 0 +} + +func (p *FrontendServiceGetGlobalSnapshotResult) FastWriteNocopy(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + offset += bthrift.Binary.WriteStructBegin(buf[offset:], "getGlobalSnapshot_result") + if p != nil { + offset += p.fastWriteField0(buf[offset:], binaryWriter) + } + offset += bthrift.Binary.WriteFieldStop(buf[offset:]) + offset += bthrift.Binary.WriteStructEnd(buf[offset:]) + return offset +} + +func (p *FrontendServiceGetGlobalSnapshotResult) BLength() int { + l := 0 + l += bthrift.Binary.StructBeginLength("getGlobalSnapshot_result") + if p != nil { + l += p.field0Length() + } + l += bthrift.Binary.FieldStopLength() + l += bthrift.Binary.StructEndLength() + return l +} + +func (p *FrontendServiceGetGlobalSnapshotResult) fastWriteField0(buf []byte, binaryWriter bthrift.BinaryWriter) int { + offset := 0 + if p.IsSetSuccess() { + offset += bthrift.Binary.WriteFieldBegin(buf[offset:], "success", thrift.STRUCT, 0) + offset += p.Success.FastWriteNocopy(buf[offset:], binaryWriter) + offset += bthrift.Binary.WriteFieldEnd(buf[offset:]) + } + return offset +} + +func (p *FrontendServiceGetGlobalSnapshotResult) field0Length() int { + l := 0 + if p.IsSetSuccess() { + l += bthrift.Binary.FieldBeginLength("success", thrift.STRUCT, 0) + l += p.Success.BLength() + l += bthrift.Binary.FieldEndLength() + } + return l +} + func (p *FrontendServiceRestoreSnapshotArgs) FastRead(buf []byte) (int, error) { var err error var offset int @@ -70154,6 +71187,14 @@ func (p *FrontendServiceGetSnapshotResult) GetResult() interface{} { return p.Success } +func (p *FrontendServiceGetGlobalSnapshotArgs) GetFirstArgument() interface{} { + return p.Request +} + +func (p *FrontendServiceGetGlobalSnapshotResult) GetResult() interface{} { + return p.Success +} + func (p *FrontendServiceRestoreSnapshotArgs) GetFirstArgument() interface{} { return p.Request } diff --git a/pkg/rpc/thrift/FrontendService.thrift b/pkg/rpc/thrift/FrontendService.thrift index 3b74dca0..40e864db 100644 --- a/pkg/rpc/thrift/FrontendService.thrift +++ b/pkg/rpc/thrift/FrontendService.thrift @@ -1197,6 +1197,24 @@ struct TGetSnapshotResult { 7: optional i64 commit_seq; } +struct TGetGlobalSnapshotRequest { + 1: optional string cluster + 2: optional string user + 3: optional string passwd + 4: optional string token + 5: optional string label_name + 6: optional string snapshot_name + 7: optional TSnapshotType snapshot_type +} + +struct TGetGlobalSnapshotResult { + 1: optional Status.TStatus status + 2: optional binary global_info + 3: optional Types.TNetworkAddress master_address + 4: optional i64 expiredAt; // in millis + 5: optional i64 commit_seq; +} + struct TTableRef { 1: optional string table 3: optional string alias_name @@ -1590,6 +1608,7 @@ service FrontendService { TRollbackTxnResult rollbackTxn(1: TRollbackTxnRequest request) TGetBinlogResult getBinlog(1: TGetBinlogRequest request) TGetSnapshotResult getSnapshot(1: TGetSnapshotRequest request) + TGetGlobalSnapshotResult getGlobalSnapshot(1: TGetGlobalSnapshotRequest request) TRestoreSnapshotResult restoreSnapshot(1: TRestoreSnapshotRequest request) TLockBinlogResult lockBinlog(1: TLockBinlogRequest request) diff --git a/pkg/service/http_service.go b/pkg/service/http_service.go index 58c65314..3d5c6352 100644 --- a/pkg/service/http_service.go +++ b/pkg/service/http_service.go @@ -40,6 +40,12 @@ import ( log "github.com/sirupsen/logrus" ) +// Global sync related constants +const ( + MAX_CHECK_RETRY_TIMES = 20 + BACKUP_CHECK_DURATION = 5 * time.Second +) + // TODO(Drogon): impl a generic http request handle parse json func writeJson(w http.ResponseWriter, data interface{}) { @@ -103,6 +109,8 @@ type CreateCcrRequest struct { // For table sync, allow to create ccr job even if the target table already exists. AllowTableExists bool `json:"allow_table_exists"` ReuseBinlogLabel bool `json:"reuse_binlog_label"` + // Whether it's cluster-level sync, if true, will get all databases from source cluster and create sync task for each database + ClusterSync bool `json:"cluster_sync"` } // Stringer @@ -156,6 +164,247 @@ func createCcr(request *CreateCcrRequest, db storage.DB, jobManager *ccr.JobMana return nil } +// createClusterCcr creates cluster-level CCR sync tasks +// Gets all databases from source cluster and creates a sync task for each database +func createClusterCcr(request *CreateCcrRequest, db storage.DB, jobManager *ccr.JobManager) error { + log.Infof("create cluster ccr %s", request) + + // Get all database list from source cluster + databases, err := getDatabaseList(&request.Src) + if err != nil { + return xerror.Wrapf(err, xerror.Normal, "Failed to get database list from source cluster") + } + + if len(databases) == 0 { + return xerror.Errorf(xerror.Normal, "No databases found in source cluster") + } + + log.Infof("Found %d databases, starting to create cluster-level sync tasks: %v", len(databases), databases) + + var errors []string + successCount := 0 + + for _, dbName := range databases { + // Create a new request for each database + dbRequest := &CreateCcrRequest{ + Name: fmt.Sprintf("%s_%s", request.Name, dbName), // Task name with database name + Src: request.Src, + Dest: request.Dest, + SkipError: request.SkipError, + AllowTableExists: request.AllowTableExists, + ReuseBinlogLabel: request.ReuseBinlogLabel, + ClusterSync: false, // Set to false to avoid recursive calls + } + + dbRequest.Src.Database = dbName + dbRequest.Dest.Database = dbName + + if err := createCcr(dbRequest, db, jobManager); err != nil { + errMsg := fmt.Sprintf("Failed to create sync task for database %s: %v", dbName, err) + log.Warnf(errMsg) + errors = append(errors, errMsg) + } else { + successCount++ + log.Infof("Successfully created sync task for database %s", dbName) + } + } + + if len(errors) > 0 { + if successCount == 0 { + return xerror.Errorf(xerror.Normal, "All database sync tasks creation failed: %s", strings.Join(errors, "; ")) + } else { + log.Warnf("Partial cluster sync tasks creation failed, success: %d, failed: %d, errors: %s", + successCount, len(errors), strings.Join(errors, "; ")) + } + } + + log.Infof("Cluster-level sync tasks creation completed, success: %d, failed: %d", successCount, len(errors)) + + // Start daemon task to periodically detect new databases in source cluster, pass existing database list + go startDatabaseMonitor(request, db, jobManager, databases) + + return nil +} + +// startDatabaseMonitor starts a daemon task to periodically detect new and deleted databases in source cluster, and create or delete corresponding sync tasks +func startDatabaseMonitor(request *CreateCcrRequest, db storage.DB, jobManager *ccr.JobManager, initialDatabases []string) { + log.Infof("Starting database monitor daemon, task name prefix: %s", request.Name) + + existingDatabases := initializeDatabaseTracking(initialDatabases) + log.Infof("Initialized database monitoring, currently have %d databases", len(existingDatabases)) + + checkInterval := 2 * time.Minute + ticker := time.NewTicker(checkInterval) + defer ticker.Stop() + + for range ticker.C { + monitorDatabaseChanges(request, db, jobManager, existingDatabases) + } +} + +func initializeDatabaseTracking(initialDatabases []string) map[string]bool { + existingDatabases := make(map[string]bool) + for _, dbName := range initialDatabases { + existingDatabases[dbName] = true + } + return existingDatabases +} + +// monitorDatabaseChanges detects database changes and handles them +func monitorDatabaseChanges(request *CreateCcrRequest, db storage.DB, jobManager *ccr.JobManager, existingDatabases map[string]bool) { + currentDatabases, err := request.Src.GetAllDatabases() + if err != nil { + log.Errorf("Failed to get database list: %v", err) + return + } + + currentDatabaseMap := make(map[string]bool) + for _, dbName := range currentDatabases { + if dbName == "" { + continue + } + currentDatabaseMap[dbName] = true + } + + newDatabases := identifyNewDatabases(currentDatabases, existingDatabases) + deletedDatabases := identifyDeletedDatabases(existingDatabases, currentDatabaseMap) + + handleNewDatabases(newDatabases, request, db, jobManager) + handleDeletedDatabases(deletedDatabases, request, jobManager) + logMonitoringStatus(newDatabases, deletedDatabases, existingDatabases) +} + +func identifyNewDatabases(currentDatabases []string, existingDatabases map[string]bool) []string { + var newDatabases []string + for _, dbName := range currentDatabases { + if !existingDatabases[dbName] { + newDatabases = append(newDatabases, dbName) + existingDatabases[dbName] = true + } + } + return newDatabases +} + +func identifyDeletedDatabases(existingDatabases map[string]bool, currentDatabaseMap map[string]bool) []string { + var deletedDatabases []string + for dbName := range existingDatabases { + if !currentDatabaseMap[dbName] { + deletedDatabases = append(deletedDatabases, dbName) + delete(existingDatabases, dbName) + } + } + return deletedDatabases +} + +func handleNewDatabases(newDatabases []string, request *CreateCcrRequest, db storage.DB, jobManager *ccr.JobManager) { + if len(newDatabases) == 0 { + return + } + + log.Infof("Found %d new databases: %v", len(newDatabases), newDatabases) + + for _, dbName := range newDatabases { + if dbName == "" { + log.Warnf("Skipping empty database name") + continue + } + + jobName := fmt.Sprintf("%s_%s", request.Name, dbName) + jobExists, err := db.IsJobExist(jobName) + if err != nil { + log.Warnf("Error checking if job %s exists: %v", jobName, err) + continue + } + + if jobExists { + log.Warnf("Job %s already exists, skipping sync task creation for database %s", jobName, dbName) + continue + } + + dbRequest := &CreateCcrRequest{ + Name: jobName, + Src: request.Src, + Dest: request.Dest, + SkipError: request.SkipError, + AllowTableExists: request.AllowTableExists, + ReuseBinlogLabel: request.ReuseBinlogLabel, + ClusterSync: false, // Set to false to avoid recursive calls + } + + dbRequest.Src.Database = dbName + dbRequest.Dest.Database = dbName + + maxRetries := 3 + for i := 0; i < maxRetries; i++ { + if err := createCcr(dbRequest, db, jobManager); err != nil { + if i == maxRetries-1 { + log.Warnf("Failed to create sync task for new database %s (attempt %d/%d): %v", + dbName, i+1, maxRetries, err) + } else { + log.Warnf("Failed to create sync task for new database %s (attempt %d/%d): %v, will retry", + dbName, i+1, maxRetries, err) + time.Sleep(time.Second * time.Duration(i+1)) // Exponential backoff + } + } else { + log.Infof("Successfully created sync task for new database %s", dbName) + break + } + } + } +} + +func handleDeletedDatabases(deletedDatabases []string, request *CreateCcrRequest, jobManager *ccr.JobManager) { + if len(deletedDatabases) == 0 { + return + } + + log.Infof("Found %d deleted databases: %v", len(deletedDatabases), deletedDatabases) + + for _, dbName := range deletedDatabases { + if dbName == "" { + log.Warnf("Skipping empty database name") + continue + } + + jobName := fmt.Sprintf("%s_%s", request.Name, dbName) + + maxRetries := 3 + for i := 0; i < maxRetries; i++ { + if err := jobManager.RemoveJob(jobName); err != nil { + if i == maxRetries-1 { + log.Warnf("Failed to remove sync task for deleted database %s (attempt %d/%d): %v", dbName, i+1, maxRetries, err) + } else { + log.Warnf("Failed to remove sync task for deleted database %s (attempt %d/%d): %v, will retry", dbName, i+1, maxRetries, err) + time.Sleep(time.Second * time.Duration(i+1)) // Exponential backoff + } + } else { + log.Infof("Successfully removed sync task for deleted database %s", dbName) + break + } + } + } +} + +// logMonitoringStatus logs monitoring status +func logMonitoringStatus(newDatabases []string, deletedDatabases []string, existingDatabases map[string]bool) { + if len(newDatabases) == 0 && len(deletedDatabases) == 0 { + log.Infof("No database changes detected, currently have %d databases", len(existingDatabases)) + } +} + +func getDatabaseList(spec *base.Spec) ([]string, error) { + log.Infof("Getting database list for cluster %s", spec.Host) + + // Use Specer interface's GetAllDatabases method + databases, err := spec.GetAllDatabases() + if err != nil { + return nil, xerror.Wrapf(err, xerror.Normal, "Failed to get database list") + } + + log.Infof("Got %d user databases: %v", len(databases), databases) + return databases, nil +} + // return exit(bool) func (s *HttpService) redirect(jobName string, w http.ResponseWriter, r *http.Request) bool { if jobExist, err := s.db.IsJobExist(jobName); err != nil { @@ -205,12 +454,20 @@ func (s *HttpService) createHandler(w http.ResponseWriter, r *http.Request) { return } - // Call the createCcr function to create the CCR - if err = createCcr(&request, s.db, s.jobManager); err != nil { - log.Warnf("create ccr failed: %+v", err) - createResult = newErrorResult(err.Error()) + if request.ClusterSync { + if err = createClusterCcr(&request, s.db, s.jobManager); err != nil { + log.Warnf("create cluster ccr failed: %+v", err) + createResult = newErrorResult(err.Error()) + } else { + createResult = newSuccessResult() + } } else { - createResult = newSuccessResult() + if err = createCcr(&request, s.db, s.jobManager); err != nil { + log.Warnf("create ccr failed: %+v", err) + createResult = newErrorResult(err.Error()) + } else { + createResult = newSuccessResult() + } } } @@ -1084,9 +1341,195 @@ func (s *HttpService) failpointHandler(w http.ResponseWriter, r *http.Request) { result = newSuccessResult() } +// SyncGlobalRequest defines the structure of global sync request +type SyncGlobalRequest struct { + // Required fields + Name string `json:"name"` + Src base.Spec `json:"src"` + Dest base.Spec `json:"dest"` + // Optional fields + All bool `json:"all"` + BackupPrivilege bool `json:"backup_privilege"` + BackupCatalog bool `json:"backup_catalog"` + BackupWorkloadGroup bool `json:"backup_workload_group"` +} + +// Validate SyncGlobalRequest to ensure only one optional field is true +func (r *SyncGlobalRequest) validate() error { + // Check required fields + if r.Name == "" { + return xerror.Errorf(xerror.Normal, "name is required") + } + + // Check optional fields logic: + // If 'all' is set, other options don't need to be checked + // If 'all' is not set, other options can be set freely (multiple or none) + if r.All { + // If 'all' is set, validation passes regardless of other options + return nil + } + + // If 'all' is not set, check if at least one other option is set + if !r.BackupPrivilege && !r.BackupCatalog && !r.BackupWorkloadGroup { + return xerror.Errorf(xerror.Normal, "Must specify at least one sync option: all, backup_privilege, backup_catalog, backup_workload_group") + } + + return nil +} + +// String method implements Stringer interface +func (r *SyncGlobalRequest) String() string { + return fmt.Sprintf("name: %s, src: %v, dest: %v, all: %v, backup_privilege: %v, backup_catalog: %v, backup_workload_group: %v", + r.Name, r.Src, r.Dest, r.All, r.BackupPrivilege, r.BackupCatalog, r.BackupWorkloadGroup) +} + +// syncGlobal executes global sync operation +// createGlobalSnapshot creates a global snapshot on the source cluster +func createGlobalSnapshot(request *SyncGlobalRequest) error { + log.Infof("Creating global snapshot %s", request.Name) + + err := request.Src.CreateGlobalSnapshot( + request.Name, + request.BackupPrivilege, + request.BackupCatalog, + request.BackupWorkloadGroup, + ) + if err != nil { + return xerror.Wrapf(err, xerror.Normal, "Failed to create global snapshot") + } + + return nil +} + +// waitForGlobalBackupCompletion waits for the global backup to complete +func waitForGlobalBackupCompletion(request *SyncGlobalRequest) error { + log.Infof("Waiting for global backup %s to complete", request.Name) + + for i := 0; i < MAX_CHECK_RETRY_TIMES; i++ { + finished, err := request.Src.CheckGlobalBackupFinished(request.Name) + if err != nil { + return xerror.Wrapf(err, xerror.Normal, "Failed to check global backup status") + } + + if finished { + log.Infof("Global backup %s completed", request.Name) + return nil + } + + time.Sleep(BACKUP_CHECK_DURATION) + } + + return xerror.Errorf(xerror.Normal, "Timeout waiting for global backup completion, max retry times: %d", MAX_CHECK_RETRY_TIMES) +} + +// processGlobalSnapshotInfo retrieves and processes global snapshot information +func processGlobalSnapshotInfo(request *SyncGlobalRequest) error { + log.Infof("Getting global snapshot %s details", request.Name) + + feRpc, err := rpc.NewFeRpc(&request.Src) + if err != nil { + log.Warnf("Failed to create FE RPC client: %+v", err) + // Don't return error because backup has completed successfully + return nil + } + + snapshot, err := feRpc.GetGlobalSnapshot(&request.Src, request.Name) + if err != nil { + log.Warnf("Failed to get global snapshot details: %+v", err) + // Don't return error because backup has completed successfully + return nil + } + + log.Infof("Global snapshot details: %+v", snapshot) + + if snapshot.GlobalInfo == nil { + log.Warnf("Global snapshot information is empty") + return nil + } + + return executeGlobalSnapshotSQL(request, snapshot.GlobalInfo) +} + +// executeGlobalSnapshotSQL converts and executes global snapshot SQL statements +func executeGlobalSnapshotSQL(request *SyncGlobalRequest, globalInfo []byte) error { + // GlobalInfo contains SQL statements, not JSON format + sqlStatements, err := ccr.NewBackupSqlsFromBytes(globalInfo) + if err != nil { + log.Warnf("Failed to convert global snapshot SQL statements: %+v", err) + return nil // Don't return error as this is not critical + } + + log.Infof("Global snapshot SQL statements: %s", sqlStatements) + + // Call RestoreGlobalInfo function to execute corresponding SQL on dest cluster + err = request.Dest.RestoreGlobalInfo(sqlStatements) + if err != nil { + log.Errorf("Failed to execute global snapshot SQL: %+v", err) + return err + } + + log.Infof("Global snapshot SQL executed successfully") + return nil +} + +// syncGlobal executes global sync operation +func syncGlobal(request *SyncGlobalRequest) error { + log.Infof("Executing global sync %s", request) + + // Step 1: Create global snapshot + if err := createGlobalSnapshot(request); err != nil { + return err + } + + // Step 2: Wait for backup completion + if err := waitForGlobalBackupCompletion(request); err != nil { + return err + } + + // Step 3: Process snapshot information and execute SQL + if err := processGlobalSnapshotInfo(request); err != nil { + return err + } + + return nil +} + +// syncGlobalHandler handles global sync requests +func (s *HttpService) syncGlobalHandler(w http.ResponseWriter, r *http.Request) { + log.Infof("Global sync request") + + var syncResult *defaultResult + defer func() { writeJson(w, syncResult) }() + + // Parse JSON request body + var request SyncGlobalRequest + err := json.NewDecoder(r.Body).Decode(&request) + if err != nil { + log.Warnf("Failed to parse global sync request: %+v", err) + syncResult = newErrorResult(err.Error()) + return + } + + // Validate request + if err = request.validate(); err != nil { + log.Warnf("Global sync request validation failed: %+v", err) + syncResult = newErrorResult(err.Error()) + return + } + + // Execute global sync + if err = syncGlobal(&request); err != nil { + log.Warnf("Global sync failed: %+v", err) + syncResult = newErrorResult(err.Error()) + } else { + syncResult = newSuccessResult() + } +} + func (s *HttpService) RegisterHandlers() { s.mux.HandleFunc("/version", s.versionHandler) s.mux.HandleFunc("/create_ccr", s.createHandler) + s.mux.HandleFunc("/sync_global", s.syncGlobalHandler) s.mux.HandleFunc("/pause", s.pauseHandler) s.mux.HandleFunc("/resume", s.resumeHandler) s.mux.HandleFunc("/delete", s.deleteHandler)