// import "github.com/baidubce/bce-sdk-go/services/rds"

args := &rds.CreateRdsArgs{
	// 指定rds的数据库引擎，取值mysql，sqlserver，postgresql，必选
    Engine:            "mysql",
    // 指定rds的数据库版本，必选
    EngineVersion:  "5.6",
    // 计费相关参数，PaymentTiming取值为 预付费：Prepaid，后付费：Postpaid；Reservation：支付方式为后支付时不需要设置，预支付时必须设置；必选
    Billing: rds.Billing{
        PaymentTiming: "Postpaid",
        //Reservation: rds.Reservation{ReservationLength: 1, ReservationTimeUnit: "Month"},
    },
    // 预付费时可指定自动续费参数 AutoRenewTime 和 AutoRenewTimeUnit
    // 自动续费时长（续费单位为year 不大于3，续费单位为month 不大于9）
    // AutoRenewTime: 1,
    // 自动续费单位（"year";"month"）
    // AutoRenewTimeUnit: "year",
    // CPU核数，必选
    CpuCount: 1,
    //套餐内存大小，单位GB，必选
    MemoryCapacity: 1,
    //套餐磁盘大小，单位GB，每5G递增，必选
    VolumeCapacity: 5,
    //磁盘类型, normal_io:本地盘ssd磁盘, cloud_high:高性能云磁盘, cloud_nor:通用型SSD, cloud_enha:增强型SSD, 必选
    DiskIoType: "normal_io",
    //批量创建云数据库 RDS 实例个数, 最大不超过10，默认1，可选
    PurchaseCount: 1,
    //rds实例名称，允许小写字母、数字，长度限制为1~32，默认命名规则:{engine} + {engineVersion}，可选
    InstanceName: "instanceName",
    //所属系列，Basic：单机基础版，Standard：双机高可用版。仅SQLServer 2012sp3 支持单机基础版。默认Standard，可选
    Category: "Standard",
    //指定zone信息，默认为空，由系统自动选择，可选
    //zoneName命名规范是小写的“国家-region-可用区序列"，例如北京可用区A为"cn-bj-a"。
    ZoneNames: []string{"cn-bj-d"},
    //vpc，如果不提供则属于默认vpc，可选
    VpcId: "vpc-IyrqYIQ7",
    //是否进行直接支付，默认false，设置为直接支付的变配订单会直接扣款，不需要再走支付逻辑，可选
    IsDirectPay: false,
    //vpc内，每个可用区的subnetId；如果不是默认vpc则必须指定 subnetId，可选
    Subnets: []rds.SubnetMap{
        {
            ZoneName: "cn-bj-a",
            SubnetId: "sbn-IyWRnII7",
        },   
    },
    // 实例绑定的标签信息，可选
    Tags: []model.TagModel{
        {
            TagKey:   "tagK",
            TagValue: "tagV",
        },
    },
}
result, err := client.CreateRds(args)
if err != nil {
    fmt.Printf("create rds error: %+v\n", err)
    return
}

for _, e := range result.InstanceIds {
	fmt.Println("create rds success, instanceId: ", e)
}

// import "github.com/baidubce/bce-sdk-go/services/rds"

args := &rds.CreateReadReplicaArgs{
    //主实例ID，必选
    SourceInstanceId: "sourceInstanceId"
    // 计费相关参数，PaymentTiming取值为 预付费：Prepaid，后付费：Postpaid；Reservation：支付方式为后支付时不需要设置，预支付时必须设置；必选
    Billing: rds.Billing{
        PaymentTiming: "Postpaid",
    },
    // CPU核数，必选
    CpuCount: 1,
    //套餐内存大小，单位GB，必选
    MemoryCapacity: 1,
    //套餐磁盘大小，单位GB，每5G递增，必选
    VolumeCapacity: 5,
    //批量创建云数据库 RDS 只读实例个数, 可选
    PurchaseCount: 1,
    //实例名称，允许小写字母、数字，长度限制为1~32，默认命名规则:{engine} + {engineVersion}，可选
    InstanceName: "instanceName",
    //指定zone信息，默认为空，由系统自动选择，可选
    //zoneName命名规范是小写的“国家-region-可用区序列"，例如北京可用区A为"cn-bj-a"。
    ZoneNames: []string{"cn-bj-d"},
    //与主实例 vpcId 相同，可选
    VpcId: "vpc-IyrqYIQ7",
    //是否进行直接支付，默认false，设置为直接支付的变配订单会直接扣款，不需要再走支付逻辑，可选
    IsDirectPay: false,
    //vpc内，每个可用区的subnetId；如果不是默认vpc则必须指定 subnetId，可选
    Subnets: []rds.SubnetMap{
        {
            ZoneName: "cn-bj-a",
            SubnetId: "sbn-IyWRnII7",
        },   
    },
    // 实例绑定的标签信息，可选
    Tags: []model.TagModel{
        {
            TagKey:   "tagK",
            TagValue: "tagV",
        },
    },
}
result, err := client.CreateReadReplica(args)
if err != nil {
    fmt.Printf("create rds readReplica error: %+v\n", err)
    return
}

for _, e := range result.InstanceIds {
	fmt.Println("create rds readReplica success, instanceId: ", e)
}

// import "github.com/baidubce/bce-sdk-go/services/rds"

args := &rds.CreateRdsProxyArgs{
    //主实例ID，必选
    SourceInstanceId: "sourceInstanceId"
    // 计费相关参数，代理实例只支持后付费Postpaid，必选
    Billing: rds.Billing{
        PaymentTiming: "Postpaid",
    },
    // 代理实例节点数。取值范围2，4，6，8，16，必选
    NodeAmount: 2,
    //实例名称，允许小写字母、数字，长度限制为1~32，默认命名规则:{engine} + {engineVersion}，可选
    InstanceName: "instanceName",
    //指定zone信息，默认为空，由系统自动选择，可选
    //zoneName命名规范是小写的“国家-region-可用区序列"，例如北京可用区A为"cn-bj-a"，建议与主实例的可用区保持一致
    ZoneNames: []string{"cn-bj-d"},
    //与主实例 vpcId 相同，可选
    VpcId: "vpc-IyrqYIQ7",
    //是否进行直接支付，默认false，设置为直接支付的变配订单会直接扣款，不需要再走支付逻辑，可选
    IsDirectPay: false,
    //vpc内，每个可用区的subnetId；如果不是默认vpc则必须指定 subnetId，可选
    Subnets: []rds.SubnetMap{
        {
            ZoneName: "cn-bj-a",
            SubnetId: "sbn-IyWRnII7",
        },   
    },
    // 实例绑定的标签信息，可选
    Tags: []model.TagModel{
        {
            TagKey:   "tagK",
            TagValue: "tagV",
        },
    },
}
result, err := client.CreateRdsProxy(args)
if err != nil {
    fmt.Printf("create rds proxy error: %+v\n", err)
    return
}

for _, e := range result.InstanceIds {
	fmt.Println("create rds proxy success, instanceId: ", e)
}

// import "github.com/baidubce/bce-sdk-go/services/rds"

args := &rds.ListRdsArgs{
    // 批量获取列表的查询的起始位置，是一个由系统生成的字符串，可选
    Marker: "marker",
    // 指定每页包含的最大数量(主实例)，最大数量不超过1000，缺省值为1000，可选
    MaxKeys: 1,
}
result, err := client.ListRds(args)
if err != nil {
    fmt.Printf("list rds error: %+v\n", err)
    return
}

// 返回标记查询的起始位置
fmt.Println("rds list marker: ", result.Marker)
// true表示后面还有数据，false表示已经是最后一页
fmt.Println("rds list isTruncated: ", result.IsTruncated)
// 获取下一页所需要传递的marker值。当isTruncated为false时，该域不出现
fmt.Println("rds list nextMarker: ", result.NextMarker)
// 每页包含的最大数量
fmt.Println("rds list maxKeys: ", result.MaxKeys)
// 获取rds的列表信息
for _, e := range result.Instances {
    fmt.Println("rds instanceId: ", e.InstanceId)
    fmt.Println("rds instanceName: ", e.InstanceName)
    fmt.Println("rds engine: ", e.Engine)
    fmt.Println("rds engineVersion: ", e.EngineVersion)
    fmt.Println("rds instanceStatus: ", e.InstanceStatus)
    fmt.Println("rds cpuCount: ", e.CpuCount)
    fmt.Println("rds memoryCapacity: ", e.MemoryCapacity)
    fmt.Println("rds volumeCapacity: ", e.VolumeCapacity)
    fmt.Println("rds usedStorage: ", e.UsedStorage)
    fmt.Println("rds paymentTiming: ", e.PaymentTiming)
    fmt.Println("rds instanceType: ", e.InstanceType)
    fmt.Println("rds instanceCreateTime: ", e.InstanceCreateTime)
    fmt.Println("rds instanceExpireTime: ", e.InstanceExpireTime)
    fmt.Println("rds publicAccessStatus: ", e.PublicAccessStatus)
    fmt.Println("rds task: ", e.Task)
    fmt.Println("rds vpcId: ", e.VpcId)
}

// import "github.com/baidubce/bce-sdk-go/services/rds"

result, err := client.GetDetail(instanceId)
if err != nil {
    fmt.Printf("get rds detail error: %+v\n", err)
    return
}

fmt.Println("rds instanceId: ", result.InstanceId)
fmt.Println("rds instanceName: ", result.InstanceName)
fmt.Println("rds engine: ", result.Engine)
fmt.Println("rds engineVersion: ", result.EngineVersion)
fmt.Println("rds instanceStatus: ", result.InstanceStatus)
fmt.Println("rds cpuCount: ", result.CpuCount)
fmt.Println("rds memoryCapacity: ", result.MemoryCapacity)
fmt.Println("rds volumeCapacity: ", result.VolumeCapacity)
fmt.Println("rds usedStorage: ", result.UsedStorage)
fmt.Println("rds paymentTiming: ", result.PaymentTiming)
fmt.Println("rds instanceType: ", result.InstanceType)
fmt.Println("rds instanceCreateTime: ", result.InstanceCreateTime)
fmt.Println("rds instanceExpireTime: ", result.InstanceExpireTime)
fmt.Println("rds publicAccessStatus: ", result.PublicAccessStatus)
fmt.Println("rds vpcId: ", result.VpcId)

// import "github.com/baidubce/bce-sdk-go/services/rds"

//多个实例间用英文半角逗号","隔开，最多可输入10个
if err := client.DeleteRds(instanceIds); err != nil {
    fmt.Printf("delete rds error: %+v\n", err)
    return
}
fmt.Printf("delete rds success\n")

// import "github.com/baidubce/bce-sdk-go/services/rds"

args := &rds.ResizeRdsArgs{
	// cpu核数
    CpuCount: 2,
    // 内存大小，单位GB
    MemoryCapacity: 8,
    // 磁盘大小，单位GB，每5G递增
    VolumeCapacity: 20,
    // 代理实例节点数，代理实例变配时此项必填
    NodeAmount: 2,
    // 是否进行直接支付，默认false，设置为直接支付的变配订单会直接扣款，不需要再走支付逻辑，可选
    IsDirectPay: false,
}
err = client.ResizeRds(instanceId, args)
if err != nil {
    fmt.Printf("resize rds error: %+v\n", err)
    return
}

fmt.Println("resize rds success.")

// import "github.com/baidubce/bce-sdk-go/services/rds"

err := client.RebootInstance(instanceId)
if err != nil {
    fmt.Printf("reboot rds error: %+v\n", err)
    return
}

// import "github.com/baidubce/bce-sdk-go/services/rds"

args := &rds.UpdateInstanceNameArgs{
    InstanceName: "instanceName",
}
err = client.UpdateInstanceName(instanceId, args)
if err != nil {
    fmt.Printf("update instance name error: %+v\n", err)
    return
}
fmt.Printf("update instance name success\n")

// import "github.com/baidubce/bce-sdk-go/services/rds"

args := &rds.AutoRenewArgs{
    // 自动续费时长（续费单位为year 不大于3，续费单位为month 不大于9）必选
	AutoRenewTime: 1,
    // 自动续费单位（"year";"month"）必选
	AutoRenewTimeUnit: "year",
    // 实例id集合 必选
    InstanceIds: []string{
        "rds-y9dJu77d", 
        "rds-aQFOoncr",
    },
}
err := client.AutoRenew(args)
if err != nil {
    fmt.Printf("create auto renew error: %+v\n", err)
    return
}

// import "github.com/baidubce/bce-sdk-go/services/rds"

args := &rds.ModifySyncModeArgs{
    //"Async"异步复制，"Semi_sync"半同步复制。
    SyncMode: "Async",
}
err = client.ModifySyncMode(instanceId, args)
if err != nil {
    fmt.Printf("modify syncMode error: %+v\n", err)
    return
}
fmt.Printf("modify syncMode success\n")

// import "github.com/baidubce/bce-sdk-go/services/rds"

args := &rds.ModifyEndpointArgs{
    Address: "newAddress",
}
err = client.ModifyEndpoint(instanceId, args)
if err != nil {
    fmt.Printf("modify endpoint error: %+v\n", err)
    return
}
fmt.Printf("modify endpoint success\n")

// import "github.com/baidubce/bce-sdk-go/services/rds"

args := &rds.ModifyPublicAccessArgs{
    // true or false
    PublicAccess: true,
}
err = client.ModifyPublicAccess(instanceId, args)
if err != nil {
    fmt.Printf("modify public access error: %+v\n", err)
    return
}
fmt.Printf("modify public access success\n")

// import "github.com/baidubce/bce-sdk-go/services/rds"

args := &rds.MaintainTimeArgs{
    MaintainStartTime: "14:00:00",
    MaintainDuration:  2,
}
err = client.UpdateMaintainTime(instanceId, args)
if err != nil {
    fmt.Printf("update maintain time error: %+v\n", err)
    return
}
fmt.Printf("update maintain time success\n")

// import "github.com/baidubce/bce-sdk-go/services/rds"

args := &rds.DiskAutoResizeArgs{
    FreeSpaceThreshold: 10,
    DiskMaxLimit:       2000,
}
err = client.ConfigDiskAutoResize(instanceId,"open", args)
if err != nil {
    fmt.Printf("config disk auto resize error: %+v\n", err)
    return
}
fmt.Printf("config disk auto resize success\n")

// import "github.com/baidubce/bce-sdk-go/services/rds"

result, err = client.GetAutoResizeConfig(instanceId)
if err != nil {
    fmt.Printf("get config error: %+v\n", err)
    return
}
fmt.Printf("get config success\n")

// import "github.com/baidubce/bce-sdk-go/services/rds"

result, err = client.EnableAutoExpansion(instanceId)
if err != nil {
    fmt.Printf("get enable auto expansion error: %+v\n", err)
    return
}
fmt.Printf("get enable auto expansion success\n")

// import "github.com/baidubce/bce-sdk-go/services/rds"
args := &rds.AzoneMigration{
    MasterAzone: "cn-bj-d",
    BackupAzone: "cn-bj-e",
    ZoneNames:   []string{"cn-bj-d", "cn-bj-e"},
    Subnets: []SubnetMap{
        {
            ZoneName: "cn-bj-d",
            SubnetId: "sbn-nedt51qre6r2",
        },
        {
            ZoneName: "cn-bj-e",
            SubnetId: "sbn-hc20wss3idai",
        },
    },
    EffectiveTime: "timewindow",
}
result, err = client.AzoneMigration(instanceId, args)
if err != nil {
    fmt.Printf("azone migration error: %+v\n", err)
    return
}
fmt.Printf("azone migration success\n")