volcengine.rds_mysql.Account

import * as pulumi from "@pulumi/pulumi";
import * as volcengine from "@pulumi/volcengine";
import * as volcengine from "@volcengine/pulumi";

const fooZones = volcengine.ecs.getZones({});
const fooVpc = new volcengine.vpc.Vpc("fooVpc", {
    vpcName: "acc-test-vpc",
    cidrBlock: "172.16.0.0/16",
});
const fooSubnet = new volcengine.vpc.Subnet("fooSubnet", {
    subnetName: "acc-test-subnet",
    cidrBlock: "172.16.0.0/24",
    zoneId: fooZones.then(fooZones => fooZones.zones?.[0]?.id),
    vpcId: fooVpc.id,
});
const fooInstance = new volcengine.rds_mysql.Instance("fooInstance", {
    instanceName: "acc-test-rds-mysql",
    dbEngineVersion: "MySQL_5_7",
    nodeSpec: "rds.mysql.1c2g",
    primaryZoneId: fooZones.then(fooZones => fooZones.zones?.[0]?.id),
    secondaryZoneId: fooZones.then(fooZones => fooZones.zones?.[0]?.id),
    storageSpace: 80,
    subnetId: fooSubnet.id,
    lowerCaseTableNames: "1",
    chargeInfo: {
        chargeType: "PostPaid",
    },
    parameters: [
        {
            parameterName: "auto_increment_increment",
            parameterValue: "2",
        },
        {
            parameterName: "auto_increment_offset",
            parameterValue: "4",
        },
    ],
});
const foo1 = new volcengine.rds_mysql.Database("foo1", {
    dbName: "acc-test-db1",
    instanceId: fooInstance.id,
});
//instance_id = "mysql-b51d37110dd1"
const fooDatabase = new volcengine.rds_mysql.Database("fooDatabase", {
    dbName: "acc-test-db",
    instanceId: fooInstance.id,
});
const fooAccount = new volcengine.rds_mysql.Account("fooAccount", {
    accountName: "acc-test-account",
    accountPassword: "93f0cb0614Aab12",
    accountType: "Normal",
    instanceId: fooInstance.id,
    accountPrivileges: [
        {
            dbName: fooDatabase.dbName,
            accountPrivilege: "Custom",
            accountPrivilegeDetail: "SELECT,INSERT,UPDATE",
        },
        {
            dbName: foo1.dbName,
            accountPrivilege: "DDLOnly",
        },
    ],
    host: "192.10.10.%",
});
//     table_column_privileges {
//          db_name = volcengine_rds_mysql_database.foo.db_name
//          table_privileges {
//               table_name = "test"
//               account_privilege_detail = "SELECT,INSERT,UPDATE"
//          }
//          column_privileges {
//               table_name = "test"
//               column_name = "test"
//               account_privilege_detail = "SELECT,INSERT,UPDATE"
//          }
//     }

import pulumi
import pulumi_volcengine as volcengine

foo_zones = volcengine.ecs.get_zones()
foo_vpc = volcengine.vpc.Vpc("fooVpc",
    vpc_name="acc-test-vpc",
    cidr_block="172.16.0.0/16")
foo_subnet = volcengine.vpc.Subnet("fooSubnet",
    subnet_name="acc-test-subnet",
    cidr_block="172.16.0.0/24",
    zone_id=foo_zones.zones[0].id,
    vpc_id=foo_vpc.id)
foo_instance = volcengine.rds_mysql.Instance("fooInstance",
    instance_name="acc-test-rds-mysql",
    db_engine_version="MySQL_5_7",
    node_spec="rds.mysql.1c2g",
    primary_zone_id=foo_zones.zones[0].id,
    secondary_zone_id=foo_zones.zones[0].id,
    storage_space=80,
    subnet_id=foo_subnet.id,
    lower_case_table_names="1",
    charge_info=volcengine.rds_mysql.InstanceChargeInfoArgs(
        charge_type="PostPaid",
    ),
    parameters=[
        volcengine.rds_mysql.InstanceParameterArgs(
            parameter_name="auto_increment_increment",
            parameter_value="2",
        ),
        volcengine.rds_mysql.InstanceParameterArgs(
            parameter_name="auto_increment_offset",
            parameter_value="4",
        ),
    ])
foo1 = volcengine.rds_mysql.Database("foo1",
    db_name="acc-test-db1",
    instance_id=foo_instance.id)
#instance_id = "mysql-b51d37110dd1"
foo_database = volcengine.rds_mysql.Database("fooDatabase",
    db_name="acc-test-db",
    instance_id=foo_instance.id)
foo_account = volcengine.rds_mysql.Account("fooAccount",
    account_name="acc-test-account",
    account_password="93f0cb0614Aab12",
    account_type="Normal",
    instance_id=foo_instance.id,
    account_privileges=[
        volcengine.rds_mysql.AccountAccountPrivilegeArgs(
            db_name=foo_database.db_name,
            account_privilege="Custom",
            account_privilege_detail="SELECT,INSERT,UPDATE",
        ),
        volcengine.rds_mysql.AccountAccountPrivilegeArgs(
            db_name=foo1.db_name,
            account_privilege="DDLOnly",
        ),
    ],
    host="192.10.10.%")
#     table_column_privileges {
#          db_name = volcengine_rds_mysql_database.foo.db_name
#          table_privileges {
#               table_name = "test"
#               account_privilege_detail = "SELECT,INSERT,UPDATE"
#          }
#          column_privileges {
#               table_name = "test"
#               column_name = "test"
#               account_privilege_detail = "SELECT,INSERT,UPDATE"
#          }
#     }

package main

import (
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
	"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/ecs"
	"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/rds_mysql"
	"github.com/volcengine/pulumi-volcengine/sdk/go/volcengine/vpc"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		fooZones, err := ecs.GetZones(ctx, nil, nil)
		if err != nil {
			return err
		}
		fooVpc, err := vpc.NewVpc(ctx, "fooVpc", &vpc.VpcArgs{
			VpcName:   pulumi.String("acc-test-vpc"),
			CidrBlock: pulumi.String("172.16.0.0/16"),
		})
		if err != nil {
			return err
		}
		fooSubnet, err := vpc.NewSubnet(ctx, "fooSubnet", &vpc.SubnetArgs{
			SubnetName: pulumi.String("acc-test-subnet"),
			CidrBlock:  pulumi.String("172.16.0.0/24"),
			ZoneId:     pulumi.String(fooZones.Zones[0].Id),
			VpcId:      fooVpc.ID(),
		})
		if err != nil {
			return err
		}
		fooInstance, err := rds_mysql.NewInstance(ctx, "fooInstance", &rds_mysql.InstanceArgs{
			InstanceName:        pulumi.String("acc-test-rds-mysql"),
			DbEngineVersion:     pulumi.String("MySQL_5_7"),
			NodeSpec:            pulumi.String("rds.mysql.1c2g"),
			PrimaryZoneId:       pulumi.String(fooZones.Zones[0].Id),
			SecondaryZoneId:     pulumi.String(fooZones.Zones[0].Id),
			StorageSpace:        pulumi.Int(80),
			SubnetId:            fooSubnet.ID(),
			LowerCaseTableNames: pulumi.String("1"),
			ChargeInfo: &rds_mysql.InstanceChargeInfoArgs{
				ChargeType: pulumi.String("PostPaid"),
			},
			Parameters: rds_mysql.InstanceParameterArray{
				&rds_mysql.InstanceParameterArgs{
					ParameterName:  pulumi.String("auto_increment_increment"),
					ParameterValue: pulumi.String("2"),
				},
				&rds_mysql.InstanceParameterArgs{
					ParameterName:  pulumi.String("auto_increment_offset"),
					ParameterValue: pulumi.String("4"),
				},
			},
		})
		if err != nil {
			return err
		}
		foo1, err := rds_mysql.NewDatabase(ctx, "foo1", &rds_mysql.DatabaseArgs{
			DbName:     pulumi.String("acc-test-db1"),
			InstanceId: fooInstance.ID(),
		})
		if err != nil {
			return err
		}
		fooDatabase, err := rds_mysql.NewDatabase(ctx, "fooDatabase", &rds_mysql.DatabaseArgs{
			DbName:     pulumi.String("acc-test-db"),
			InstanceId: fooInstance.ID(),
		})
		if err != nil {
			return err
		}
		_, err = rds_mysql.NewAccount(ctx, "fooAccount", &rds_mysql.AccountArgs{
			AccountName:     pulumi.String("acc-test-account"),
			AccountPassword: pulumi.String("93f0cb0614Aab12"),
			AccountType:     pulumi.String("Normal"),
			InstanceId:      fooInstance.ID(),
			AccountPrivileges: rds_mysql.AccountAccountPrivilegeArray{
				&rds_mysql.AccountAccountPrivilegeArgs{
					DbName:                 fooDatabase.DbName,
					AccountPrivilege:       pulumi.String("Custom"),
					AccountPrivilegeDetail: pulumi.String("SELECT,INSERT,UPDATE"),
				},
				&rds_mysql.AccountAccountPrivilegeArgs{
					DbName:           foo1.DbName,
					AccountPrivilege: pulumi.String("DDLOnly"),
				},
			},
			Host: pulumi.String("192.10.10.%"),
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Volcengine = Pulumi.Volcengine;

return await Deployment.RunAsync(() => 
{
    var fooZones = Volcengine.Ecs.GetZones.Invoke();

    var fooVpc = new Volcengine.Vpc.Vpc("fooVpc", new()
    {
        VpcName = "acc-test-vpc",
        CidrBlock = "172.16.0.0/16",
    });

    var fooSubnet = new Volcengine.Vpc.Subnet("fooSubnet", new()
    {
        SubnetName = "acc-test-subnet",
        CidrBlock = "172.16.0.0/24",
        ZoneId = fooZones.Apply(getZonesResult => getZonesResult.Zones[0]?.Id),
        VpcId = fooVpc.Id,
    });

    var fooInstance = new Volcengine.Rds_mysql.Instance("fooInstance", new()
    {
        InstanceName = "acc-test-rds-mysql",
        DbEngineVersion = "MySQL_5_7",
        NodeSpec = "rds.mysql.1c2g",
        PrimaryZoneId = fooZones.Apply(getZonesResult => getZonesResult.Zones[0]?.Id),
        SecondaryZoneId = fooZones.Apply(getZonesResult => getZonesResult.Zones[0]?.Id),
        StorageSpace = 80,
        SubnetId = fooSubnet.Id,
        LowerCaseTableNames = "1",
        ChargeInfo = new Volcengine.Rds_mysql.Inputs.InstanceChargeInfoArgs
        {
            ChargeType = "PostPaid",
        },
        Parameters = new[]
        {
            new Volcengine.Rds_mysql.Inputs.InstanceParameterArgs
            {
                ParameterName = "auto_increment_increment",
                ParameterValue = "2",
            },
            new Volcengine.Rds_mysql.Inputs.InstanceParameterArgs
            {
                ParameterName = "auto_increment_offset",
                ParameterValue = "4",
            },
        },
    });

    var foo1 = new Volcengine.Rds_mysql.Database("foo1", new()
    {
        DbName = "acc-test-db1",
        InstanceId = fooInstance.Id,
    });

    //instance_id = "mysql-b51d37110dd1"
    var fooDatabase = new Volcengine.Rds_mysql.Database("fooDatabase", new()
    {
        DbName = "acc-test-db",
        InstanceId = fooInstance.Id,
    });

    var fooAccount = new Volcengine.Rds_mysql.Account("fooAccount", new()
    {
        AccountName = "acc-test-account",
        AccountPassword = "93f0cb0614Aab12",
        AccountType = "Normal",
        InstanceId = fooInstance.Id,
        AccountPrivileges = new[]
        {
            new Volcengine.Rds_mysql.Inputs.AccountAccountPrivilegeArgs
            {
                DbName = fooDatabase.DbName,
                AccountPrivilege = "Custom",
                AccountPrivilegeDetail = "SELECT,INSERT,UPDATE",
            },
            new Volcengine.Rds_mysql.Inputs.AccountAccountPrivilegeArgs
            {
                DbName = foo1.DbName,
                AccountPrivilege = "DDLOnly",
            },
        },
        Host = "192.10.10.%",
    });

    //     table_column_privileges {
    //          db_name = volcengine_rds_mysql_database.foo.db_name
    //          table_privileges {
    //               table_name = "test"
    //               account_privilege_detail = "SELECT,INSERT,UPDATE"
    //          }
    //          column_privileges {
    //               table_name = "test"
    //               column_name = "test"
    //               account_privilege_detail = "SELECT,INSERT,UPDATE"
    //          }
    //     }
});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.volcengine.ecs.EcsFunctions;
import com.pulumi.volcengine.ecs.inputs.GetZonesArgs;
import com.pulumi.volcengine.vpc.Vpc;
import com.pulumi.volcengine.vpc.VpcArgs;
import com.pulumi.volcengine.vpc.Subnet;
import com.pulumi.volcengine.vpc.SubnetArgs;
import com.pulumi.volcengine.rds_mysql.Instance;
import com.pulumi.volcengine.rds_mysql.InstanceArgs;
import com.pulumi.volcengine.rds_mysql.inputs.InstanceChargeInfoArgs;
import com.pulumi.volcengine.rds_mysql.inputs.InstanceParameterArgs;
import com.pulumi.volcengine.rds_mysql.Database;
import com.pulumi.volcengine.rds_mysql.DatabaseArgs;
import com.pulumi.volcengine.rds_mysql.Account;
import com.pulumi.volcengine.rds_mysql.AccountArgs;
import com.pulumi.volcengine.rds_mysql.inputs.AccountAccountPrivilegeArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }

    public static void stack(Context ctx) {
        final var fooZones = EcsFunctions.getZones();

        var fooVpc = new Vpc("fooVpc", VpcArgs.builder()        
            .vpcName("acc-test-vpc")
            .cidrBlock("172.16.0.0/16")
            .build());

        var fooSubnet = new Subnet("fooSubnet", SubnetArgs.builder()        
            .subnetName("acc-test-subnet")
            .cidrBlock("172.16.0.0/24")
            .zoneId(fooZones.applyValue(getZonesResult -> getZonesResult.zones()[0].id()))
            .vpcId(fooVpc.id())
            .build());

        var fooInstance = new Instance("fooInstance", InstanceArgs.builder()        
            .instanceName("acc-test-rds-mysql")
            .dbEngineVersion("MySQL_5_7")
            .nodeSpec("rds.mysql.1c2g")
            .primaryZoneId(fooZones.applyValue(getZonesResult -> getZonesResult.zones()[0].id()))
            .secondaryZoneId(fooZones.applyValue(getZonesResult -> getZonesResult.zones()[0].id()))
            .storageSpace(80)
            .subnetId(fooSubnet.id())
            .lowerCaseTableNames("1")
            .chargeInfo(InstanceChargeInfoArgs.builder()
                .chargeType("PostPaid")
                .build())
            .parameters(            
                InstanceParameterArgs.builder()
                    .parameterName("auto_increment_increment")
                    .parameterValue("2")
                    .build(),
                InstanceParameterArgs.builder()
                    .parameterName("auto_increment_offset")
                    .parameterValue("4")
                    .build())
            .build());

        var foo1 = new Database("foo1", DatabaseArgs.builder()        
            .dbName("acc-test-db1")
            .instanceId(fooInstance.id())
            .build());

        //instance_id = "mysql-b51d37110dd1"
        var fooDatabase = new Database("fooDatabase", DatabaseArgs.builder()        
            .dbName("acc-test-db")
            .instanceId(fooInstance.id())
            .build());

        var fooAccount = new Account("fooAccount", AccountArgs.builder()        
            .accountName("acc-test-account")
            .accountPassword("93f0cb0614Aab12")
            .accountType("Normal")
            .instanceId(fooInstance.id())
            .accountPrivileges(            
                AccountAccountPrivilegeArgs.builder()
                    .dbName(fooDatabase.dbName())
                    .accountPrivilege("Custom")
                    .accountPrivilegeDetail("SELECT,INSERT,UPDATE")
                    .build(),
                AccountAccountPrivilegeArgs.builder()
                    .dbName(foo1.dbName())
                    .accountPrivilege("DDLOnly")
                    .build())
            .host("192.10.10.%")
            .build());

        //     table_column_privileges {
        //          db_name = volcengine_rds_mysql_database.foo.db_name
        //          table_privileges {
        //               table_name = "test"
        //               account_privilege_detail = "SELECT,INSERT,UPDATE"
        //          }
        //          column_privileges {
        //               table_name = "test"
        //               column_name = "test"
        //               account_privilege_detail = "SELECT,INSERT,UPDATE"
        //          }
        //     }
    }
}

resources:
  fooVpc:
    type: volcengine:vpc:Vpc
    properties:
      vpcName: acc-test-vpc
      cidrBlock: 172.16.0.0/16
  fooSubnet:
    type: volcengine:vpc:Subnet
    properties:
      subnetName: acc-test-subnet
      cidrBlock: 172.16.0.0/24
      zoneId: ${fooZones.zones[0].id}
      vpcId: ${fooVpc.id}
  fooInstance:
    type: volcengine:rds_mysql:Instance
    properties:
      instanceName: acc-test-rds-mysql
      dbEngineVersion: MySQL_5_7
      nodeSpec: rds.mysql.1c2g
      primaryZoneId: ${fooZones.zones[0].id}
      secondaryZoneId: ${fooZones.zones[0].id}
      storageSpace: 80
      subnetId: ${fooSubnet.id}
      lowerCaseTableNames: '1'
      chargeInfo:
        chargeType: PostPaid
      parameters:
        - parameterName: auto_increment_increment
          parameterValue: '2'
        - parameterName: auto_increment_offset
          parameterValue: '4'
  foo1:
    type: volcengine:rds_mysql:Database
    properties:
      dbName: acc-test-db1
      instanceId: ${fooInstance.id}
  fooDatabase:
    type: volcengine:rds_mysql:Database
    properties:
      dbName: acc-test-db
      instanceId: ${fooInstance.id}
  fooAccount:
    type: volcengine:rds_mysql:Account
    properties:
      accountName: acc-test-account
      accountPassword: 93f0cb0614Aab12
      accountType: Normal
      instanceId: ${fooInstance.id}
      accountPrivileges:
        - dbName: ${fooDatabase.dbName}
          accountPrivilege: Custom
          accountPrivilegeDetail: SELECT,INSERT,UPDATE
        - dbName: ${foo1.dbName}
          accountPrivilege: DDLOnly
      host: 192.10.10.%
variables:
  fooZones:
    fn::invoke:
      Function: volcengine:ecs:getZones
      Arguments: {}

var exampleaccountResourceResourceFromRds_mysqlaccount = new Volcengine.Rds_mysql.Account("exampleaccountResourceResourceFromRds_mysqlaccount", new()
{
    AccountName = "string",
    AccountPassword = "string",
    AccountType = "string",
    InstanceId = "string",
    AccountDesc = "string",
    AccountPrivileges = new[]
    {
        new Volcengine.Rds_mysql.Inputs.AccountAccountPrivilegeArgs
        {
            AccountPrivilege = "string",
            DbName = "string",
            AccountPrivilegeDetail = "string",
        },
    },
    Host = "string",
    TableColumnPrivileges = new[]
    {
        new Volcengine.Rds_mysql.Inputs.AccountTableColumnPrivilegeArgs
        {
            DbName = "string",
            ColumnPrivileges = new[]
            {
                new Volcengine.Rds_mysql.Inputs.AccountTableColumnPrivilegeColumnPrivilegeArgs
                {
                    ColumnName = "string",
                    TableName = "string",
                    AccountPrivilegeDetail = "string",
                },
            },
            TablePrivileges = new[]
            {
                new Volcengine.Rds_mysql.Inputs.AccountTableColumnPrivilegeTablePrivilegeArgs
                {
                    TableName = "string",
                    AccountPrivilegeDetail = "string",
                },
            },
        },
    },
});

example, err := rds_mysql.NewAccount(ctx, "exampleaccountResourceResourceFromRds_mysqlaccount", &rds_mysql.AccountArgs{
	AccountName:     pulumi.String("string"),
	AccountPassword: pulumi.String("string"),
	AccountType:     pulumi.String("string"),
	InstanceId:      pulumi.String("string"),
	AccountDesc:     pulumi.String("string"),
	AccountPrivileges: rds_mysql.AccountAccountPrivilegeArray{
		&rds_mysql.AccountAccountPrivilegeArgs{
			AccountPrivilege:       pulumi.String("string"),
			DbName:                 pulumi.String("string"),
			AccountPrivilegeDetail: pulumi.String("string"),
		},
	},
	Host: pulumi.String("string"),
	TableColumnPrivileges: rds_mysql.AccountTableColumnPrivilegeArray{
		&rds_mysql.AccountTableColumnPrivilegeArgs{
			DbName: pulumi.String("string"),
			ColumnPrivileges: rds_mysql.AccountTableColumnPrivilegeColumnPrivilegeArray{
				&rds_mysql.AccountTableColumnPrivilegeColumnPrivilegeArgs{
					ColumnName:             pulumi.String("string"),
					TableName:              pulumi.String("string"),
					AccountPrivilegeDetail: pulumi.String("string"),
				},
			},
			TablePrivileges: rds_mysql.AccountTableColumnPrivilegeTablePrivilegeArray{
				&rds_mysql.AccountTableColumnPrivilegeTablePrivilegeArgs{
					TableName:              pulumi.String("string"),
					AccountPrivilegeDetail: pulumi.String("string"),
				},
			},
		},
	},
})

var exampleaccountResourceResourceFromRds_mysqlaccount = new com.pulumi.volcengine.rds_mysql.Account("exampleaccountResourceResourceFromRds_mysqlaccount", com.pulumi.volcengine.rds_mysql.AccountArgs.builder()
    .accountName("string")
    .accountPassword("string")
    .accountType("string")
    .instanceId("string")
    .accountDesc("string")
    .accountPrivileges(AccountAccountPrivilegeArgs.builder()
        .accountPrivilege("string")
        .dbName("string")
        .accountPrivilegeDetail("string")
        .build())
    .host("string")
    .tableColumnPrivileges(AccountTableColumnPrivilegeArgs.builder()
        .dbName("string")
        .columnPrivileges(AccountTableColumnPrivilegeColumnPrivilegeArgs.builder()
            .columnName("string")
            .tableName("string")
            .accountPrivilegeDetail("string")
            .build())
        .tablePrivileges(AccountTableColumnPrivilegeTablePrivilegeArgs.builder()
            .tableName("string")
            .accountPrivilegeDetail("string")
            .build())
        .build())
    .build());

exampleaccount_resource_resource_from_rds_mysqlaccount = volcengine.rds_mysql.Account("exampleaccountResourceResourceFromRds_mysqlaccount",
    account_name="string",
    account_password="string",
    account_type="string",
    instance_id="string",
    account_desc="string",
    account_privileges=[{
        "account_privilege": "string",
        "db_name": "string",
        "account_privilege_detail": "string",
    }],
    host="string",
    table_column_privileges=[{
        "db_name": "string",
        "column_privileges": [{
            "column_name": "string",
            "table_name": "string",
            "account_privilege_detail": "string",
        }],
        "table_privileges": [{
            "table_name": "string",
            "account_privilege_detail": "string",
        }],
    }])

const exampleaccountResourceResourceFromRds_mysqlaccount = new volcengine.rds_mysql.Account("exampleaccountResourceResourceFromRds_mysqlaccount", {
    accountName: "string",
    accountPassword: "string",
    accountType: "string",
    instanceId: "string",
    accountDesc: "string",
    accountPrivileges: [{
        accountPrivilege: "string",
        dbName: "string",
        accountPrivilegeDetail: "string",
    }],
    host: "string",
    tableColumnPrivileges: [{
        dbName: "string",
        columnPrivileges: [{
            columnName: "string",
            tableName: "string",
            accountPrivilegeDetail: "string",
        }],
        tablePrivileges: [{
            tableName: "string",
            accountPrivilegeDetail: "string",
        }],
    }],
});

type: volcengine:rds_mysql:Account
properties:
    accountDesc: string
    accountName: string
    accountPassword: string
    accountPrivileges:
        - accountPrivilege: string
          accountPrivilegeDetail: string
          dbName: string
    accountType: string
    host: string
    instanceId: string
    tableColumnPrivileges:
        - columnPrivileges:
            - accountPrivilegeDetail: string
              columnName: string
              tableName: string
          dbName: string
          tablePrivileges:
            - accountPrivilegeDetail: string
              tableName: string