1585346868/aliyun-openapi-cpp-sdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

DescribeDBInstances, add cpuType.

Browse Source
This commit is contained in:
sdk-team
2024-05-22 03:33:56 +00:00
parent 212db1e32d
commit 283dc6d360
293 changed files with 13397 additions and 7751 deletions
Download Patch File Download Diff File Expand all files Collapse all files

220
polardbx/CMakeLists.txt
View File

@@ -21,22 +21,26 @@ set(polardbx_public_header
include/alibabacloud/polardbx/PolardbxExport.h )
set(polardbx_public_header_model
include/alibabacloud/polardbx/model/AlignStoragePrimaryAzoneRequest.h
include/alibabacloud/polardbx/model/AlignStoragePrimaryAzoneResult.h
include/alibabacloud/polardbx/model/AllocateColdDataVolumeRequest.h
include/alibabacloud/polardbx/model/AllocateColdDataVolumeResult.h
include/alibabacloud/polardbx/model/AllocateInstancePublicConnectionRequest.h
include/alibabacloud/polardbx/model/AllocateInstancePublicConnectionResult.h
include/alibabacloud/polardbx/model/CancelPolarxOrderRequest.h
include/alibabacloud/polardbx/model/CancelPolarxOrderResult.h
include/alibabacloud/polardbx/model/CheckHealthRequest.h
include/alibabacloud/polardbx/model/CheckHealthResult.h
include/alibabacloud/polardbx/model/CancelActiveOperationTasksRequest.h
include/alibabacloud/polardbx/model/CancelActiveOperationTasksResult.h
include/alibabacloud/polardbx/model/ChangeResourceGroupRequest.h
include/alibabacloud/polardbx/model/ChangeResourceGroupResult.h
include/alibabacloud/polardbx/model/CheckCloudResourceAuthorizedRequest.h
include/alibabacloud/polardbx/model/CheckCloudResourceAuthorizedResult.h
include/alibabacloud/polardbx/model/CreateAccountRequest.h
include/alibabacloud/polardbx/model/CreateAccountResult.h
include/alibabacloud/polardbx/model/CreateBackupRequest.h
include/alibabacloud/polardbx/model/CreateBackupResult.h
include/alibabacloud/polardbx/model/CreateDBRequest.h
include/alibabacloud/polardbx/model/CreateDBResult.h
include/alibabacloud/polardbx/model/CreateDBInstanceRequest.h
include/alibabacloud/polardbx/model/CreateDBInstanceResult.h
include/alibabacloud/polardbx/model/CreatePolarxInstanceRequest.h
include/alibabacloud/polardbx/model/CreatePolarxInstanceResult.h
include/alibabacloud/polardbx/model/CreatePolarxOrderRequest.h
include/alibabacloud/polardbx/model/CreatePolarxOrderResult.h
include/alibabacloud/polardbx/model/CreateSuperAccountRequest.h
include/alibabacloud/polardbx/model/CreateSuperAccountResult.h
include/alibabacloud/polardbx/model/DeleteAccountRequest.h
@@ -47,80 +51,114 @@ set(polardbx_public_header_model
include/alibabacloud/polardbx/model/DeleteDBInstanceResult.h
include/alibabacloud/polardbx/model/DescribeAccountListRequest.h
include/alibabacloud/polardbx/model/DescribeAccountListResult.h
include/alibabacloud/polardbx/model/DescribeActiveOperationMaintainConfRequest.h
include/alibabacloud/polardbx/model/DescribeActiveOperationMaintainConfResult.h
include/alibabacloud/polardbx/model/DescribeActiveOperationTaskCountRequest.h
include/alibabacloud/polardbx/model/DescribeActiveOperationTaskCountResult.h
include/alibabacloud/polardbx/model/DescribeActiveOperationTasksRequest.h
include/alibabacloud/polardbx/model/DescribeActiveOperationTasksResult.h
include/alibabacloud/polardbx/model/DescribeArchiveTableListRequest.h
include/alibabacloud/polardbx/model/DescribeArchiveTableListResult.h
include/alibabacloud/polardbx/model/DescribeBackupPolicyRequest.h
include/alibabacloud/polardbx/model/DescribeBackupPolicyResult.h
include/alibabacloud/polardbx/model/DescribeBackupSetRequest.h
include/alibabacloud/polardbx/model/DescribeBackupSetResult.h
include/alibabacloud/polardbx/model/DescribeBackupSetListRequest.h
include/alibabacloud/polardbx/model/DescribeBackupSetListResult.h
include/alibabacloud/polardbx/model/DescribeBinaryLogListRequest.h
include/alibabacloud/polardbx/model/DescribeBinaryLogListResult.h
include/alibabacloud/polardbx/model/DescribeCharacterSetRequest.h
include/alibabacloud/polardbx/model/DescribeCharacterSetResult.h
include/alibabacloud/polardbx/model/DescribeColdDataBasicInfoRequest.h
include/alibabacloud/polardbx/model/DescribeColdDataBasicInfoResult.h
include/alibabacloud/polardbx/model/DescribeDBInstanceAttributeRequest.h
include/alibabacloud/polardbx/model/DescribeDBInstanceAttributeResult.h
include/alibabacloud/polardbx/model/DescribeDBInstanceConfigRequest.h
include/alibabacloud/polardbx/model/DescribeDBInstanceConfigResult.h
include/alibabacloud/polardbx/model/DescribeDBInstanceHARequest.h
include/alibabacloud/polardbx/model/DescribeDBInstanceHAResult.h
include/alibabacloud/polardbx/model/DescribeDBInstanceSSLRequest.h
include/alibabacloud/polardbx/model/DescribeDBInstanceSSLResult.h
include/alibabacloud/polardbx/model/DescribeDBInstanceTDERequest.h
include/alibabacloud/polardbx/model/DescribeDBInstanceTDEResult.h
include/alibabacloud/polardbx/model/DescribeDBInstanceTopologyRequest.h
include/alibabacloud/polardbx/model/DescribeDBInstanceTopologyResult.h
include/alibabacloud/polardbx/model/DescribeDBInstanceViaEndpointRequest.h
include/alibabacloud/polardbx/model/DescribeDBInstanceViaEndpointResult.h
include/alibabacloud/polardbx/model/DescribeDBInstancesRequest.h
include/alibabacloud/polardbx/model/DescribeDBInstancesResult.h
include/alibabacloud/polardbx/model/DescribeDBNodePerformanceRequest.h
include/alibabacloud/polardbx/model/DescribeDBNodePerformanceResult.h
include/alibabacloud/polardbx/model/DescribeDbListRequest.h
include/alibabacloud/polardbx/model/DescribeDbListResult.h
include/alibabacloud/polardbx/model/DescribeDistributeTableListRequest.h
include/alibabacloud/polardbx/model/DescribeDistributeTableListResult.h
include/alibabacloud/polardbx/model/DescribeInstanceDbPerformanceRequest.h
include/alibabacloud/polardbx/model/DescribeInstanceDbPerformanceResult.h
include/alibabacloud/polardbx/model/DescribeInstancePerformanceRequest.h
include/alibabacloud/polardbx/model/DescribeInstancePerformanceResult.h
include/alibabacloud/polardbx/model/DescribeInstanceStoragePerformanceRequest.h
include/alibabacloud/polardbx/model/DescribeInstanceStoragePerformanceResult.h
include/alibabacloud/polardbx/model/DescribeModifyParameterLogRequest.h
include/alibabacloud/polardbx/model/DescribeModifyParameterLogResult.h
include/alibabacloud/polardbx/model/DescribeEventsRequest.h
include/alibabacloud/polardbx/model/DescribeEventsResult.h
include/alibabacloud/polardbx/model/DescribeParameterTemplatesRequest.h
include/alibabacloud/polardbx/model/DescribeParameterTemplatesResult.h
include/alibabacloud/polardbx/model/DescribeParametersRequest.h
include/alibabacloud/polardbx/model/DescribeParametersResult.h
include/alibabacloud/polardbx/model/DescribePolarxDbInstancesRequest.h
include/alibabacloud/polardbx/model/DescribePolarxDbInstancesResult.h
include/alibabacloud/polardbx/model/DescribeRegionsRequest.h
include/alibabacloud/polardbx/model/DescribeRegionsResult.h
include/alibabacloud/polardbx/model/DescribeScaleOutMigrateTaskListRequest.h
include/alibabacloud/polardbx/model/DescribeScaleOutMigrateTaskListResult.h
include/alibabacloud/polardbx/model/DescribeSecurityIpsRequest.h
include/alibabacloud/polardbx/model/DescribeSecurityIpsResult.h
include/alibabacloud/polardbx/model/DescribeSqlAuditInfoRequest.h
include/alibabacloud/polardbx/model/DescribeSqlAuditInfoResult.h
include/alibabacloud/polardbx/model/DescribeTableDetailRequest.h
include/alibabacloud/polardbx/model/DescribeTableDetailResult.h
include/alibabacloud/polardbx/model/DescribeTagsRequest.h
include/alibabacloud/polardbx/model/DescribeTagsResult.h
include/alibabacloud/polardbx/model/DescribeTasksRequest.h
include/alibabacloud/polardbx/model/DescribeTasksResult.h
include/alibabacloud/polardbx/model/DisableSqlAuditRequest.h
include/alibabacloud/polardbx/model/DisableSqlAuditResult.h
include/alibabacloud/polardbx/model/EnableSqlAuditRequest.h
include/alibabacloud/polardbx/model/EnableSqlAuditResult.h
include/alibabacloud/polardbx/model/GetPolarXPriceRequest.h
include/alibabacloud/polardbx/model/GetPolarXPriceResult.h
include/alibabacloud/polardbx/model/GetPolarxCommodityRequest.h
include/alibabacloud/polardbx/model/GetPolarxCommodityResult.h
include/alibabacloud/polardbx/model/DescribeUserEncryptionKeyListRequest.h
include/alibabacloud/polardbx/model/DescribeUserEncryptionKeyListResult.h
include/alibabacloud/polardbx/model/DisableRightsSeparationRequest.h
include/alibabacloud/polardbx/model/DisableRightsSeparationResult.h
include/alibabacloud/polardbx/model/EnableRightsSeparationRequest.h
include/alibabacloud/polardbx/model/EnableRightsSeparationResult.h
include/alibabacloud/polardbx/model/ListTagResourcesRequest.h
include/alibabacloud/polardbx/model/ListTagResourcesResult.h
include/alibabacloud/polardbx/model/ModifyAccountDescriptionRequest.h
include/alibabacloud/polardbx/model/ModifyAccountDescriptionResult.h
include/alibabacloud/polardbx/model/ModifyAccountPrivilegeRequest.h
include/alibabacloud/polardbx/model/ModifyAccountPrivilegeResult.h
include/alibabacloud/polardbx/model/ModifyActiveOperationMaintainConfRequest.h
include/alibabacloud/polardbx/model/ModifyActiveOperationMaintainConfResult.h
include/alibabacloud/polardbx/model/ModifyActiveOperationTasksRequest.h
include/alibabacloud/polardbx/model/ModifyActiveOperationTasksResult.h
include/alibabacloud/polardbx/model/ModifyDBInstanceClassRequest.h
include/alibabacloud/polardbx/model/ModifyDBInstanceClassResult.h
include/alibabacloud/polardbx/model/ModifyDBInstanceConfigRequest.h
include/alibabacloud/polardbx/model/ModifyDBInstanceConfigResult.h
include/alibabacloud/polardbx/model/ModifyDBInstanceConnectionStringRequest.h
include/alibabacloud/polardbx/model/ModifyDBInstanceConnectionStringResult.h
include/alibabacloud/polardbx/model/ModifyDBInstanceDescriptionRequest.h
include/alibabacloud/polardbx/model/ModifyDBInstanceDescriptionResult.h
include/alibabacloud/polardbx/model/ModifyDBInstanceMaintainTimeRequest.h
include/alibabacloud/polardbx/model/ModifyDBInstanceMaintainTimeResult.h
include/alibabacloud/polardbx/model/ModifyDatabaseDescriptionRequest.h
include/alibabacloud/polardbx/model/ModifyDatabaseDescriptionResult.h
include/alibabacloud/polardbx/model/ModifyParameterRequest.h
include/alibabacloud/polardbx/model/ModifyParameterResult.h
include/alibabacloud/polardbx/model/ModifySecurityIpsRequest.h
include/alibabacloud/polardbx/model/ModifySecurityIpsResult.h
include/alibabacloud/polardbx/model/ReleaseColdDataVolumeRequest.h
include/alibabacloud/polardbx/model/ReleaseColdDataVolumeResult.h
include/alibabacloud/polardbx/model/ReleaseInstancePublicConnectionRequest.h
include/alibabacloud/polardbx/model/ReleaseInstancePublicConnectionResult.h
include/alibabacloud/polardbx/model/ResetAccountPasswordRequest.h
include/alibabacloud/polardbx/model/ResetAccountPasswordResult.h
include/alibabacloud/polardbx/model/ResetPolarxPgAccountPasswordRequest.h
include/alibabacloud/polardbx/model/ResetPolarxPgAccountPasswordResult.h
include/alibabacloud/polardbx/model/RestartDBInstanceRequest.h
include/alibabacloud/polardbx/model/RestartDBInstanceResult.h
include/alibabacloud/polardbx/model/RetryPolarxOrderRequest.h
include/alibabacloud/polardbx/model/RetryPolarxOrderResult.h
include/alibabacloud/polardbx/model/SwitchDBInstanceHARequest.h
include/alibabacloud/polardbx/model/SwitchDBInstanceHAResult.h
include/alibabacloud/polardbx/model/TagResourcesRequest.h
include/alibabacloud/polardbx/model/TagResourcesResult.h
include/alibabacloud/polardbx/model/UntagResourcesRequest.h
include/alibabacloud/polardbx/model/UntagResourcesResult.h
include/alibabacloud/polardbx/model/UpdateBackupPolicyRequest.h
include/alibabacloud/polardbx/model/UpdateBackupPolicyResult.h
include/alibabacloud/polardbx/model/UpdateDBInstanceSSLRequest.h
include/alibabacloud/polardbx/model/UpdateDBInstanceSSLResult.h
include/alibabacloud/polardbx/model/UpdateDBInstanceTDERequest.h
include/alibabacloud/polardbx/model/UpdateDBInstanceTDEResult.h
include/alibabacloud/polardbx/model/UpdatePolarDBXInstanceNodeRequest.h
include/alibabacloud/polardbx/model/UpdatePolarDBXInstanceNodeResult.h
include/alibabacloud/polardbx/model/UpgradeDBInstanceKernelVersionRequest.h
@@ -128,22 +166,26 @@ set(polardbx_public_header_model
set(polardbx_src
src/PolardbxClient.cc
src/model/AlignStoragePrimaryAzoneRequest.cc
src/model/AlignStoragePrimaryAzoneResult.cc
src/model/AllocateColdDataVolumeRequest.cc
src/model/AllocateColdDataVolumeResult.cc
src/model/AllocateInstancePublicConnectionRequest.cc
src/model/AllocateInstancePublicConnectionResult.cc
src/model/CancelPolarxOrderRequest.cc
src/model/CancelPolarxOrderResult.cc
src/model/CheckHealthRequest.cc
src/model/CheckHealthResult.cc
src/model/CancelActiveOperationTasksRequest.cc
src/model/CancelActiveOperationTasksResult.cc
src/model/ChangeResourceGroupRequest.cc
src/model/ChangeResourceGroupResult.cc
src/model/CheckCloudResourceAuthorizedRequest.cc
src/model/CheckCloudResourceAuthorizedResult.cc
src/model/CreateAccountRequest.cc
src/model/CreateAccountResult.cc
src/model/CreateBackupRequest.cc
src/model/CreateBackupResult.cc
src/model/CreateDBRequest.cc
src/model/CreateDBResult.cc
src/model/CreateDBInstanceRequest.cc
src/model/CreateDBInstanceResult.cc
src/model/CreatePolarxInstanceRequest.cc
src/model/CreatePolarxInstanceResult.cc
src/model/CreatePolarxOrderRequest.cc
src/model/CreatePolarxOrderResult.cc
src/model/CreateSuperAccountRequest.cc
src/model/CreateSuperAccountResult.cc
src/model/DeleteAccountRequest.cc
@@ -154,80 +196,114 @@ set(polardbx_src
src/model/DeleteDBInstanceResult.cc
src/model/DescribeAccountListRequest.cc
src/model/DescribeAccountListResult.cc
src/model/DescribeActiveOperationMaintainConfRequest.cc
src/model/DescribeActiveOperationMaintainConfResult.cc
src/model/DescribeActiveOperationTaskCountRequest.cc
src/model/DescribeActiveOperationTaskCountResult.cc
src/model/DescribeActiveOperationTasksRequest.cc
src/model/DescribeActiveOperationTasksResult.cc
src/model/DescribeArchiveTableListRequest.cc
src/model/DescribeArchiveTableListResult.cc
src/model/DescribeBackupPolicyRequest.cc
src/model/DescribeBackupPolicyResult.cc
src/model/DescribeBackupSetRequest.cc
src/model/DescribeBackupSetResult.cc
src/model/DescribeBackupSetListRequest.cc
src/model/DescribeBackupSetListResult.cc
src/model/DescribeBinaryLogListRequest.cc
src/model/DescribeBinaryLogListResult.cc
src/model/DescribeCharacterSetRequest.cc
src/model/DescribeCharacterSetResult.cc
src/model/DescribeColdDataBasicInfoRequest.cc
src/model/DescribeColdDataBasicInfoResult.cc
src/model/DescribeDBInstanceAttributeRequest.cc
src/model/DescribeDBInstanceAttributeResult.cc
src/model/DescribeDBInstanceConfigRequest.cc
src/model/DescribeDBInstanceConfigResult.cc
src/model/DescribeDBInstanceHARequest.cc
src/model/DescribeDBInstanceHAResult.cc
src/model/DescribeDBInstanceSSLRequest.cc
src/model/DescribeDBInstanceSSLResult.cc
src/model/DescribeDBInstanceTDERequest.cc
src/model/DescribeDBInstanceTDEResult.cc
src/model/DescribeDBInstanceTopologyRequest.cc
src/model/DescribeDBInstanceTopologyResult.cc
src/model/DescribeDBInstanceViaEndpointRequest.cc
src/model/DescribeDBInstanceViaEndpointResult.cc
src/model/DescribeDBInstancesRequest.cc
src/model/DescribeDBInstancesResult.cc
src/model/DescribeDBNodePerformanceRequest.cc
src/model/DescribeDBNodePerformanceResult.cc
src/model/DescribeDbListRequest.cc
src/model/DescribeDbListResult.cc
src/model/DescribeDistributeTableListRequest.cc
src/model/DescribeDistributeTableListResult.cc
src/model/DescribeInstanceDbPerformanceRequest.cc
src/model/DescribeInstanceDbPerformanceResult.cc
src/model/DescribeInstancePerformanceRequest.cc
src/model/DescribeInstancePerformanceResult.cc
src/model/DescribeInstanceStoragePerformanceRequest.cc
src/model/DescribeInstanceStoragePerformanceResult.cc
src/model/DescribeModifyParameterLogRequest.cc
src/model/DescribeModifyParameterLogResult.cc
src/model/DescribeEventsRequest.cc
src/model/DescribeEventsResult.cc
src/model/DescribeParameterTemplatesRequest.cc
src/model/DescribeParameterTemplatesResult.cc
src/model/DescribeParametersRequest.cc
src/model/DescribeParametersResult.cc
src/model/DescribePolarxDbInstancesRequest.cc
src/model/DescribePolarxDbInstancesResult.cc
src/model/DescribeRegionsRequest.cc
src/model/DescribeRegionsResult.cc
src/model/DescribeScaleOutMigrateTaskListRequest.cc
src/model/DescribeScaleOutMigrateTaskListResult.cc
src/model/DescribeSecurityIpsRequest.cc
src/model/DescribeSecurityIpsResult.cc
src/model/DescribeSqlAuditInfoRequest.cc
src/model/DescribeSqlAuditInfoResult.cc
src/model/DescribeTableDetailRequest.cc
src/model/DescribeTableDetailResult.cc
src/model/DescribeTagsRequest.cc
src/model/DescribeTagsResult.cc
src/model/DescribeTasksRequest.cc
src/model/DescribeTasksResult.cc
src/model/DisableSqlAuditRequest.cc
src/model/DisableSqlAuditResult.cc
src/model/EnableSqlAuditRequest.cc
src/model/EnableSqlAuditResult.cc
src/model/GetPolarXPriceRequest.cc
src/model/GetPolarXPriceResult.cc
src/model/GetPolarxCommodityRequest.cc
src/model/GetPolarxCommodityResult.cc
src/model/DescribeUserEncryptionKeyListRequest.cc
src/model/DescribeUserEncryptionKeyListResult.cc
src/model/DisableRightsSeparationRequest.cc
src/model/DisableRightsSeparationResult.cc
src/model/EnableRightsSeparationRequest.cc
src/model/EnableRightsSeparationResult.cc
src/model/ListTagResourcesRequest.cc
src/model/ListTagResourcesResult.cc
src/model/ModifyAccountDescriptionRequest.cc
src/model/ModifyAccountDescriptionResult.cc
src/model/ModifyAccountPrivilegeRequest.cc
src/model/ModifyAccountPrivilegeResult.cc
src/model/ModifyActiveOperationMaintainConfRequest.cc
src/model/ModifyActiveOperationMaintainConfResult.cc
src/model/ModifyActiveOperationTasksRequest.cc
src/model/ModifyActiveOperationTasksResult.cc
src/model/ModifyDBInstanceClassRequest.cc
src/model/ModifyDBInstanceClassResult.cc
src/model/ModifyDBInstanceConfigRequest.cc
src/model/ModifyDBInstanceConfigResult.cc
src/model/ModifyDBInstanceConnectionStringRequest.cc
src/model/ModifyDBInstanceConnectionStringResult.cc
src/model/ModifyDBInstanceDescriptionRequest.cc
src/model/ModifyDBInstanceDescriptionResult.cc
src/model/ModifyDBInstanceMaintainTimeRequest.cc
src/model/ModifyDBInstanceMaintainTimeResult.cc
src/model/ModifyDatabaseDescriptionRequest.cc
src/model/ModifyDatabaseDescriptionResult.cc
src/model/ModifyParameterRequest.cc
src/model/ModifyParameterResult.cc
src/model/ModifySecurityIpsRequest.cc
src/model/ModifySecurityIpsResult.cc
src/model/ReleaseColdDataVolumeRequest.cc
src/model/ReleaseColdDataVolumeResult.cc
src/model/ReleaseInstancePublicConnectionRequest.cc
src/model/ReleaseInstancePublicConnectionResult.cc
src/model/ResetAccountPasswordRequest.cc
src/model/ResetAccountPasswordResult.cc
src/model/ResetPolarxPgAccountPasswordRequest.cc
src/model/ResetPolarxPgAccountPasswordResult.cc
src/model/RestartDBInstanceRequest.cc
src/model/RestartDBInstanceResult.cc
src/model/RetryPolarxOrderRequest.cc
src/model/RetryPolarxOrderResult.cc
src/model/SwitchDBInstanceHARequest.cc
src/model/SwitchDBInstanceHAResult.cc
src/model/TagResourcesRequest.cc
src/model/TagResourcesResult.cc
src/model/UntagResourcesRequest.cc
src/model/UntagResourcesResult.cc
src/model/UpdateBackupPolicyRequest.cc
src/model/UpdateBackupPolicyResult.cc
src/model/UpdateDBInstanceSSLRequest.cc
src/model/UpdateDBInstanceSSLResult.cc
src/model/UpdateDBInstanceTDERequest.cc
src/model/UpdateDBInstanceTDEResult.cc
src/model/UpdatePolarDBXInstanceNodeRequest.cc
src/model/UpdatePolarDBXInstanceNodeResult.cc
src/model/UpgradeDBInstanceKernelVersionRequest.cc

440
polardbx/include/alibabacloud/polardbx/PolardbxClient.h
View File

@@ -22,22 +22,26 @@
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "PolardbxExport.h"
#include "model/AlignStoragePrimaryAzoneRequest.h"
#include "model/AlignStoragePrimaryAzoneResult.h"
#include "model/AllocateColdDataVolumeRequest.h"
#include "model/AllocateColdDataVolumeResult.h"
#include "model/AllocateInstancePublicConnectionRequest.h"
#include "model/AllocateInstancePublicConnectionResult.h"
#include "model/CancelPolarxOrderRequest.h"
#include "model/CancelPolarxOrderResult.h"
#include "model/CheckHealthRequest.h"
#include "model/CheckHealthResult.h"
#include "model/CancelActiveOperationTasksRequest.h"
#include "model/CancelActiveOperationTasksResult.h"
#include "model/ChangeResourceGroupRequest.h"
#include "model/ChangeResourceGroupResult.h"
#include "model/CheckCloudResourceAuthorizedRequest.h"
#include "model/CheckCloudResourceAuthorizedResult.h"
#include "model/CreateAccountRequest.h"
#include "model/CreateAccountResult.h"
#include "model/CreateBackupRequest.h"
#include "model/CreateBackupResult.h"
#include "model/CreateDBRequest.h"
#include "model/CreateDBResult.h"
#include "model/CreateDBInstanceRequest.h"
#include "model/CreateDBInstanceResult.h"
#include "model/CreatePolarxInstanceRequest.h"
#include "model/CreatePolarxInstanceResult.h"
#include "model/CreatePolarxOrderRequest.h"
#include "model/CreatePolarxOrderResult.h"
#include "model/CreateSuperAccountRequest.h"
#include "model/CreateSuperAccountResult.h"
#include "model/DeleteAccountRequest.h"
@@ -48,80 +52,114 @@
#include "model/DeleteDBInstanceResult.h"
#include "model/DescribeAccountListRequest.h"
#include "model/DescribeAccountListResult.h"
#include "model/DescribeActiveOperationMaintainConfRequest.h"
#include "model/DescribeActiveOperationMaintainConfResult.h"
#include "model/DescribeActiveOperationTaskCountRequest.h"
#include "model/DescribeActiveOperationTaskCountResult.h"
#include "model/DescribeActiveOperationTasksRequest.h"
#include "model/DescribeActiveOperationTasksResult.h"
#include "model/DescribeArchiveTableListRequest.h"
#include "model/DescribeArchiveTableListResult.h"
#include "model/DescribeBackupPolicyRequest.h"
#include "model/DescribeBackupPolicyResult.h"
#include "model/DescribeBackupSetRequest.h"
#include "model/DescribeBackupSetResult.h"
#include "model/DescribeBackupSetListRequest.h"
#include "model/DescribeBackupSetListResult.h"
#include "model/DescribeBinaryLogListRequest.h"
#include "model/DescribeBinaryLogListResult.h"
#include "model/DescribeCharacterSetRequest.h"
#include "model/DescribeCharacterSetResult.h"
#include "model/DescribeColdDataBasicInfoRequest.h"
#include "model/DescribeColdDataBasicInfoResult.h"
#include "model/DescribeDBInstanceAttributeRequest.h"
#include "model/DescribeDBInstanceAttributeResult.h"
#include "model/DescribeDBInstanceConfigRequest.h"
#include "model/DescribeDBInstanceConfigResult.h"
#include "model/DescribeDBInstanceHARequest.h"
#include "model/DescribeDBInstanceHAResult.h"
#include "model/DescribeDBInstanceSSLRequest.h"
#include "model/DescribeDBInstanceSSLResult.h"
#include "model/DescribeDBInstanceTDERequest.h"
#include "model/DescribeDBInstanceTDEResult.h"
#include "model/DescribeDBInstanceTopologyRequest.h"
#include "model/DescribeDBInstanceTopologyResult.h"
#include "model/DescribeDBInstanceViaEndpointRequest.h"
#include "model/DescribeDBInstanceViaEndpointResult.h"
#include "model/DescribeDBInstancesRequest.h"
#include "model/DescribeDBInstancesResult.h"
#include "model/DescribeDBNodePerformanceRequest.h"
#include "model/DescribeDBNodePerformanceResult.h"
#include "model/DescribeDbListRequest.h"
#include "model/DescribeDbListResult.h"
#include "model/DescribeDistributeTableListRequest.h"
#include "model/DescribeDistributeTableListResult.h"
#include "model/DescribeInstanceDbPerformanceRequest.h"
#include "model/DescribeInstanceDbPerformanceResult.h"
#include "model/DescribeInstancePerformanceRequest.h"
#include "model/DescribeInstancePerformanceResult.h"
#include "model/DescribeInstanceStoragePerformanceRequest.h"
#include "model/DescribeInstanceStoragePerformanceResult.h"
#include "model/DescribeModifyParameterLogRequest.h"
#include "model/DescribeModifyParameterLogResult.h"
#include "model/DescribeEventsRequest.h"
#include "model/DescribeEventsResult.h"
#include "model/DescribeParameterTemplatesRequest.h"
#include "model/DescribeParameterTemplatesResult.h"
#include "model/DescribeParametersRequest.h"
#include "model/DescribeParametersResult.h"
#include "model/DescribePolarxDbInstancesRequest.h"
#include "model/DescribePolarxDbInstancesResult.h"
#include "model/DescribeRegionsRequest.h"
#include "model/DescribeRegionsResult.h"
#include "model/DescribeScaleOutMigrateTaskListRequest.h"
#include "model/DescribeScaleOutMigrateTaskListResult.h"
#include "model/DescribeSecurityIpsRequest.h"
#include "model/DescribeSecurityIpsResult.h"
#include "model/DescribeSqlAuditInfoRequest.h"
#include "model/DescribeSqlAuditInfoResult.h"
#include "model/DescribeTableDetailRequest.h"
#include "model/DescribeTableDetailResult.h"
#include "model/DescribeTagsRequest.h"
#include "model/DescribeTagsResult.h"
#include "model/DescribeTasksRequest.h"
#include "model/DescribeTasksResult.h"
#include "model/DisableSqlAuditRequest.h"
#include "model/DisableSqlAuditResult.h"
#include "model/EnableSqlAuditRequest.h"
#include "model/EnableSqlAuditResult.h"
#include "model/GetPolarXPriceRequest.h"
#include "model/GetPolarXPriceResult.h"
#include "model/GetPolarxCommodityRequest.h"
#include "model/GetPolarxCommodityResult.h"
#include "model/DescribeUserEncryptionKeyListRequest.h"
#include "model/DescribeUserEncryptionKeyListResult.h"
#include "model/DisableRightsSeparationRequest.h"
#include "model/DisableRightsSeparationResult.h"
#include "model/EnableRightsSeparationRequest.h"
#include "model/EnableRightsSeparationResult.h"
#include "model/ListTagResourcesRequest.h"
#include "model/ListTagResourcesResult.h"
#include "model/ModifyAccountDescriptionRequest.h"
#include "model/ModifyAccountDescriptionResult.h"
#include "model/ModifyAccountPrivilegeRequest.h"
#include "model/ModifyAccountPrivilegeResult.h"
#include "model/ModifyActiveOperationMaintainConfRequest.h"
#include "model/ModifyActiveOperationMaintainConfResult.h"
#include "model/ModifyActiveOperationTasksRequest.h"
#include "model/ModifyActiveOperationTasksResult.h"
#include "model/ModifyDBInstanceClassRequest.h"
#include "model/ModifyDBInstanceClassResult.h"
#include "model/ModifyDBInstanceConfigRequest.h"
#include "model/ModifyDBInstanceConfigResult.h"
#include "model/ModifyDBInstanceConnectionStringRequest.h"
#include "model/ModifyDBInstanceConnectionStringResult.h"
#include "model/ModifyDBInstanceDescriptionRequest.h"
#include "model/ModifyDBInstanceDescriptionResult.h"
#include "model/ModifyDBInstanceMaintainTimeRequest.h"
#include "model/ModifyDBInstanceMaintainTimeResult.h"
#include "model/ModifyDatabaseDescriptionRequest.h"
#include "model/ModifyDatabaseDescriptionResult.h"
#include "model/ModifyParameterRequest.h"
#include "model/ModifyParameterResult.h"
#include "model/ModifySecurityIpsRequest.h"
#include "model/ModifySecurityIpsResult.h"
#include "model/ReleaseColdDataVolumeRequest.h"
#include "model/ReleaseColdDataVolumeResult.h"
#include "model/ReleaseInstancePublicConnectionRequest.h"
#include "model/ReleaseInstancePublicConnectionResult.h"
#include "model/ResetAccountPasswordRequest.h"
#include "model/ResetAccountPasswordResult.h"
#include "model/ResetPolarxPgAccountPasswordRequest.h"
#include "model/ResetPolarxPgAccountPasswordResult.h"
#include "model/RestartDBInstanceRequest.h"
#include "model/RestartDBInstanceResult.h"
#include "model/RetryPolarxOrderRequest.h"
#include "model/RetryPolarxOrderResult.h"
#include "model/SwitchDBInstanceHARequest.h"
#include "model/SwitchDBInstanceHAResult.h"
#include "model/TagResourcesRequest.h"
#include "model/TagResourcesResult.h"
#include "model/UntagResourcesRequest.h"
#include "model/UntagResourcesResult.h"
#include "model/UpdateBackupPolicyRequest.h"
#include "model/UpdateBackupPolicyResult.h"
#include "model/UpdateDBInstanceSSLRequest.h"
#include "model/UpdateDBInstanceSSLResult.h"
#include "model/UpdateDBInstanceTDERequest.h"
#include "model/UpdateDBInstanceTDEResult.h"
#include "model/UpdatePolarDBXInstanceNodeRequest.h"
#include "model/UpdatePolarDBXInstanceNodeResult.h"
#include "model/UpgradeDBInstanceKernelVersionRequest.h"
@@ -135,30 +173,36 @@ namespace AlibabaCloud
class ALIBABACLOUD_POLARDBX_EXPORT PolardbxClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::AlignStoragePrimaryAzoneResult> AlignStoragePrimaryAzoneOutcome;
typedef std::future<AlignStoragePrimaryAzoneOutcome> AlignStoragePrimaryAzoneOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::AlignStoragePrimaryAzoneRequest&, const AlignStoragePrimaryAzoneOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AlignStoragePrimaryAzoneAsyncHandler;
typedef Outcome<Error, Model::AllocateColdDataVolumeResult> AllocateColdDataVolumeOutcome;
typedef std::future<AllocateColdDataVolumeOutcome> AllocateColdDataVolumeOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::AllocateColdDataVolumeRequest&, const AllocateColdDataVolumeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AllocateColdDataVolumeAsyncHandler;
typedef Outcome<Error, Model::AllocateInstancePublicConnectionResult> AllocateInstancePublicConnectionOutcome;
typedef std::future<AllocateInstancePublicConnectionOutcome> AllocateInstancePublicConnectionOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::AllocateInstancePublicConnectionRequest&, const AllocateInstancePublicConnectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> AllocateInstancePublicConnectionAsyncHandler;
typedef Outcome<Error, Model::CancelPolarxOrderResult> CancelPolarxOrderOutcome;
typedef std::future<CancelPolarxOrderOutcome> CancelPolarxOrderOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::CancelPolarxOrderRequest&, const CancelPolarxOrderOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CancelPolarxOrderAsyncHandler;
typedef Outcome<Error, Model::CheckHealthResult> CheckHealthOutcome;
typedef std::future<CheckHealthOutcome> CheckHealthOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::CheckHealthRequest&, const CheckHealthOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckHealthAsyncHandler;
typedef Outcome<Error, Model::CancelActiveOperationTasksResult> CancelActiveOperationTasksOutcome;
typedef std::future<CancelActiveOperationTasksOutcome> CancelActiveOperationTasksOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::CancelActiveOperationTasksRequest&, const CancelActiveOperationTasksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CancelActiveOperationTasksAsyncHandler;
typedef Outcome<Error, Model::ChangeResourceGroupResult> ChangeResourceGroupOutcome;
typedef std::future<ChangeResourceGroupOutcome> ChangeResourceGroupOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::ChangeResourceGroupRequest&, const ChangeResourceGroupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ChangeResourceGroupAsyncHandler;
typedef Outcome<Error, Model::CheckCloudResourceAuthorizedResult> CheckCloudResourceAuthorizedOutcome;
typedef std::future<CheckCloudResourceAuthorizedOutcome> CheckCloudResourceAuthorizedOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::CheckCloudResourceAuthorizedRequest&, const CheckCloudResourceAuthorizedOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckCloudResourceAuthorizedAsyncHandler;
typedef Outcome<Error, Model::CreateAccountResult> CreateAccountOutcome;
typedef std::future<CreateAccountOutcome> CreateAccountOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::CreateAccountRequest&, const CreateAccountOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateAccountAsyncHandler;
typedef Outcome<Error, Model::CreateBackupResult> CreateBackupOutcome;
typedef std::future<CreateBackupOutcome> CreateBackupOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::CreateBackupRequest&, const CreateBackupOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateBackupAsyncHandler;
typedef Outcome<Error, Model::CreateDBResult> CreateDBOutcome;
typedef std::future<CreateDBOutcome> CreateDBOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::CreateDBRequest&, const CreateDBOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDBAsyncHandler;
typedef Outcome<Error, Model::CreateDBInstanceResult> CreateDBInstanceOutcome;
typedef std::future<CreateDBInstanceOutcome> CreateDBInstanceOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::CreateDBInstanceRequest&, const CreateDBInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDBInstanceAsyncHandler;
typedef Outcome<Error, Model::CreatePolarxInstanceResult> CreatePolarxInstanceOutcome;
typedef std::future<CreatePolarxInstanceOutcome> CreatePolarxInstanceOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::CreatePolarxInstanceRequest&, const CreatePolarxInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreatePolarxInstanceAsyncHandler;
typedef Outcome<Error, Model::CreatePolarxOrderResult> CreatePolarxOrderOutcome;
typedef std::future<CreatePolarxOrderOutcome> CreatePolarxOrderOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::CreatePolarxOrderRequest&, const CreatePolarxOrderOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreatePolarxOrderAsyncHandler;
typedef Outcome<Error, Model::CreateSuperAccountResult> CreateSuperAccountOutcome;
typedef std::future<CreateSuperAccountOutcome> CreateSuperAccountOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::CreateSuperAccountRequest&, const CreateSuperAccountOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateSuperAccountAsyncHandler;
@@ -174,45 +218,78 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DescribeAccountListResult> DescribeAccountListOutcome;
typedef std::future<DescribeAccountListOutcome> DescribeAccountListOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::DescribeAccountListRequest&, const DescribeAccountListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeAccountListAsyncHandler;
typedef Outcome<Error, Model::DescribeActiveOperationMaintainConfResult> DescribeActiveOperationMaintainConfOutcome;
typedef std::future<DescribeActiveOperationMaintainConfOutcome> DescribeActiveOperationMaintainConfOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::DescribeActiveOperationMaintainConfRequest&, const DescribeActiveOperationMaintainConfOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeActiveOperationMaintainConfAsyncHandler;
typedef Outcome<Error, Model::DescribeActiveOperationTaskCountResult> DescribeActiveOperationTaskCountOutcome;
typedef std::future<DescribeActiveOperationTaskCountOutcome> DescribeActiveOperationTaskCountOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::DescribeActiveOperationTaskCountRequest&, const DescribeActiveOperationTaskCountOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeActiveOperationTaskCountAsyncHandler;
typedef Outcome<Error, Model::DescribeActiveOperationTasksResult> DescribeActiveOperationTasksOutcome;
typedef std::future<DescribeActiveOperationTasksOutcome> DescribeActiveOperationTasksOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::DescribeActiveOperationTasksRequest&, const DescribeActiveOperationTasksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeActiveOperationTasksAsyncHandler;
typedef Outcome<Error, Model::DescribeArchiveTableListResult> DescribeArchiveTableListOutcome;
typedef std::future<DescribeArchiveTableListOutcome> DescribeArchiveTableListOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::DescribeArchiveTableListRequest&, const DescribeArchiveTableListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeArchiveTableListAsyncHandler;
typedef Outcome<Error, Model::DescribeBackupPolicyResult> DescribeBackupPolicyOutcome;
typedef std::future<DescribeBackupPolicyOutcome> DescribeBackupPolicyOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::DescribeBackupPolicyRequest&, const DescribeBackupPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeBackupPolicyAsyncHandler;
typedef Outcome<Error, Model::DescribeBackupSetResult> DescribeBackupSetOutcome;
typedef std::future<DescribeBackupSetOutcome> DescribeBackupSetOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::DescribeBackupSetRequest&, const DescribeBackupSetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeBackupSetAsyncHandler;
typedef Outcome<Error, Model::DescribeBackupSetListResult> DescribeBackupSetListOutcome;
typedef std::future<DescribeBackupSetListOutcome> DescribeBackupSetListOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::DescribeBackupSetListRequest&, const DescribeBackupSetListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeBackupSetListAsyncHandler;
typedef Outcome<Error, Model::DescribeBinaryLogListResult> DescribeBinaryLogListOutcome;
typedef std::future<DescribeBinaryLogListOutcome> DescribeBinaryLogListOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::DescribeBinaryLogListRequest&, const DescribeBinaryLogListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeBinaryLogListAsyncHandler;
typedef Outcome<Error, Model::DescribeCharacterSetResult> DescribeCharacterSetOutcome;
typedef std::future<DescribeCharacterSetOutcome> DescribeCharacterSetOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::DescribeCharacterSetRequest&, const DescribeCharacterSetOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeCharacterSetAsyncHandler;
typedef Outcome<Error, Model::DescribeColdDataBasicInfoResult> DescribeColdDataBasicInfoOutcome;
typedef std::future<DescribeColdDataBasicInfoOutcome> DescribeColdDataBasicInfoOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::DescribeColdDataBasicInfoRequest&, const DescribeColdDataBasicInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeColdDataBasicInfoAsyncHandler;
typedef Outcome<Error, Model::DescribeDBInstanceAttributeResult> DescribeDBInstanceAttributeOutcome;
typedef std::future<DescribeDBInstanceAttributeOutcome> DescribeDBInstanceAttributeOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::DescribeDBInstanceAttributeRequest&, const DescribeDBInstanceAttributeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBInstanceAttributeAsyncHandler;
typedef Outcome<Error, Model::DescribeDBInstanceConfigResult> DescribeDBInstanceConfigOutcome;
typedef std::future<DescribeDBInstanceConfigOutcome> DescribeDBInstanceConfigOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::DescribeDBInstanceConfigRequest&, const DescribeDBInstanceConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBInstanceConfigAsyncHandler;
typedef Outcome<Error, Model::DescribeDBInstanceHAResult> DescribeDBInstanceHAOutcome;
typedef std::future<DescribeDBInstanceHAOutcome> DescribeDBInstanceHAOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::DescribeDBInstanceHARequest&, const DescribeDBInstanceHAOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBInstanceHAAsyncHandler;
typedef Outcome<Error, Model::DescribeDBInstanceSSLResult> DescribeDBInstanceSSLOutcome;
typedef std::future<DescribeDBInstanceSSLOutcome> DescribeDBInstanceSSLOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::DescribeDBInstanceSSLRequest&, const DescribeDBInstanceSSLOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBInstanceSSLAsyncHandler;
typedef Outcome<Error, Model::DescribeDBInstanceTDEResult> DescribeDBInstanceTDEOutcome;
typedef std::future<DescribeDBInstanceTDEOutcome> DescribeDBInstanceTDEOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::DescribeDBInstanceTDERequest&, const DescribeDBInstanceTDEOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBInstanceTDEAsyncHandler;
typedef Outcome<Error, Model::DescribeDBInstanceTopologyResult> DescribeDBInstanceTopologyOutcome;
typedef std::future<DescribeDBInstanceTopologyOutcome> DescribeDBInstanceTopologyOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::DescribeDBInstanceTopologyRequest&, const DescribeDBInstanceTopologyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBInstanceTopologyAsyncHandler;
typedef Outcome<Error, Model::DescribeDBInstanceViaEndpointResult> DescribeDBInstanceViaEndpointOutcome;
typedef std::future<DescribeDBInstanceViaEndpointOutcome> DescribeDBInstanceViaEndpointOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::DescribeDBInstanceViaEndpointRequest&, const DescribeDBInstanceViaEndpointOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBInstanceViaEndpointAsyncHandler;
typedef Outcome<Error, Model::DescribeDBInstancesResult> DescribeDBInstancesOutcome;
typedef std::future<DescribeDBInstancesOutcome> DescribeDBInstancesOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::DescribeDBInstancesRequest&, const DescribeDBInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBInstancesAsyncHandler;
typedef Outcome<Error, Model::DescribeDBNodePerformanceResult> DescribeDBNodePerformanceOutcome;
typedef std::future<DescribeDBNodePerformanceOutcome> DescribeDBNodePerformanceOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::DescribeDBNodePerformanceRequest&, const DescribeDBNodePerformanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBNodePerformanceAsyncHandler;
typedef Outcome<Error, Model::DescribeDbListResult> DescribeDbListOutcome;
typedef std::future<DescribeDbListOutcome> DescribeDbListOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::DescribeDbListRequest&, const DescribeDbListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDbListAsyncHandler;
typedef Outcome<Error, Model::DescribeDistributeTableListResult> DescribeDistributeTableListOutcome;
typedef std::future<DescribeDistributeTableListOutcome> DescribeDistributeTableListOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::DescribeDistributeTableListRequest&, const DescribeDistributeTableListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDistributeTableListAsyncHandler;
typedef Outcome<Error, Model::DescribeInstanceDbPerformanceResult> DescribeInstanceDbPerformanceOutcome;
typedef std::future<DescribeInstanceDbPerformanceOutcome> DescribeInstanceDbPerformanceOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::DescribeInstanceDbPerformanceRequest&, const DescribeInstanceDbPerformanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeInstanceDbPerformanceAsyncHandler;
typedef Outcome<Error, Model::DescribeInstancePerformanceResult> DescribeInstancePerformanceOutcome;
typedef std::future<DescribeInstancePerformanceOutcome> DescribeInstancePerformanceOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::DescribeInstancePerformanceRequest&, const DescribeInstancePerformanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeInstancePerformanceAsyncHandler;
typedef Outcome<Error, Model::DescribeInstanceStoragePerformanceResult> DescribeInstanceStoragePerformanceOutcome;
typedef std::future<DescribeInstanceStoragePerformanceOutcome> DescribeInstanceStoragePerformanceOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::DescribeInstanceStoragePerformanceRequest&, const DescribeInstanceStoragePerformanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeInstanceStoragePerformanceAsyncHandler;
typedef Outcome<Error, Model::DescribeModifyParameterLogResult> DescribeModifyParameterLogOutcome;
typedef std::future<DescribeModifyParameterLogOutcome> DescribeModifyParameterLogOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::DescribeModifyParameterLogRequest&, const DescribeModifyParameterLogOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeModifyParameterLogAsyncHandler;
typedef Outcome<Error, Model::DescribeEventsResult> DescribeEventsOutcome;
typedef std::future<DescribeEventsOutcome> DescribeEventsOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::DescribeEventsRequest&, const DescribeEventsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeEventsAsyncHandler;
typedef Outcome<Error, Model::DescribeParameterTemplatesResult> DescribeParameterTemplatesOutcome;
typedef std::future<DescribeParameterTemplatesOutcome> DescribeParameterTemplatesOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::DescribeParameterTemplatesRequest&, const DescribeParameterTemplatesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeParameterTemplatesAsyncHandler;
typedef Outcome<Error, Model::DescribeParametersResult> DescribeParametersOutcome;
typedef std::future<DescribeParametersOutcome> DescribeParametersOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::DescribeParametersRequest&, const DescribeParametersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeParametersAsyncHandler;
typedef Outcome<Error, Model::DescribePolarxDbInstancesResult> DescribePolarxDbInstancesOutcome;
typedef std::future<DescribePolarxDbInstancesOutcome> DescribePolarxDbInstancesOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::DescribePolarxDbInstancesRequest&, const DescribePolarxDbInstancesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePolarxDbInstancesAsyncHandler;
typedef Outcome<Error, Model::DescribeRegionsResult> DescribeRegionsOutcome;
typedef std::future<DescribeRegionsOutcome> DescribeRegionsOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::DescribeRegionsRequest&, const DescribeRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRegionsAsyncHandler;
@@ -222,45 +299,48 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DescribeSecurityIpsResult> DescribeSecurityIpsOutcome;
typedef std::future<DescribeSecurityIpsOutcome> DescribeSecurityIpsOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::DescribeSecurityIpsRequest&, const DescribeSecurityIpsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSecurityIpsAsyncHandler;
typedef Outcome<Error, Model::DescribeSqlAuditInfoResult> DescribeSqlAuditInfoOutcome;
typedef std::future<DescribeSqlAuditInfoOutcome> DescribeSqlAuditInfoOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::DescribeSqlAuditInfoRequest&, const DescribeSqlAuditInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSqlAuditInfoAsyncHandler;
typedef Outcome<Error, Model::DescribeTableDetailResult> DescribeTableDetailOutcome;
typedef std::future<DescribeTableDetailOutcome> DescribeTableDetailOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::DescribeTableDetailRequest&, const DescribeTableDetailOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeTableDetailAsyncHandler;
typedef Outcome<Error, Model::DescribeTagsResult> DescribeTagsOutcome;
typedef std::future<DescribeTagsOutcome> DescribeTagsOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::DescribeTagsRequest&, const DescribeTagsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeTagsAsyncHandler;
typedef Outcome<Error, Model::DescribeTasksResult> DescribeTasksOutcome;
typedef std::future<DescribeTasksOutcome> DescribeTasksOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::DescribeTasksRequest&, const DescribeTasksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeTasksAsyncHandler;
typedef Outcome<Error, Model::DisableSqlAuditResult> DisableSqlAuditOutcome;
typedef std::future<DisableSqlAuditOutcome> DisableSqlAuditOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::DisableSqlAuditRequest&, const DisableSqlAuditOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DisableSqlAuditAsyncHandler;
typedef Outcome<Error, Model::EnableSqlAuditResult> EnableSqlAuditOutcome;
typedef std::future<EnableSqlAuditOutcome> EnableSqlAuditOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::EnableSqlAuditRequest&, const EnableSqlAuditOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableSqlAuditAsyncHandler;
typedef Outcome<Error, Model::GetPolarXPriceResult> GetPolarXPriceOutcome;
typedef std::future<GetPolarXPriceOutcome> GetPolarXPriceOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::GetPolarXPriceRequest&, const GetPolarXPriceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetPolarXPriceAsyncHandler;
typedef Outcome<Error, Model::GetPolarxCommodityResult> GetPolarxCommodityOutcome;
typedef std::future<GetPolarxCommodityOutcome> GetPolarxCommodityOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::GetPolarxCommodityRequest&, const GetPolarxCommodityOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetPolarxCommodityAsyncHandler;
typedef Outcome<Error, Model::DescribeUserEncryptionKeyListResult> DescribeUserEncryptionKeyListOutcome;
typedef std::future<DescribeUserEncryptionKeyListOutcome> DescribeUserEncryptionKeyListOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::DescribeUserEncryptionKeyListRequest&, const DescribeUserEncryptionKeyListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeUserEncryptionKeyListAsyncHandler;
typedef Outcome<Error, Model::DisableRightsSeparationResult> DisableRightsSeparationOutcome;
typedef std::future<DisableRightsSeparationOutcome> DisableRightsSeparationOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::DisableRightsSeparationRequest&, const DisableRightsSeparationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DisableRightsSeparationAsyncHandler;
typedef Outcome<Error, Model::EnableRightsSeparationResult> EnableRightsSeparationOutcome;
typedef std::future<EnableRightsSeparationOutcome> EnableRightsSeparationOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::EnableRightsSeparationRequest&, const EnableRightsSeparationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EnableRightsSeparationAsyncHandler;
typedef Outcome<Error, Model::ListTagResourcesResult> ListTagResourcesOutcome;
typedef std::future<ListTagResourcesOutcome> ListTagResourcesOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::ListTagResourcesRequest&, const ListTagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ListTagResourcesAsyncHandler;
typedef Outcome<Error, Model::ModifyAccountDescriptionResult> ModifyAccountDescriptionOutcome;
typedef std::future<ModifyAccountDescriptionOutcome> ModifyAccountDescriptionOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::ModifyAccountDescriptionRequest&, const ModifyAccountDescriptionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyAccountDescriptionAsyncHandler;
typedef Outcome<Error, Model::ModifyAccountPrivilegeResult> ModifyAccountPrivilegeOutcome;
typedef std::future<ModifyAccountPrivilegeOutcome> ModifyAccountPrivilegeOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::ModifyAccountPrivilegeRequest&, const ModifyAccountPrivilegeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyAccountPrivilegeAsyncHandler;
typedef Outcome<Error, Model::ModifyActiveOperationMaintainConfResult> ModifyActiveOperationMaintainConfOutcome;
typedef std::future<ModifyActiveOperationMaintainConfOutcome> ModifyActiveOperationMaintainConfOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::ModifyActiveOperationMaintainConfRequest&, const ModifyActiveOperationMaintainConfOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyActiveOperationMaintainConfAsyncHandler;
typedef Outcome<Error, Model::ModifyActiveOperationTasksResult> ModifyActiveOperationTasksOutcome;
typedef std::future<ModifyActiveOperationTasksOutcome> ModifyActiveOperationTasksOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::ModifyActiveOperationTasksRequest&, const ModifyActiveOperationTasksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyActiveOperationTasksAsyncHandler;
typedef Outcome<Error, Model::ModifyDBInstanceClassResult> ModifyDBInstanceClassOutcome;
typedef std::future<ModifyDBInstanceClassOutcome> ModifyDBInstanceClassOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::ModifyDBInstanceClassRequest&, const ModifyDBInstanceClassOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDBInstanceClassAsyncHandler;
typedef Outcome<Error, Model::ModifyDBInstanceConfigResult> ModifyDBInstanceConfigOutcome;
typedef std::future<ModifyDBInstanceConfigOutcome> ModifyDBInstanceConfigOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::ModifyDBInstanceConfigRequest&, const ModifyDBInstanceConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDBInstanceConfigAsyncHandler;
typedef Outcome<Error, Model::ModifyDBInstanceConnectionStringResult> ModifyDBInstanceConnectionStringOutcome;
typedef std::future<ModifyDBInstanceConnectionStringOutcome> ModifyDBInstanceConnectionStringOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::ModifyDBInstanceConnectionStringRequest&, const ModifyDBInstanceConnectionStringOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDBInstanceConnectionStringAsyncHandler;
typedef Outcome<Error, Model::ModifyDBInstanceDescriptionResult> ModifyDBInstanceDescriptionOutcome;
typedef std::future<ModifyDBInstanceDescriptionOutcome> ModifyDBInstanceDescriptionOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::ModifyDBInstanceDescriptionRequest&, const ModifyDBInstanceDescriptionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDBInstanceDescriptionAsyncHandler;
typedef Outcome<Error, Model::ModifyDBInstanceMaintainTimeResult> ModifyDBInstanceMaintainTimeOutcome;
typedef std::future<ModifyDBInstanceMaintainTimeOutcome> ModifyDBInstanceMaintainTimeOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::ModifyDBInstanceMaintainTimeRequest&, const ModifyDBInstanceMaintainTimeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDBInstanceMaintainTimeAsyncHandler;
typedef Outcome<Error, Model::ModifyDatabaseDescriptionResult> ModifyDatabaseDescriptionOutcome;
typedef std::future<ModifyDatabaseDescriptionOutcome> ModifyDatabaseDescriptionOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::ModifyDatabaseDescriptionRequest&, const ModifyDatabaseDescriptionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDatabaseDescriptionAsyncHandler;
@@ -270,21 +350,36 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::ModifySecurityIpsResult> ModifySecurityIpsOutcome;
typedef std::future<ModifySecurityIpsOutcome> ModifySecurityIpsOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::ModifySecurityIpsRequest&, const ModifySecurityIpsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifySecurityIpsAsyncHandler;
typedef Outcome<Error, Model::ReleaseColdDataVolumeResult> ReleaseColdDataVolumeOutcome;
typedef std::future<ReleaseColdDataVolumeOutcome> ReleaseColdDataVolumeOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::ReleaseColdDataVolumeRequest&, const ReleaseColdDataVolumeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ReleaseColdDataVolumeAsyncHandler;
typedef Outcome<Error, Model::ReleaseInstancePublicConnectionResult> ReleaseInstancePublicConnectionOutcome;
typedef std::future<ReleaseInstancePublicConnectionOutcome> ReleaseInstancePublicConnectionOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::ReleaseInstancePublicConnectionRequest&, const ReleaseInstancePublicConnectionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ReleaseInstancePublicConnectionAsyncHandler;
typedef Outcome<Error, Model::ResetAccountPasswordResult> ResetAccountPasswordOutcome;
typedef std::future<ResetAccountPasswordOutcome> ResetAccountPasswordOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::ResetAccountPasswordRequest&, const ResetAccountPasswordOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ResetAccountPasswordAsyncHandler;
typedef Outcome<Error, Model::ResetPolarxPgAccountPasswordResult> ResetPolarxPgAccountPasswordOutcome;
typedef std::future<ResetPolarxPgAccountPasswordOutcome> ResetPolarxPgAccountPasswordOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::ResetPolarxPgAccountPasswordRequest&, const ResetPolarxPgAccountPasswordOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ResetPolarxPgAccountPasswordAsyncHandler;
typedef Outcome<Error, Model::RestartDBInstanceResult> RestartDBInstanceOutcome;
typedef std::future<RestartDBInstanceOutcome> RestartDBInstanceOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::RestartDBInstanceRequest&, const RestartDBInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RestartDBInstanceAsyncHandler;
typedef Outcome<Error, Model::RetryPolarxOrderResult> RetryPolarxOrderOutcome;
typedef std::future<RetryPolarxOrderOutcome> RetryPolarxOrderOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::RetryPolarxOrderRequest&, const RetryPolarxOrderOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RetryPolarxOrderAsyncHandler;
typedef Outcome<Error, Model::SwitchDBInstanceHAResult> SwitchDBInstanceHAOutcome;
typedef std::future<SwitchDBInstanceHAOutcome> SwitchDBInstanceHAOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::SwitchDBInstanceHARequest&, const SwitchDBInstanceHAOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> SwitchDBInstanceHAAsyncHandler;
typedef Outcome<Error, Model::TagResourcesResult> TagResourcesOutcome;
typedef std::future<TagResourcesOutcome> TagResourcesOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::TagResourcesRequest&, const TagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TagResourcesAsyncHandler;
typedef Outcome<Error, Model::UntagResourcesResult> UntagResourcesOutcome;
typedef std::future<UntagResourcesOutcome> UntagResourcesOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::UntagResourcesRequest&, const UntagResourcesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UntagResourcesAsyncHandler;
typedef Outcome<Error, Model::UpdateBackupPolicyResult> UpdateBackupPolicyOutcome;
typedef std::future<UpdateBackupPolicyOutcome> UpdateBackupPolicyOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::UpdateBackupPolicyRequest&, const UpdateBackupPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateBackupPolicyAsyncHandler;
typedef Outcome<Error, Model::UpdateDBInstanceSSLResult> UpdateDBInstanceSSLOutcome;
typedef std::future<UpdateDBInstanceSSLOutcome> UpdateDBInstanceSSLOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::UpdateDBInstanceSSLRequest&, const UpdateDBInstanceSSLOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateDBInstanceSSLAsyncHandler;
typedef Outcome<Error, Model::UpdateDBInstanceTDEResult> UpdateDBInstanceTDEOutcome;
typedef std::future<UpdateDBInstanceTDEOutcome> UpdateDBInstanceTDEOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::UpdateDBInstanceTDERequest&, const UpdateDBInstanceTDEOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdateDBInstanceTDEAsyncHandler;
typedef Outcome<Error, Model::UpdatePolarDBXInstanceNodeResult> UpdatePolarDBXInstanceNodeOutcome;
typedef std::future<UpdatePolarDBXInstanceNodeOutcome> UpdatePolarDBXInstanceNodeOutcomeCallable;
typedef std::function<void(const PolardbxClient*, const Model::UpdatePolarDBXInstanceNodeRequest&, const UpdatePolarDBXInstanceNodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> UpdatePolarDBXInstanceNodeAsyncHandler;
@@ -296,30 +391,36 @@ namespace AlibabaCloud
PolardbxClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
PolardbxClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~PolardbxClient();
AlignStoragePrimaryAzoneOutcome alignStoragePrimaryAzone(const Model::AlignStoragePrimaryAzoneRequest &request)const;
void alignStoragePrimaryAzoneAsync(const Model::AlignStoragePrimaryAzoneRequest& request, const AlignStoragePrimaryAzoneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AlignStoragePrimaryAzoneOutcomeCallable alignStoragePrimaryAzoneCallable(const Model::AlignStoragePrimaryAzoneRequest& request) const;
AllocateColdDataVolumeOutcome allocateColdDataVolume(const Model::AllocateColdDataVolumeRequest &request)const;
void allocateColdDataVolumeAsync(const Model::AllocateColdDataVolumeRequest& request, const AllocateColdDataVolumeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AllocateColdDataVolumeOutcomeCallable allocateColdDataVolumeCallable(const Model::AllocateColdDataVolumeRequest& request) const;
AllocateInstancePublicConnectionOutcome allocateInstancePublicConnection(const Model::AllocateInstancePublicConnectionRequest &request)const;
void allocateInstancePublicConnectionAsync(const Model::AllocateInstancePublicConnectionRequest& request, const AllocateInstancePublicConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
AllocateInstancePublicConnectionOutcomeCallable allocateInstancePublicConnectionCallable(const Model::AllocateInstancePublicConnectionRequest& request) const;
CancelPolarxOrderOutcome cancelPolarxOrder(const Model::CancelPolarxOrderRequest &request)const;
void cancelPolarxOrderAsync(const Model::CancelPolarxOrderRequest& request, const CancelPolarxOrderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CancelPolarxOrderOutcomeCallable cancelPolarxOrderCallable(const Model::CancelPolarxOrderRequest& request) const;
CheckHealthOutcome checkHealth(const Model::CheckHealthRequest &request)const;
void checkHealthAsync(const Model::CheckHealthRequest& request, const CheckHealthAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CheckHealthOutcomeCallable checkHealthCallable(const Model::CheckHealthRequest& request) const;
CancelActiveOperationTasksOutcome cancelActiveOperationTasks(const Model::CancelActiveOperationTasksRequest &request)const;
void cancelActiveOperationTasksAsync(const Model::CancelActiveOperationTasksRequest& request, const CancelActiveOperationTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CancelActiveOperationTasksOutcomeCallable cancelActiveOperationTasksCallable(const Model::CancelActiveOperationTasksRequest& request) const;
ChangeResourceGroupOutcome changeResourceGroup(const Model::ChangeResourceGroupRequest &request)const;
void changeResourceGroupAsync(const Model::ChangeResourceGroupRequest& request, const ChangeResourceGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ChangeResourceGroupOutcomeCallable changeResourceGroupCallable(const Model::ChangeResourceGroupRequest& request) const;
CheckCloudResourceAuthorizedOutcome checkCloudResourceAuthorized(const Model::CheckCloudResourceAuthorizedRequest &request)const;
void checkCloudResourceAuthorizedAsync(const Model::CheckCloudResourceAuthorizedRequest& request, const CheckCloudResourceAuthorizedAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CheckCloudResourceAuthorizedOutcomeCallable checkCloudResourceAuthorizedCallable(const Model::CheckCloudResourceAuthorizedRequest& request) const;
CreateAccountOutcome createAccount(const Model::CreateAccountRequest &request)const;
void createAccountAsync(const Model::CreateAccountRequest& request, const CreateAccountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateAccountOutcomeCallable createAccountCallable(const Model::CreateAccountRequest& request) const;
CreateBackupOutcome createBackup(const Model::CreateBackupRequest &request)const;
void createBackupAsync(const Model::CreateBackupRequest& request, const CreateBackupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateBackupOutcomeCallable createBackupCallable(const Model::CreateBackupRequest& request) const;
CreateDBOutcome createDB(const Model::CreateDBRequest &request)const;
void createDBAsync(const Model::CreateDBRequest& request, const CreateDBAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateDBOutcomeCallable createDBCallable(const Model::CreateDBRequest& request) const;
CreateDBInstanceOutcome createDBInstance(const Model::CreateDBInstanceRequest &request)const;
void createDBInstanceAsync(const Model::CreateDBInstanceRequest& request, const CreateDBInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateDBInstanceOutcomeCallable createDBInstanceCallable(const Model::CreateDBInstanceRequest& request) const;
CreatePolarxInstanceOutcome createPolarxInstance(const Model::CreatePolarxInstanceRequest &request)const;
void createPolarxInstanceAsync(const Model::CreatePolarxInstanceRequest& request, const CreatePolarxInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreatePolarxInstanceOutcomeCallable createPolarxInstanceCallable(const Model::CreatePolarxInstanceRequest& request) const;
CreatePolarxOrderOutcome createPolarxOrder(const Model::CreatePolarxOrderRequest &request)const;
void createPolarxOrderAsync(const Model::CreatePolarxOrderRequest& request, const CreatePolarxOrderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreatePolarxOrderOutcomeCallable createPolarxOrderCallable(const Model::CreatePolarxOrderRequest& request) const;
CreateSuperAccountOutcome createSuperAccount(const Model::CreateSuperAccountRequest &request)const;
void createSuperAccountAsync(const Model::CreateSuperAccountRequest& request, const CreateSuperAccountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateSuperAccountOutcomeCallable createSuperAccountCallable(const Model::CreateSuperAccountRequest& request) const;
@@ -335,45 +436,78 @@ namespace AlibabaCloud
DescribeAccountListOutcome describeAccountList(const Model::DescribeAccountListRequest &request)const;
void describeAccountListAsync(const Model::DescribeAccountListRequest& request, const DescribeAccountListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeAccountListOutcomeCallable describeAccountListCallable(const Model::DescribeAccountListRequest& request) const;
DescribeActiveOperationMaintainConfOutcome describeActiveOperationMaintainConf(const Model::DescribeActiveOperationMaintainConfRequest &request)const;
void describeActiveOperationMaintainConfAsync(const Model::DescribeActiveOperationMaintainConfRequest& request, const DescribeActiveOperationMaintainConfAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeActiveOperationMaintainConfOutcomeCallable describeActiveOperationMaintainConfCallable(const Model::DescribeActiveOperationMaintainConfRequest& request) const;
DescribeActiveOperationTaskCountOutcome describeActiveOperationTaskCount(const Model::DescribeActiveOperationTaskCountRequest &request)const;
void describeActiveOperationTaskCountAsync(const Model::DescribeActiveOperationTaskCountRequest& request, const DescribeActiveOperationTaskCountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeActiveOperationTaskCountOutcomeCallable describeActiveOperationTaskCountCallable(const Model::DescribeActiveOperationTaskCountRequest& request) const;
DescribeActiveOperationTasksOutcome describeActiveOperationTasks(const Model::DescribeActiveOperationTasksRequest &request)const;
void describeActiveOperationTasksAsync(const Model::DescribeActiveOperationTasksRequest& request, const DescribeActiveOperationTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeActiveOperationTasksOutcomeCallable describeActiveOperationTasksCallable(const Model::DescribeActiveOperationTasksRequest& request) const;
DescribeArchiveTableListOutcome describeArchiveTableList(const Model::DescribeArchiveTableListRequest &request)const;
void describeArchiveTableListAsync(const Model::DescribeArchiveTableListRequest& request, const DescribeArchiveTableListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeArchiveTableListOutcomeCallable describeArchiveTableListCallable(const Model::DescribeArchiveTableListRequest& request) const;
DescribeBackupPolicyOutcome describeBackupPolicy(const Model::DescribeBackupPolicyRequest &request)const;
void describeBackupPolicyAsync(const Model::DescribeBackupPolicyRequest& request, const DescribeBackupPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeBackupPolicyOutcomeCallable describeBackupPolicyCallable(const Model::DescribeBackupPolicyRequest& request) const;
DescribeBackupSetOutcome describeBackupSet(const Model::DescribeBackupSetRequest &request)const;
void describeBackupSetAsync(const Model::DescribeBackupSetRequest& request, const DescribeBackupSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeBackupSetOutcomeCallable describeBackupSetCallable(const Model::DescribeBackupSetRequest& request) const;
DescribeBackupSetListOutcome describeBackupSetList(const Model::DescribeBackupSetListRequest &request)const;
void describeBackupSetListAsync(const Model::DescribeBackupSetListRequest& request, const DescribeBackupSetListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeBackupSetListOutcomeCallable describeBackupSetListCallable(const Model::DescribeBackupSetListRequest& request) const;
DescribeBinaryLogListOutcome describeBinaryLogList(const Model::DescribeBinaryLogListRequest &request)const;
void describeBinaryLogListAsync(const Model::DescribeBinaryLogListRequest& request, const DescribeBinaryLogListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeBinaryLogListOutcomeCallable describeBinaryLogListCallable(const Model::DescribeBinaryLogListRequest& request) const;
DescribeCharacterSetOutcome describeCharacterSet(const Model::DescribeCharacterSetRequest &request)const;
void describeCharacterSetAsync(const Model::DescribeCharacterSetRequest& request, const DescribeCharacterSetAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeCharacterSetOutcomeCallable describeCharacterSetCallable(const Model::DescribeCharacterSetRequest& request) const;
DescribeColdDataBasicInfoOutcome describeColdDataBasicInfo(const Model::DescribeColdDataBasicInfoRequest &request)const;
void describeColdDataBasicInfoAsync(const Model::DescribeColdDataBasicInfoRequest& request, const DescribeColdDataBasicInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeColdDataBasicInfoOutcomeCallable describeColdDataBasicInfoCallable(const Model::DescribeColdDataBasicInfoRequest& request) const;
DescribeDBInstanceAttributeOutcome describeDBInstanceAttribute(const Model::DescribeDBInstanceAttributeRequest &request)const;
void describeDBInstanceAttributeAsync(const Model::DescribeDBInstanceAttributeRequest& request, const DescribeDBInstanceAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDBInstanceAttributeOutcomeCallable describeDBInstanceAttributeCallable(const Model::DescribeDBInstanceAttributeRequest& request) const;
DescribeDBInstanceConfigOutcome describeDBInstanceConfig(const Model::DescribeDBInstanceConfigRequest &request)const;
void describeDBInstanceConfigAsync(const Model::DescribeDBInstanceConfigRequest& request, const DescribeDBInstanceConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDBInstanceConfigOutcomeCallable describeDBInstanceConfigCallable(const Model::DescribeDBInstanceConfigRequest& request) const;
DescribeDBInstanceHAOutcome describeDBInstanceHA(const Model::DescribeDBInstanceHARequest &request)const;
void describeDBInstanceHAAsync(const Model::DescribeDBInstanceHARequest& request, const DescribeDBInstanceHAAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDBInstanceHAOutcomeCallable describeDBInstanceHACallable(const Model::DescribeDBInstanceHARequest& request) const;
DescribeDBInstanceSSLOutcome describeDBInstanceSSL(const Model::DescribeDBInstanceSSLRequest &request)const;
void describeDBInstanceSSLAsync(const Model::DescribeDBInstanceSSLRequest& request, const DescribeDBInstanceSSLAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDBInstanceSSLOutcomeCallable describeDBInstanceSSLCallable(const Model::DescribeDBInstanceSSLRequest& request) const;
DescribeDBInstanceTDEOutcome describeDBInstanceTDE(const Model::DescribeDBInstanceTDERequest &request)const;
void describeDBInstanceTDEAsync(const Model::DescribeDBInstanceTDERequest& request, const DescribeDBInstanceTDEAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDBInstanceTDEOutcomeCallable describeDBInstanceTDECallable(const Model::DescribeDBInstanceTDERequest& request) const;
DescribeDBInstanceTopologyOutcome describeDBInstanceTopology(const Model::DescribeDBInstanceTopologyRequest &request)const;
void describeDBInstanceTopologyAsync(const Model::DescribeDBInstanceTopologyRequest& request, const DescribeDBInstanceTopologyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDBInstanceTopologyOutcomeCallable describeDBInstanceTopologyCallable(const Model::DescribeDBInstanceTopologyRequest& request) const;
DescribeDBInstanceViaEndpointOutcome describeDBInstanceViaEndpoint(const Model::DescribeDBInstanceViaEndpointRequest &request)const;
void describeDBInstanceViaEndpointAsync(const Model::DescribeDBInstanceViaEndpointRequest& request, const DescribeDBInstanceViaEndpointAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDBInstanceViaEndpointOutcomeCallable describeDBInstanceViaEndpointCallable(const Model::DescribeDBInstanceViaEndpointRequest& request) const;
DescribeDBInstancesOutcome describeDBInstances(const Model::DescribeDBInstancesRequest &request)const;
void describeDBInstancesAsync(const Model::DescribeDBInstancesRequest& request, const DescribeDBInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDBInstancesOutcomeCallable describeDBInstancesCallable(const Model::DescribeDBInstancesRequest& request) const;
DescribeDBNodePerformanceOutcome describeDBNodePerformance(const Model::DescribeDBNodePerformanceRequest &request)const;
void describeDBNodePerformanceAsync(const Model::DescribeDBNodePerformanceRequest& request, const DescribeDBNodePerformanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDBNodePerformanceOutcomeCallable describeDBNodePerformanceCallable(const Model::DescribeDBNodePerformanceRequest& request) const;
DescribeDbListOutcome describeDbList(const Model::DescribeDbListRequest &request)const;
void describeDbListAsync(const Model::DescribeDbListRequest& request, const DescribeDbListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDbListOutcomeCallable describeDbListCallable(const Model::DescribeDbListRequest& request) const;
DescribeDistributeTableListOutcome describeDistributeTableList(const Model::DescribeDistributeTableListRequest &request)const;
void describeDistributeTableListAsync(const Model::DescribeDistributeTableListRequest& request, const DescribeDistributeTableListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDistributeTableListOutcomeCallable describeDistributeTableListCallable(const Model::DescribeDistributeTableListRequest& request) const;
DescribeInstanceDbPerformanceOutcome describeInstanceDbPerformance(const Model::DescribeInstanceDbPerformanceRequest &request)const;
void describeInstanceDbPerformanceAsync(const Model::DescribeInstanceDbPerformanceRequest& request, const DescribeInstanceDbPerformanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeInstanceDbPerformanceOutcomeCallable describeInstanceDbPerformanceCallable(const Model::DescribeInstanceDbPerformanceRequest& request) const;
DescribeInstancePerformanceOutcome describeInstancePerformance(const Model::DescribeInstancePerformanceRequest &request)const;
void describeInstancePerformanceAsync(const Model::DescribeInstancePerformanceRequest& request, const DescribeInstancePerformanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeInstancePerformanceOutcomeCallable describeInstancePerformanceCallable(const Model::DescribeInstancePerformanceRequest& request) const;
DescribeInstanceStoragePerformanceOutcome describeInstanceStoragePerformance(const Model::DescribeInstanceStoragePerformanceRequest &request)const;
void describeInstanceStoragePerformanceAsync(const Model::DescribeInstanceStoragePerformanceRequest& request, const DescribeInstanceStoragePerformanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeInstanceStoragePerformanceOutcomeCallable describeInstanceStoragePerformanceCallable(const Model::DescribeInstanceStoragePerformanceRequest& request) const;
DescribeModifyParameterLogOutcome describeModifyParameterLog(const Model::DescribeModifyParameterLogRequest &request)const;
void describeModifyParameterLogAsync(const Model::DescribeModifyParameterLogRequest& request, const DescribeModifyParameterLogAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeModifyParameterLogOutcomeCallable describeModifyParameterLogCallable(const Model::DescribeModifyParameterLogRequest& request) const;
DescribeEventsOutcome describeEvents(const Model::DescribeEventsRequest &request)const;
void describeEventsAsync(const Model::DescribeEventsRequest& request, const DescribeEventsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeEventsOutcomeCallable describeEventsCallable(const Model::DescribeEventsRequest& request) const;
DescribeParameterTemplatesOutcome describeParameterTemplates(const Model::DescribeParameterTemplatesRequest &request)const;
void describeParameterTemplatesAsync(const Model::DescribeParameterTemplatesRequest& request, const DescribeParameterTemplatesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeParameterTemplatesOutcomeCallable describeParameterTemplatesCallable(const Model::DescribeParameterTemplatesRequest& request) const;
DescribeParametersOutcome describeParameters(const Model::DescribeParametersRequest &request)const;
void describeParametersAsync(const Model::DescribeParametersRequest& request, const DescribeParametersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeParametersOutcomeCallable describeParametersCallable(const Model::DescribeParametersRequest& request) const;
DescribePolarxDbInstancesOutcome describePolarxDbInstances(const Model::DescribePolarxDbInstancesRequest &request)const;
void describePolarxDbInstancesAsync(const Model::DescribePolarxDbInstancesRequest& request, const DescribePolarxDbInstancesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribePolarxDbInstancesOutcomeCallable describePolarxDbInstancesCallable(const Model::DescribePolarxDbInstancesRequest& request) const;
DescribeRegionsOutcome describeRegions(const Model::DescribeRegionsRequest &request)const;
void describeRegionsAsync(const Model::DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeRegionsOutcomeCallable describeRegionsCallable(const Model::DescribeRegionsRequest& request) const;
@@ -383,45 +517,48 @@ namespace AlibabaCloud
DescribeSecurityIpsOutcome describeSecurityIps(const Model::DescribeSecurityIpsRequest &request)const;
void describeSecurityIpsAsync(const Model::DescribeSecurityIpsRequest& request, const DescribeSecurityIpsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeSecurityIpsOutcomeCallable describeSecurityIpsCallable(const Model::DescribeSecurityIpsRequest& request) const;
DescribeSqlAuditInfoOutcome describeSqlAuditInfo(const Model::DescribeSqlAuditInfoRequest &request)const;
void describeSqlAuditInfoAsync(const Model::DescribeSqlAuditInfoRequest& request, const DescribeSqlAuditInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeSqlAuditInfoOutcomeCallable describeSqlAuditInfoCallable(const Model::DescribeSqlAuditInfoRequest& request) const;
DescribeTableDetailOutcome describeTableDetail(const Model::DescribeTableDetailRequest &request)const;
void describeTableDetailAsync(const Model::DescribeTableDetailRequest& request, const DescribeTableDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeTableDetailOutcomeCallable describeTableDetailCallable(const Model::DescribeTableDetailRequest& request) const;
DescribeTagsOutcome describeTags(const Model::DescribeTagsRequest &request)const;
void describeTagsAsync(const Model::DescribeTagsRequest& request, const DescribeTagsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeTagsOutcomeCallable describeTagsCallable(const Model::DescribeTagsRequest& request) const;
DescribeTasksOutcome describeTasks(const Model::DescribeTasksRequest &request)const;
void describeTasksAsync(const Model::DescribeTasksRequest& request, const DescribeTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeTasksOutcomeCallable describeTasksCallable(const Model::DescribeTasksRequest& request) const;
DisableSqlAuditOutcome disableSqlAudit(const Model::DisableSqlAuditRequest &request)const;
void disableSqlAuditAsync(const Model::DisableSqlAuditRequest& request, const DisableSqlAuditAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DisableSqlAuditOutcomeCallable disableSqlAuditCallable(const Model::DisableSqlAuditRequest& request) const;
EnableSqlAuditOutcome enableSqlAudit(const Model::EnableSqlAuditRequest &request)const;
void enableSqlAuditAsync(const Model::EnableSqlAuditRequest& request, const EnableSqlAuditAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
EnableSqlAuditOutcomeCallable enableSqlAuditCallable(const Model::EnableSqlAuditRequest& request) const;
GetPolarXPriceOutcome getPolarXPrice(const Model::GetPolarXPriceRequest &request)const;
void getPolarXPriceAsync(const Model::GetPolarXPriceRequest& request, const GetPolarXPriceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetPolarXPriceOutcomeCallable getPolarXPriceCallable(const Model::GetPolarXPriceRequest& request) const;
GetPolarxCommodityOutcome getPolarxCommodity(const Model::GetPolarxCommodityRequest &request)const;
void getPolarxCommodityAsync(const Model::GetPolarxCommodityRequest& request, const GetPolarxCommodityAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetPolarxCommodityOutcomeCallable getPolarxCommodityCallable(const Model::GetPolarxCommodityRequest& request) const;
DescribeUserEncryptionKeyListOutcome describeUserEncryptionKeyList(const Model::DescribeUserEncryptionKeyListRequest &request)const;
void describeUserEncryptionKeyListAsync(const Model::DescribeUserEncryptionKeyListRequest& request, const DescribeUserEncryptionKeyListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeUserEncryptionKeyListOutcomeCallable describeUserEncryptionKeyListCallable(const Model::DescribeUserEncryptionKeyListRequest& request) const;
DisableRightsSeparationOutcome disableRightsSeparation(const Model::DisableRightsSeparationRequest &request)const;
void disableRightsSeparationAsync(const Model::DisableRightsSeparationRequest& request, const DisableRightsSeparationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DisableRightsSeparationOutcomeCallable disableRightsSeparationCallable(const Model::DisableRightsSeparationRequest& request) const;
EnableRightsSeparationOutcome enableRightsSeparation(const Model::EnableRightsSeparationRequest &request)const;
void enableRightsSeparationAsync(const Model::EnableRightsSeparationRequest& request, const EnableRightsSeparationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
EnableRightsSeparationOutcomeCallable enableRightsSeparationCallable(const Model::EnableRightsSeparationRequest& request) const;
ListTagResourcesOutcome listTagResources(const Model::ListTagResourcesRequest &request)const;
void listTagResourcesAsync(const Model::ListTagResourcesRequest& request, const ListTagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ListTagResourcesOutcomeCallable listTagResourcesCallable(const Model::ListTagResourcesRequest& request) const;
ModifyAccountDescriptionOutcome modifyAccountDescription(const Model::ModifyAccountDescriptionRequest &request)const;
void modifyAccountDescriptionAsync(const Model::ModifyAccountDescriptionRequest& request, const ModifyAccountDescriptionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyAccountDescriptionOutcomeCallable modifyAccountDescriptionCallable(const Model::ModifyAccountDescriptionRequest& request) const;
ModifyAccountPrivilegeOutcome modifyAccountPrivilege(const Model::ModifyAccountPrivilegeRequest &request)const;
void modifyAccountPrivilegeAsync(const Model::ModifyAccountPrivilegeRequest& request, const ModifyAccountPrivilegeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyAccountPrivilegeOutcomeCallable modifyAccountPrivilegeCallable(const Model::ModifyAccountPrivilegeRequest& request) const;
ModifyActiveOperationMaintainConfOutcome modifyActiveOperationMaintainConf(const Model::ModifyActiveOperationMaintainConfRequest &request)const;
void modifyActiveOperationMaintainConfAsync(const Model::ModifyActiveOperationMaintainConfRequest& request, const ModifyActiveOperationMaintainConfAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyActiveOperationMaintainConfOutcomeCallable modifyActiveOperationMaintainConfCallable(const Model::ModifyActiveOperationMaintainConfRequest& request) const;
ModifyActiveOperationTasksOutcome modifyActiveOperationTasks(const Model::ModifyActiveOperationTasksRequest &request)const;
void modifyActiveOperationTasksAsync(const Model::ModifyActiveOperationTasksRequest& request, const ModifyActiveOperationTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyActiveOperationTasksOutcomeCallable modifyActiveOperationTasksCallable(const Model::ModifyActiveOperationTasksRequest& request) const;
ModifyDBInstanceClassOutcome modifyDBInstanceClass(const Model::ModifyDBInstanceClassRequest &request)const;
void modifyDBInstanceClassAsync(const Model::ModifyDBInstanceClassRequest& request, const ModifyDBInstanceClassAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyDBInstanceClassOutcomeCallable modifyDBInstanceClassCallable(const Model::ModifyDBInstanceClassRequest& request) const;
ModifyDBInstanceConfigOutcome modifyDBInstanceConfig(const Model::ModifyDBInstanceConfigRequest &request)const;
void modifyDBInstanceConfigAsync(const Model::ModifyDBInstanceConfigRequest& request, const ModifyDBInstanceConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyDBInstanceConfigOutcomeCallable modifyDBInstanceConfigCallable(const Model::ModifyDBInstanceConfigRequest& request) const;
ModifyDBInstanceConnectionStringOutcome modifyDBInstanceConnectionString(const Model::ModifyDBInstanceConnectionStringRequest &request)const;
void modifyDBInstanceConnectionStringAsync(const Model::ModifyDBInstanceConnectionStringRequest& request, const ModifyDBInstanceConnectionStringAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyDBInstanceConnectionStringOutcomeCallable modifyDBInstanceConnectionStringCallable(const Model::ModifyDBInstanceConnectionStringRequest& request) const;
ModifyDBInstanceDescriptionOutcome modifyDBInstanceDescription(const Model::ModifyDBInstanceDescriptionRequest &request)const;
void modifyDBInstanceDescriptionAsync(const Model::ModifyDBInstanceDescriptionRequest& request, const ModifyDBInstanceDescriptionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyDBInstanceDescriptionOutcomeCallable modifyDBInstanceDescriptionCallable(const Model::ModifyDBInstanceDescriptionRequest& request) const;
ModifyDBInstanceMaintainTimeOutcome modifyDBInstanceMaintainTime(const Model::ModifyDBInstanceMaintainTimeRequest &request)const;
void modifyDBInstanceMaintainTimeAsync(const Model::ModifyDBInstanceMaintainTimeRequest& request, const ModifyDBInstanceMaintainTimeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyDBInstanceMaintainTimeOutcomeCallable modifyDBInstanceMaintainTimeCallable(const Model::ModifyDBInstanceMaintainTimeRequest& request) const;
ModifyDatabaseDescriptionOutcome modifyDatabaseDescription(const Model::ModifyDatabaseDescriptionRequest &request)const;
void modifyDatabaseDescriptionAsync(const Model::ModifyDatabaseDescriptionRequest& request, const ModifyDatabaseDescriptionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifyDatabaseDescriptionOutcomeCallable modifyDatabaseDescriptionCallable(const Model::ModifyDatabaseDescriptionRequest& request) const;
@@ -431,21 +568,36 @@ namespace AlibabaCloud
ModifySecurityIpsOutcome modifySecurityIps(const Model::ModifySecurityIpsRequest &request)const;
void modifySecurityIpsAsync(const Model::ModifySecurityIpsRequest& request, const ModifySecurityIpsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ModifySecurityIpsOutcomeCallable modifySecurityIpsCallable(const Model::ModifySecurityIpsRequest& request) const;
ReleaseColdDataVolumeOutcome releaseColdDataVolume(const Model::ReleaseColdDataVolumeRequest &request)const;
void releaseColdDataVolumeAsync(const Model::ReleaseColdDataVolumeRequest& request, const ReleaseColdDataVolumeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ReleaseColdDataVolumeOutcomeCallable releaseColdDataVolumeCallable(const Model::ReleaseColdDataVolumeRequest& request) const;
ReleaseInstancePublicConnectionOutcome releaseInstancePublicConnection(const Model::ReleaseInstancePublicConnectionRequest &request)const;
void releaseInstancePublicConnectionAsync(const Model::ReleaseInstancePublicConnectionRequest& request, const ReleaseInstancePublicConnectionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ReleaseInstancePublicConnectionOutcomeCallable releaseInstancePublicConnectionCallable(const Model::ReleaseInstancePublicConnectionRequest& request) const;
ResetAccountPasswordOutcome resetAccountPassword(const Model::ResetAccountPasswordRequest &request)const;
void resetAccountPasswordAsync(const Model::ResetAccountPasswordRequest& request, const ResetAccountPasswordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ResetAccountPasswordOutcomeCallable resetAccountPasswordCallable(const Model::ResetAccountPasswordRequest& request) const;
ResetPolarxPgAccountPasswordOutcome resetPolarxPgAccountPassword(const Model::ResetPolarxPgAccountPasswordRequest &request)const;
void resetPolarxPgAccountPasswordAsync(const Model::ResetPolarxPgAccountPasswordRequest& request, const ResetPolarxPgAccountPasswordAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
ResetPolarxPgAccountPasswordOutcomeCallable resetPolarxPgAccountPasswordCallable(const Model::ResetPolarxPgAccountPasswordRequest& request) const;
RestartDBInstanceOutcome restartDBInstance(const Model::RestartDBInstanceRequest &request)const;
void restartDBInstanceAsync(const Model::RestartDBInstanceRequest& request, const RestartDBInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RestartDBInstanceOutcomeCallable restartDBInstanceCallable(const Model::RestartDBInstanceRequest& request) const;
RetryPolarxOrderOutcome retryPolarxOrder(const Model::RetryPolarxOrderRequest &request)const;
void retryPolarxOrderAsync(const Model::RetryPolarxOrderRequest& request, const RetryPolarxOrderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RetryPolarxOrderOutcomeCallable retryPolarxOrderCallable(const Model::RetryPolarxOrderRequest& request) const;
SwitchDBInstanceHAOutcome switchDBInstanceHA(const Model::SwitchDBInstanceHARequest &request)const;
void switchDBInstanceHAAsync(const Model::SwitchDBInstanceHARequest& request, const SwitchDBInstanceHAAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
SwitchDBInstanceHAOutcomeCallable switchDBInstanceHACallable(const Model::SwitchDBInstanceHARequest& request) const;
TagResourcesOutcome tagResources(const Model::TagResourcesRequest &request)const;
void tagResourcesAsync(const Model::TagResourcesRequest& request, const TagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
TagResourcesOutcomeCallable tagResourcesCallable(const Model::TagResourcesRequest& request) const;
UntagResourcesOutcome untagResources(const Model::UntagResourcesRequest &request)const;
void untagResourcesAsync(const Model::UntagResourcesRequest& request, const UntagResourcesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UntagResourcesOutcomeCallable untagResourcesCallable(const Model::UntagResourcesRequest& request) const;
UpdateBackupPolicyOutcome updateBackupPolicy(const Model::UpdateBackupPolicyRequest &request)const;
void updateBackupPolicyAsync(const Model::UpdateBackupPolicyRequest& request, const UpdateBackupPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateBackupPolicyOutcomeCallable updateBackupPolicyCallable(const Model::UpdateBackupPolicyRequest& request) const;
UpdateDBInstanceSSLOutcome updateDBInstanceSSL(const Model::UpdateDBInstanceSSLRequest &request)const;
void updateDBInstanceSSLAsync(const Model::UpdateDBInstanceSSLRequest& request, const UpdateDBInstanceSSLAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateDBInstanceSSLOutcomeCallable updateDBInstanceSSLCallable(const Model::UpdateDBInstanceSSLRequest& request) const;
UpdateDBInstanceTDEOutcome updateDBInstanceTDE(const Model::UpdateDBInstanceTDERequest &request)const;
void updateDBInstanceTDEAsync(const Model::UpdateDBInstanceTDERequest& request, const UpdateDBInstanceTDEAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdateDBInstanceTDEOutcomeCallable updateDBInstanceTDECallable(const Model::UpdateDBInstanceTDERequest& request) const;
UpdatePolarDBXInstanceNodeOutcome updatePolarDBXInstanceNode(const Model::UpdatePolarDBXInstanceNodeRequest &request)const;
void updatePolarDBXInstanceNodeAsync(const Model::UpdatePolarDBXInstanceNodeRequest& request, const UpdatePolarDBXInstanceNodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
UpdatePolarDBXInstanceNodeOutcomeCallable updatePolarDBXInstanceNodeCallable(const Model::UpdatePolarDBXInstanceNodeRequest& request) const;

54
polardbx/include/alibabacloud/polardbx/model/AlignStoragePrimaryAzoneRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_ALIGNSTORAGEPRIMARYAZONEREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_ALIGNSTORAGEPRIMARYAZONEREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT AlignStoragePrimaryAzoneRequest : public RpcServiceRequest {
public:
AlignStoragePrimaryAzoneRequest();
~AlignStoragePrimaryAzoneRequest();
std::string getDBInstanceName() const;
void setDBInstanceName(const std::string &dBInstanceName);
std::string getSwitchTimeMode() const;
void setSwitchTimeMode(const std::string &switchTimeMode);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getSwitchTime() const;
void setSwitchTime(const std::string &switchTime);
std::string getStorageInstanceName() const;
void setStorageInstanceName(const std::string &storageInstanceName);
private:
std::string dBInstanceName_;
std::string switchTimeMode_;
std::string regionId_;
std::string switchTime_;
std::string storageInstanceName_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_ALIGNSTORAGEPRIMARYAZONEREQUEST_H_

14
polardbx/include/alibabacloud/polardbx/model/ResetPolarxPgAccountPasswordResult.h → polardbx/include/alibabacloud/polardbx/model/AlignStoragePrimaryAzoneResult.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_RESETPOLARXPGACCOUNTPASSWORDRESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_RESETPOLARXPGACCOUNTPASSWORDRESULT_H_
#ifndef ALIBABACLOUD_POLARDBX_MODEL_ALIGNSTORAGEPRIMARYAZONERESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_ALIGNSTORAGEPRIMARYAZONERESULT_H_
#include <string>
#include <vector>
@@ -29,14 +29,14 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT ResetPolarxPgAccountPasswordResult : public ServiceResult
class ALIBABACLOUD_POLARDBX_EXPORT AlignStoragePrimaryAzoneResult : public ServiceResult
{
public:
ResetPolarxPgAccountPasswordResult();
explicit ResetPolarxPgAccountPasswordResult(const std::string &payload);
~ResetPolarxPgAccountPasswordResult();
AlignStoragePrimaryAzoneResult();
explicit AlignStoragePrimaryAzoneResult(const std::string &payload);
~AlignStoragePrimaryAzoneResult();
std::string getMessage()const;
bool getSuccess()const;
@@ -50,4 +50,4 @@ namespace AlibabaCloud
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_RESETPOLARXPGACCOUNTPASSWORDRESULT_H_
#endif // !ALIBABACLOUD_POLARDBX_MODEL_ALIGNSTORAGEPRIMARYAZONERESULT_H_

45
polardbx/include/alibabacloud/polardbx/model/AllocateColdDataVolumeRequest.h Normal file
View File

@@ -0,0 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_ALLOCATECOLDDATAVOLUMEREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_ALLOCATECOLDDATAVOLUMEREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT AllocateColdDataVolumeRequest : public RpcServiceRequest {
public:
AllocateColdDataVolumeRequest();
~AllocateColdDataVolumeRequest();
std::string getDBInstanceName() const;
void setDBInstanceName(const std::string &dBInstanceName);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
private:
std::string dBInstanceName_;
std::string regionId_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_ALLOCATECOLDDATAVOLUMEREQUEST_H_

16
polardbx/include/alibabacloud/polardbx/model/CheckHealthResult.h → polardbx/include/alibabacloud/polardbx/model/AllocateColdDataVolumeResult.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_CHECKHEALTHRESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_CHECKHEALTHRESULT_H_
#ifndef ALIBABACLOUD_POLARDBX_MODEL_ALLOCATECOLDDATAVOLUMERESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_ALLOCATECOLDDATAVOLUMERESULT_H_
#include <string>
#include <vector>
@@ -29,23 +29,21 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT CheckHealthResult : public ServiceResult
class ALIBABACLOUD_POLARDBX_EXPORT AllocateColdDataVolumeResult : public ServiceResult
{
public:
CheckHealthResult();
explicit CheckHealthResult(const std::string &payload);
~CheckHealthResult();
std::string getStatus()const;
AllocateColdDataVolumeResult();
explicit AllocateColdDataVolumeResult(const std::string &payload);
~AllocateColdDataVolumeResult();
protected:
void parse(const std::string &payload);
private:
std::string status_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_CHECKHEALTHRESULT_H_
#endif // !ALIBABACLOUD_POLARDBX_MODEL_ALLOCATECOLDDATAVOLUMERESULT_H_

113
polardbx/include/alibabacloud/polardbx/model/AllocateInstancePublicConnectionRequest.h
View File

@@ -1,72 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_ALLOCATEINSTANCEPUBLICCONNECTIONREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_ALLOCATEINSTANCEPUBLICCONNECTIONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT AllocateInstancePublicConnectionRequest : public RpcServiceRequest
{
public:
AllocateInstancePublicConnectionRequest();
~AllocateInstancePublicConnectionRequest();
std::string getDBInstanceName()const;
void setDBInstanceName(const std::string& dBInstanceName);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getConnectionStringPrefix()const;
void setConnectionStringPrefix(const std::string& connectionStringPrefix);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getPort()const;
void setPort(const std::string& port);
private:
std::string dBInstanceName_;
long resourceOwnerId_;
std::string connectionStringPrefix_;
std::string accessKeyId_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string port_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_ALLOCATEINSTANCEPUBLICCONNECTIONREQUEST_H_
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_ALLOCATEINSTANCEPUBLICCONNECTIONREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_ALLOCATEINSTANCEPUBLICCONNECTIONREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT AllocateInstancePublicConnectionRequest : public RpcServiceRequest {
public:
AllocateInstancePublicConnectionRequest();
~AllocateInstancePublicConnectionRequest();
std::string getDBInstanceName() const;
void setDBInstanceName(const std::string &dBInstanceName);
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getConnectionStringPrefix() const;
void setConnectionStringPrefix(const std::string &connectionStringPrefix);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
std::string getPort() const;
void setPort(const std::string &port);
private:
std::string dBInstanceName_;
long resourceOwnerId_;
std::string connectionStringPrefix_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
std::string port_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_ALLOCATEINSTANCEPUBLICCONNECTIONREQUEST_H_

45
polardbx/include/alibabacloud/polardbx/model/CancelActiveOperationTasksRequest.h Normal file
View File

@@ -0,0 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_CANCELACTIVEOPERATIONTASKSREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_CANCELACTIVEOPERATIONTASKSREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT CancelActiveOperationTasksRequest : public RpcServiceRequest {
public:
CancelActiveOperationTasksRequest();
~CancelActiveOperationTasksRequest();
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getIds() const;
void setIds(const std::string &ids);
private:
std::string regionId_;
std::string ids_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_CANCELACTIVEOPERATIONTASKSREQUEST_H_

51
polardbx/include/alibabacloud/polardbx/model/CancelActiveOperationTasksResult.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_CANCELACTIVEOPERATIONTASKSRESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_CANCELACTIVEOPERATIONTASKSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT CancelActiveOperationTasksResult : public ServiceResult
{
public:
CancelActiveOperationTasksResult();
explicit CancelActiveOperationTasksResult(const std::string &payload);
~CancelActiveOperationTasksResult();
std::string getIds()const;
protected:
void parse(const std::string &payload);
private:
std::string ids_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_CANCELACTIVEOPERATIONTASKSRESULT_H_

54
polardbx/include/alibabacloud/polardbx/model/CancelPolarxOrderRequest.h
View File

@@ -1,54 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_CANCELPOLARXORDERREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_CANCELPOLARXORDERREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT CancelPolarxOrderRequest : public RpcServiceRequest
{
public:
CancelPolarxOrderRequest();
~CancelPolarxOrderRequest();
std::string getDBInstanceName()const;
void setDBInstanceName(const std::string& dBInstanceName);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getScaleOutToken()const;
void setScaleOutToken(const std::string& scaleOutToken);
private:
std::string dBInstanceName_;
std::string regionId_;
std::string scaleOutToken_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_CANCELPOLARXORDERREQUEST_H_

51
polardbx/include/alibabacloud/polardbx/model/ChangeResourceGroupRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_CHANGERESOURCEGROUPREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_CHANGERESOURCEGROUPREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT ChangeResourceGroupRequest : public RpcServiceRequest {
public:
ChangeResourceGroupRequest();
~ChangeResourceGroupRequest();
std::string getResourceId() const;
void setResourceId(const std::string &resourceId);
std::string getResourceType() const;
void setResourceType(const std::string &resourceType);
std::string getNewResourceGroupId() const;
void setNewResourceGroupId(const std::string &newResourceGroupId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
private:
std::string resourceId_;
std::string resourceType_;
std::string newResourceGroupId_;
std::string regionId_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_CHANGERESOURCEGROUPREQUEST_H_

14
polardbx/include/alibabacloud/polardbx/model/CancelPolarxOrderResult.h → polardbx/include/alibabacloud/polardbx/model/ChangeResourceGroupResult.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_CANCELPOLARXORDERRESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_CANCELPOLARXORDERRESULT_H_
#ifndef ALIBABACLOUD_POLARDBX_MODEL_CHANGERESOURCEGROUPRESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_CHANGERESOURCEGROUPRESULT_H_
#include <string>
#include <vector>
@@ -29,14 +29,14 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT CancelPolarxOrderResult : public ServiceResult
class ALIBABACLOUD_POLARDBX_EXPORT ChangeResourceGroupResult : public ServiceResult
{
public:
CancelPolarxOrderResult();
explicit CancelPolarxOrderResult(const std::string &payload);
~CancelPolarxOrderResult();
ChangeResourceGroupResult();
explicit ChangeResourceGroupResult(const std::string &payload);
~ChangeResourceGroupResult();
protected:
void parse(const std::string &payload);
@@ -46,4 +46,4 @@ namespace AlibabaCloud
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_CANCELPOLARXORDERRESULT_H_
#endif // !ALIBABACLOUD_POLARDBX_MODEL_CHANGERESOURCEGROUPRESULT_H_

48
polardbx/include/alibabacloud/polardbx/model/CheckCloudResourceAuthorizedRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_CHECKCLOUDRESOURCEAUTHORIZEDREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_CHECKCLOUDRESOURCEAUTHORIZEDREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT CheckCloudResourceAuthorizedRequest : public RpcServiceRequest {
public:
CheckCloudResourceAuthorizedRequest();
~CheckCloudResourceAuthorizedRequest();
std::string getDBInstanceName() const;
void setDBInstanceName(const std::string &dBInstanceName);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getRoleArn() const;
void setRoleArn(const std::string &roleArn);
private:
std::string dBInstanceName_;
std::string regionId_;
std::string roleArn_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_CHECKCLOUDRESOURCEAUTHORIZEDREQUEST_H_

21
polardbx/include/alibabacloud/polardbx/model/ModifyDBInstanceMaintainTimeResult.h → polardbx/include/alibabacloud/polardbx/model/CheckCloudResourceAuthorizedResult.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_MODIFYDBINSTANCEMAINTAINTIMERESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_MODIFYDBINSTANCEMAINTAINTIMERESULT_H_
#ifndef ALIBABACLOUD_POLARDBX_MODEL_CHECKCLOUDRESOURCEAUTHORIZEDRESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_CHECKCLOUDRESOURCEAUTHORIZEDRESULT_H_
#include <string>
#include <vector>
@@ -29,21 +29,28 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT ModifyDBInstanceMaintainTimeResult : public ServiceResult
class ALIBABACLOUD_POLARDBX_EXPORT CheckCloudResourceAuthorizedResult : public ServiceResult
{
public:
struct Data
{
std::string authorizationState;
std::string roleArn;
};
ModifyDBInstanceMaintainTimeResult();
explicit ModifyDBInstanceMaintainTimeResult(const std::string &payload);
~ModifyDBInstanceMaintainTimeResult();
CheckCloudResourceAuthorizedResult();
explicit CheckCloudResourceAuthorizedResult(const std::string &payload);
~CheckCloudResourceAuthorizedResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_MODIFYDBINSTANCEMAINTAINTIMERESULT_H_
#endif // !ALIBABACLOUD_POLARDBX_MODEL_CHECKCLOUDRESOURCEAUTHORIZEDRESULT_H_

45
polardbx/include/alibabacloud/polardbx/model/CheckHealthRequest.h
View File

@@ -1,45 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_CHECKHEALTHREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_CHECKHEALTHREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT CheckHealthRequest : public RpcServiceRequest
{
public:
CheckHealthRequest();
~CheckHealthRequest();
private:
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_CHECKHEALTHREQUEST_H_

110
polardbx/include/alibabacloud/polardbx/model/CreateAccountRequest.h
View File

@@ -1,66 +1,66 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_CREATEACCOUNTREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_CREATEACCOUNTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT CreateAccountRequest : public RpcServiceRequest
{
public:
CreateAccountRequest();
~CreateAccountRequest();
std::string getDBInstanceName()const;
void setDBInstanceName(const std::string& dBInstanceName);
std::string getAccountDescription()const;
void setAccountDescription(const std::string& accountDescription);
std::string getAccountPrivilege()const;
void setAccountPrivilege(const std::string& accountPrivilege);
std::string getAccountPassword()const;
void setAccountPassword(const std::string& accountPassword);
std::string getAccountName()const;
void setAccountName(const std::string& accountName);
std::string getDBName()const;
void setDBName(const std::string& dBName);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
private:
std::string dBInstanceName_;
std::string accountDescription_;
std::string accountPrivilege_;
std::string accountPassword_;
std::string accountName_;
std::string dBName_;
std::string regionId_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_CREATEACCOUNTREQUEST_H_
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_CREATEACCOUNTREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_CREATEACCOUNTREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT CreateAccountRequest : public RpcServiceRequest {
public:
CreateAccountRequest();
~CreateAccountRequest();
std::string getDBInstanceName() const;
void setDBInstanceName(const std::string &dBInstanceName);
std::string getSecurityAccountPassword() const;
void setSecurityAccountPassword(const std::string &securityAccountPassword);
std::string getAccountDescription() const;
void setAccountDescription(const std::string &accountDescription);
std::string getAccountPrivilege() const;
void setAccountPrivilege(const std::string &accountPrivilege);
std::string getAccountPassword() const;
void setAccountPassword(const std::string &accountPassword);
std::string getAccountName() const;
void setAccountName(const std::string &accountName);
std::string getDBName() const;
void setDBName(const std::string &dBName);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getSecurityAccountName() const;
void setSecurityAccountName(const std::string &securityAccountName);
private:
std::string dBInstanceName_;
std::string securityAccountPassword_;
std::string accountDescription_;
std::string accountPrivilege_;
std::string accountPassword_;
std::string accountName_;
std::string dBName_;
std::string regionId_;
std::string securityAccountName_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_CREATEACCOUNTREQUEST_H_

48
polardbx/include/alibabacloud/polardbx/model/CreateBackupRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_CREATEBACKUPREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_CREATEBACKUPREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT CreateBackupRequest : public RpcServiceRequest {
public:
CreateBackupRequest();
~CreateBackupRequest();
std::string getDBInstanceName() const;
void setDBInstanceName(const std::string &dBInstanceName);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getBackupType() const;
void setBackupType(const std::string &backupType);
private:
std::string dBInstanceName_;
std::string regionId_;
std::string backupType_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_CREATEBACKUPREQUEST_H_

59
polardbx/include/alibabacloud/polardbx/model/CreateBackupResult.h Normal file
View File

@@ -0,0 +1,59 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_CREATEBACKUPRESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_CREATEBACKUPRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT CreateBackupResult : public ServiceResult
{
public:
struct Account
{
long backupSetId;
};
CreateBackupResult();
explicit CreateBackupResult(const std::string &payload);
~CreateBackupResult();
std::string getMessage()const;
std::vector<Account> getData()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
std::vector<Account> data_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_CREATEBACKUPRESULT_H_

188
polardbx/include/alibabacloud/polardbx/model/CreateDBInstanceRequest.h
View File

@@ -1,93 +1,117 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_CREATEDBINSTANCEREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_CREATEDBINSTANCEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT CreateDBInstanceRequest : public RpcServiceRequest
{
public:
CreateDBInstanceRequest();
~CreateDBInstanceRequest();
std::string getNetworkType()const;
void setNetworkType(const std::string& networkType);
std::string getEngineVersion()const;
void setEngineVersion(const std::string& engineVersion);
std::string getResourceGroupId()const;
void setResourceGroupId(const std::string& resourceGroupId);
std::string getDBNodeClass()const;
void setDBNodeClass(const std::string& dBNodeClass);
std::string getPeriod()const;
void setPeriod(const std::string& period);
bool getIsReadDBInstance()const;
void setIsReadDBInstance(bool isReadDBInstance);
std::string getVSwitchId()const;
void setVSwitchId(const std::string& vSwitchId);
bool getAutoRenew()const;
void setAutoRenew(bool autoRenew);
std::string getZoneId()const;
void setZoneId(const std::string& zoneId);
std::string getPrimaryDBInstanceName()const;
void setPrimaryDBInstanceName(const std::string& primaryDBInstanceName);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
int getDBNodeCount()const;
void setDBNodeCount(int dBNodeCount);
int getUsedTime()const;
void setUsedTime(int usedTime);
std::string getVPCId()const;
void setVPCId(const std::string& vPCId);
std::string getPayType()const;
void setPayType(const std::string& payType);
private:
std::string networkType_;
std::string engineVersion_;
std::string resourceGroupId_;
std::string dBNodeClass_;
std::string period_;
bool isReadDBInstance_;
std::string vSwitchId_;
bool autoRenew_;
std::string zoneId_;
std::string primaryDBInstanceName_;
std::string clientToken_;
std::string regionId_;
int dBNodeCount_;
int usedTime_;
std::string vPCId_;
std::string payType_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_CREATEDBINSTANCEREQUEST_H_
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_CREATEDBINSTANCEREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_CREATEDBINSTANCEREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT CreateDBInstanceRequest : public RpcServiceRequest {
public:
CreateDBInstanceRequest();
~CreateDBInstanceRequest();
std::string getNetworkType() const;
void setNetworkType(const std::string &networkType);
std::string getEngineVersion() const;
void setEngineVersion(const std::string &engineVersion);
std::string getTertiaryZone() const;
void setTertiaryZone(const std::string &tertiaryZone);
std::string getCnClass() const;
void setCnClass(const std::string &cnClass);
std::string getResourceGroupId() const;
void setResourceGroupId(const std::string &resourceGroupId);
std::string getDBNodeClass() const;
void setDBNodeClass(const std::string &dBNodeClass);
std::string getSecondaryZone() const;
void setSecondaryZone(const std::string &secondaryZone);
std::string getPeriod() const;
void setPeriod(const std::string &period);
bool getIsReadDBInstance() const;
void setIsReadDBInstance(bool isReadDBInstance);
std::string getVSwitchId() const;
void setVSwitchId(const std::string &vSwitchId);
bool getAutoRenew() const;
void setAutoRenew(bool autoRenew);
std::string getZoneId() const;
void setZoneId(const std::string &zoneId);
std::string getCNNodeCount() const;
void setCNNodeCount(const std::string &cNNodeCount);
std::string getPrimaryDBInstanceName() const;
void setPrimaryDBInstanceName(const std::string &primaryDBInstanceName);
std::string getTopologyType() const;
void setTopologyType(const std::string &topologyType);
std::string getClientToken() const;
void setClientToken(const std::string &clientToken);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
bool getIsColumnarReadDBInstance() const;
void setIsColumnarReadDBInstance(bool isColumnarReadDBInstance);
std::string getDNNodeCount() const;
void setDNNodeCount(const std::string &dNNodeCount);
int getDBNodeCount() const;
void setDBNodeCount(int dBNodeCount);
std::string getDnClass() const;
void setDnClass(const std::string &dnClass);
int getUsedTime() const;
void setUsedTime(int usedTime);
std::string getPrimaryZone() const;
void setPrimaryZone(const std::string &primaryZone);
std::string getSeries() const;
void setSeries(const std::string &series);
std::string getVPCId() const;
void setVPCId(const std::string &vPCId);
std::string getPayType() const;
void setPayType(const std::string &payType);
private:
std::string networkType_;
std::string engineVersion_;
std::string tertiaryZone_;
std::string cnClass_;
std::string resourceGroupId_;
std::string dBNodeClass_;
std::string secondaryZone_;
std::string period_;
bool isReadDBInstance_;
std::string vSwitchId_;
bool autoRenew_;
std::string zoneId_;
std::string cNNodeCount_;
std::string primaryDBInstanceName_;
std::string topologyType_;
std::string clientToken_;
std::string regionId_;
bool isColumnarReadDBInstance_;
std::string dNNodeCount_;
int dBNodeCount_;
std::string dnClass_;
int usedTime_;
std::string primaryZone_;
std::string series_;
std::string vPCId_;
std::string payType_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_CREATEDBINSTANCEREQUEST_H_

116
polardbx/include/alibabacloud/polardbx/model/CreateDBRequest.h
View File

@@ -1,66 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_CREATEDBREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_CREATEDBREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT CreateDBRequest : public RpcServiceRequest
{
public:
CreateDBRequest();
~CreateDBRequest();
std::string getDBInstanceName()const;
void setDBInstanceName(const std::string& dBInstanceName);
std::string getCharset()const;
void setCharset(const std::string& charset);
std::string getAccountPrivilege()const;
void setAccountPrivilege(const std::string& accountPrivilege);
std::string getAccountName()const;
void setAccountName(const std::string& accountName);
std::string getDbName()const;
void setDbName(const std::string& dbName);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getDbDescription()const;
void setDbDescription(const std::string& dbDescription);
private:
std::string dBInstanceName_;
std::string charset_;
std::string accountPrivilege_;
std::string accountName_;
std::string dbName_;
std::string regionId_;
std::string dbDescription_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_CREATEDBREQUEST_H_
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_CREATEDBREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_CREATEDBREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT CreateDBRequest : public RpcServiceRequest {
public:
CreateDBRequest();
~CreateDBRequest();
std::string getDBInstanceName() const;
void setDBInstanceName(const std::string &dBInstanceName);
std::string getCharset() const;
void setCharset(const std::string &charset);
std::string getSecurityAccountPassword() const;
void setSecurityAccountPassword(const std::string &securityAccountPassword);
std::string getAccountPrivilege() const;
void setAccountPrivilege(const std::string &accountPrivilege);
std::string getMode() const;
void setMode(const std::string &mode);
std::string getAccountName() const;
void setAccountName(const std::string &accountName);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getSecurityAccountName() const;
void setSecurityAccountName(const std::string &securityAccountName);
std::string getDbDescription() const;
void setDbDescription(const std::string &dbDescription);
std::string getDbName() const;
void setDbName(const std::string &dbName);
std::string getStoragePoolName() const;
void setStoragePoolName(const std::string &storagePoolName);
private:
std::string dBInstanceName_;
std::string charset_;
std::string securityAccountPassword_;
std::string accountPrivilege_;
std::string mode_;
std::string accountName_;
std::string regionId_;
std::string securityAccountName_;
std::string dbDescription_;
std::string dbName_;
std::string storagePoolName_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_CREATEDBREQUEST_H_

99
polardbx/include/alibabacloud/polardbx/model/CreatePolarxInstanceRequest.h
View File

@@ -1,99 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_CREATEPOLARXINSTANCEREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_CREATEPOLARXINSTANCEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT CreatePolarxInstanceRequest : public RpcServiceRequest
{
public:
CreatePolarxInstanceRequest();
~CreatePolarxInstanceRequest();
bool getIsAutoRenew()const;
void setIsAutoRenew(bool isAutoRenew);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getDescription()const;
void setDescription(const std::string& description);
std::string getType()const;
void setType(const std::string& type);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
int getDuration()const;
void setDuration(int duration);
bool getIsHa()const;
void setIsHa(bool isHa);
int getMySQLVersion()const;
void setMySQLVersion(int mySQLVersion);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getInstanceSeries()const;
void setInstanceSeries(const std::string& instanceSeries);
std::string getMasterInstId()const;
void setMasterInstId(const std::string& masterInstId);
int getQuantity()const;
void setQuantity(int quantity);
std::string getSpecification()const;
void setSpecification(const std::string& specification);
std::string getVswitchId()const;
void setVswitchId(const std::string& vswitchId);
std::string getVpcId()const;
void setVpcId(const std::string& vpcId);
std::string getZoneId()const;
void setZoneId(const std::string& zoneId);
std::string getPayType()const;
void setPayType(const std::string& payType);
std::string getPricingCycle()const;
void setPricingCycle(const std::string& pricingCycle);
private:
bool isAutoRenew_;
std::string clientToken_;
std::string description_;
std::string type_;
std::string accessKeyId_;
int duration_;
bool isHa_;
int mySQLVersion_;
std::string regionId_;
std::string instanceSeries_;
std::string masterInstId_;
int quantity_;
std::string specification_;
std::string vswitchId_;
std::string vpcId_;
std::string zoneId_;
std::string payType_;
std::string pricingCycle_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_CREATEPOLARXINSTANCEREQUEST_H_

54
polardbx/include/alibabacloud/polardbx/model/CreatePolarxOrderRequest.h
View File

@@ -1,54 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_CREATEPOLARXORDERREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_CREATEPOLARXORDERREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT CreatePolarxOrderRequest : public RpcServiceRequest
{
public:
CreatePolarxOrderRequest();
~CreatePolarxOrderRequest();
std::string getDBInstanceName()const;
void setDBInstanceName(const std::string& dBInstanceName);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getNodeCount()const;
void setNodeCount(const std::string& nodeCount);
private:
std::string dBInstanceName_;
std::string regionId_;
std::string nodeCount_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_CREATEPOLARXORDERREQUEST_H_

92
polardbx/include/alibabacloud/polardbx/model/CreateSuperAccountRequest.h
View File

@@ -1,60 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_CREATESUPERACCOUNTREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_CREATESUPERACCOUNTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT CreateSuperAccountRequest : public RpcServiceRequest
{
public:
CreateSuperAccountRequest();
~CreateSuperAccountRequest();
std::string getDBInstanceName()const;
void setDBInstanceName(const std::string& dBInstanceName);
std::string getAccountDescription()const;
void setAccountDescription(const std::string& accountDescription);
std::string getAccountPassword()const;
void setAccountPassword(const std::string& accountPassword);
std::string getAccountName()const;
void setAccountName(const std::string& accountName);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
private:
std::string dBInstanceName_;
std::string accountDescription_;
std::string accountPassword_;
std::string accountName_;
std::string regionId_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_CREATESUPERACCOUNTREQUEST_H_
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_CREATESUPERACCOUNTREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_CREATESUPERACCOUNTREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT CreateSuperAccountRequest : public RpcServiceRequest {
public:
CreateSuperAccountRequest();
~CreateSuperAccountRequest();
std::string getDBInstanceName() const;
void setDBInstanceName(const std::string &dBInstanceName);
std::string getAccountDescription() const;
void setAccountDescription(const std::string &accountDescription);
std::string getAccountPassword() const;
void setAccountPassword(const std::string &accountPassword);
std::string getAccountName() const;
void setAccountName(const std::string &accountName);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
private:
std::string dBInstanceName_;
std::string accountDescription_;
std::string accountPassword_;
std::string accountName_;
std::string regionId_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_CREATESUPERACCOUNTREQUEST_H_

86
polardbx/include/alibabacloud/polardbx/model/DeleteAccountRequest.h
View File

@@ -1,54 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DELETEACCOUNTREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DELETEACCOUNTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT DeleteAccountRequest : public RpcServiceRequest
{
public:
DeleteAccountRequest();
~DeleteAccountRequest();
std::string getDBInstanceName()const;
void setDBInstanceName(const std::string& dBInstanceName);
std::string getAccountName()const;
void setAccountName(const std::string& accountName);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
private:
std::string dBInstanceName_;
std::string accountName_;
std::string regionId_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DELETEACCOUNTREQUEST_H_
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DELETEACCOUNTREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DELETEACCOUNTREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT DeleteAccountRequest : public RpcServiceRequest {
public:
DeleteAccountRequest();
~DeleteAccountRequest();
std::string getDBInstanceName() const;
void setDBInstanceName(const std::string &dBInstanceName);
std::string getSecurityAccountPassword() const;
void setSecurityAccountPassword(const std::string &securityAccountPassword);
std::string getAccountName() const;
void setAccountName(const std::string &accountName);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getSecurityAccountName() const;
void setSecurityAccountName(const std::string &securityAccountName);
private:
std::string dBInstanceName_;
std::string securityAccountPassword_;
std::string accountName_;
std::string regionId_;
std::string securityAccountName_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DELETEACCOUNTREQUEST_H_

74
polardbx/include/alibabacloud/polardbx/model/DeleteDBInstanceRequest.h
View File

@@ -1,51 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DELETEDBINSTANCEREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DELETEDBINSTANCEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT DeleteDBInstanceRequest : public RpcServiceRequest
{
public:
DeleteDBInstanceRequest();
~DeleteDBInstanceRequest();
std::string getDBInstanceName()const;
void setDBInstanceName(const std::string& dBInstanceName);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
private:
std::string dBInstanceName_;
std::string regionId_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DELETEDBINSTANCEREQUEST_H_
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DELETEDBINSTANCEREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DELETEDBINSTANCEREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT DeleteDBInstanceRequest : public RpcServiceRequest {
public:
DeleteDBInstanceRequest();
~DeleteDBInstanceRequest();
std::string getDBInstanceName() const;
void setDBInstanceName(const std::string &dBInstanceName);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
private:
std::string dBInstanceName_;
std::string regionId_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DELETEDBINSTANCEREQUEST_H_

80
polardbx/include/alibabacloud/polardbx/model/DeleteDBRequest.h
View File

@@ -1,54 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DELETEDBREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DELETEDBREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT DeleteDBRequest : public RpcServiceRequest
{
public:
DeleteDBRequest();
~DeleteDBRequest();
std::string getDBInstanceName()const;
void setDBInstanceName(const std::string& dBInstanceName);
std::string getDbName()const;
void setDbName(const std::string& dbName);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
private:
std::string dBInstanceName_;
std::string dbName_;
std::string regionId_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DELETEDBREQUEST_H_
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DELETEDBREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DELETEDBREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT DeleteDBRequest : public RpcServiceRequest {
public:
DeleteDBRequest();
~DeleteDBRequest();
std::string getDBInstanceName() const;
void setDBInstanceName(const std::string &dBInstanceName);
std::string getDbName() const;
void setDbName(const std::string &dbName);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
private:
std::string dBInstanceName_;
std::string dbName_;
std::string regionId_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DELETEDBREQUEST_H_

83
polardbx/include/alibabacloud/polardbx/model/DescribeAccountListRequest.h
View File

@@ -1,54 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEACCOUNTLISTREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEACCOUNTLISTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT DescribeAccountListRequest : public RpcServiceRequest
{
public:
DescribeAccountListRequest();
~DescribeAccountListRequest();
std::string getDBInstanceName()const;
void setDBInstanceName(const std::string& dBInstanceName);
std::string getAccountName()const;
void setAccountName(const std::string& accountName);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
private:
std::string dBInstanceName_;
std::string accountName_;
std::string regionId_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEACCOUNTLISTREQUEST_H_
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEACCOUNTLISTREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEACCOUNTLISTREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT DescribeAccountListRequest : public RpcServiceRequest {
public:
DescribeAccountListRequest();
~DescribeAccountListRequest();
std::string getDBInstanceName() const;
void setDBInstanceName(const std::string &dBInstanceName);
std::string getAccountType() const;
void setAccountType(const std::string &accountType);
std::string getAccountName() const;
void setAccountName(const std::string &accountName);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
private:
std::string dBInstanceName_;
std::string accountType_;
std::string accountName_;
std::string regionId_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEACCOUNTLISTREQUEST_H_

3
polardbx/include/alibabacloud/polardbx/model/DescribeAccountListResult.h
View File

@@ -37,9 +37,10 @@ namespace AlibabaCloud
std::string accountDescription;
std::string accountPrivilege;
std::string dBName;
std::string gmtCreated;
std::string accountType;
std::string accountName;
std::string dBInstanceName;
std::string accountName;
};

42
polardbx/include/alibabacloud/polardbx/model/DescribeActiveOperationMaintainConfRequest.h Normal file
View File

@@ -0,0 +1,42 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEACTIVEOPERATIONMAINTAINCONFREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEACTIVEOPERATIONMAINTAINCONFREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT DescribeActiveOperationMaintainConfRequest : public RpcServiceRequest {
public:
DescribeActiveOperationMaintainConfRequest();
~DescribeActiveOperationMaintainConfRequest();
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
private:
std::string regionId_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEACTIVEOPERATIONMAINTAINCONFREQUEST_H_

63
polardbx/include/alibabacloud/polardbx/model/DescribeActiveOperationMaintainConfResult.h Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEACTIVEOPERATIONMAINTAINCONFRESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEACTIVEOPERATIONMAINTAINCONFRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT DescribeActiveOperationMaintainConfResult : public ServiceResult
{
public:
struct Config
{
long status;
std::string cycleTime;
std::string cycleType;
std::string createdTime;
std::string maintainEndTime;
std::string modifiedTime;
std::string maintainStartTime;
};
DescribeActiveOperationMaintainConfResult();
explicit DescribeActiveOperationMaintainConfResult(const std::string &payload);
~DescribeActiveOperationMaintainConfResult();
Config getConfig()const;
long getHasConfig()const;
protected:
void parse(const std::string &payload);
private:
Config config_;
long hasConfig_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEACTIVEOPERATIONMAINTAINCONFRESULT_H_

48
polardbx/include/alibabacloud/polardbx/model/DescribeActiveOperationTaskCountRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEACTIVEOPERATIONTASKCOUNTREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEACTIVEOPERATIONTASKCOUNTREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT DescribeActiveOperationTaskCountRequest : public RpcServiceRequest {
public:
DescribeActiveOperationTaskCountRequest();
~DescribeActiveOperationTaskCountRequest();
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getProduct() const;
void setProduct(const std::string &product);
std::string getCategory() const;
void setCategory(const std::string &category);
private:
std::string regionId_;
std::string product_;
std::string category_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEACTIVEOPERATIONTASKCOUNTREQUEST_H_

53
polardbx/include/alibabacloud/polardbx/model/DescribeActiveOperationTaskCountResult.h Normal file
View File

@@ -0,0 +1,53 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEACTIVEOPERATIONTASKCOUNTRESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEACTIVEOPERATIONTASKCOUNTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT DescribeActiveOperationTaskCountResult : public ServiceResult
{
public:
DescribeActiveOperationTaskCountResult();
explicit DescribeActiveOperationTaskCountResult(const std::string &payload);
~DescribeActiveOperationTaskCountResult();
long getNeedPop()const;
long getTaskCount()const;
protected:
void parse(const std::string &payload);
private:
long needPop_;
long taskCount_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEACTIVEOPERATIONTASKCOUNTRESULT_H_

75
polardbx/include/alibabacloud/polardbx/model/DescribeActiveOperationTasksRequest.h Normal file
View File

@@ -0,0 +1,75 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEACTIVEOPERATIONTASKSREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEACTIVEOPERATIONTASKSREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT DescribeActiveOperationTasksRequest : public RpcServiceRequest {
public:
DescribeActiveOperationTasksRequest();
~DescribeActiveOperationTasksRequest();
std::string getProductId() const;
void setProductId(const std::string &productId);
std::string getChangeLevel() const;
void setChangeLevel(const std::string &changeLevel);
long getPageNumber() const;
void setPageNumber(long pageNumber);
std::string getInsName() const;
void setInsName(const std::string &insName);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
long getPageSize() const;
void setPageSize(long pageSize);
std::string getTaskType() const;
void setTaskType(const std::string &taskType);
long getAllowCancel() const;
void setAllowCancel(long allowCancel);
std::string getDbType() const;
void setDbType(const std::string &dbType);
long getAllowChange() const;
void setAllowChange(long allowChange);
std::string getRegion() const;
void setRegion(const std::string &region);
long getStatus() const;
void setStatus(long status);
private:
std::string productId_;
std::string changeLevel_;
long pageNumber_;
std::string insName_;
std::string regionId_;
long pageSize_;
std::string taskType_;
long allowCancel_;
std::string dbType_;
long allowChange_;
std::string region_;
long status_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEACTIVEOPERATIONTASKSREQUEST_H_

87
polardbx/include/alibabacloud/polardbx/model/DescribeActiveOperationTasksResult.h Normal file
View File

@@ -0,0 +1,87 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEACTIVEOPERATIONTASKSRESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEACTIVEOPERATIONTASKSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT DescribeActiveOperationTasksResult : public ServiceResult
{
public:
struct ItemsItem
{
std::string createdTime;
std::string impactEn;
std::string changeLevelZh;
std::string taskTypeZh;
std::string dbVersion;
std::string modifiedTime;
std::string impactZh;
std::string taskTypeEn;
std::string taskType;
std::string switchTime;
std::string impact;
long status;
std::string currentAVZ;
std::string deadline;
std::string startTime;
std::string insName;
std::string changeLevel;
std::string dbType;
std::string insComment;
std::string allowCancel;
std::string changeLevelEn;
std::string allowChange;
std::vector<std::string> subInsNames;
std::string prepareInterval;
std::string region;
long id;
std::string resultInfo;
};
DescribeActiveOperationTasksResult();
explicit DescribeActiveOperationTasksResult(const std::string &payload);
~DescribeActiveOperationTasksResult();
long getTotalRecordCount()const;
long getPageSize()const;
long getPageNumber()const;
std::vector<ItemsItem> getItems()const;
protected:
void parse(const std::string &payload);
private:
long totalRecordCount_;
long pageSize_;
long pageNumber_;
std::vector<ItemsItem> items_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEACTIVEOPERATIONTASKSRESULT_H_

60
polardbx/include/alibabacloud/polardbx/model/DescribeArchiveTableListRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEARCHIVETABLELISTREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEARCHIVETABLELISTREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT DescribeArchiveTableListRequest : public RpcServiceRequest {
public:
DescribeArchiveTableListRequest();
~DescribeArchiveTableListRequest();
std::string getDBInstanceName() const;
void setDBInstanceName(const std::string &dBInstanceName);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
long getPageSize() const;
void setPageSize(long pageSize);
long getPageIndex() const;
void setPageIndex(long pageIndex);
std::string getTableName() const;
void setTableName(const std::string &tableName);
std::string getSchemaName() const;
void setSchemaName(const std::string &schemaName);
std::string getStatus() const;
void setStatus(const std::string &status);
private:
std::string dBInstanceName_;
std::string regionId_;
long pageSize_;
long pageIndex_;
std::string tableName_;
std::string schemaName_;
std::string status_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEARCHIVETABLELISTREQUEST_H_

44
polardbx/include/alibabacloud/polardbx/model/DescribeInstanceDbPerformanceResult.h → polardbx/include/alibabacloud/polardbx/model/DescribeArchiveTableListResult.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEINSTANCEDBPERFORMANCERESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEINSTANCEDBPERFORMANCERESULT_H_
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEARCHIVETABLELISTRESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEARCHIVETABLELISTRESULT_H_
#include <string>
#include <vector>
@@ -29,42 +29,44 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT DescribeInstanceDbPerformanceResult : public ServiceResult
class ALIBABACLOUD_POLARDBX_EXPORT DescribeArchiveTableListResult : public ServiceResult
{
public:
struct Data
{
struct PerformanceItem
struct ArchiveTable
{
struct Point
{
std::string value;
long timestamp;
};
std::string measurement;
std::string metricName;
std::vector<PerformanceItem::Point> points;
std::string tableName;
double spaceSize;
long lastSuccessArchiveTime;
int fileCount;
long createdDate;
std::string schemaName;
std::string archiveStatus;
};
std::vector<PerformanceItem> performanceItems;
int runningCount;
long pageSize;
int pausedCount;
long total;
std::vector<ArchiveTable> tables;
long pageIndex;
int tobeArchivedConut;
int successCount;
};
DescribeInstanceDbPerformanceResult();
explicit DescribeInstanceDbPerformanceResult(const std::string &payload);
~DescribeInstanceDbPerformanceResult();
std::string getMessage()const;
DescribeArchiveTableListResult();
explicit DescribeArchiveTableListResult(const std::string &payload);
~DescribeArchiveTableListResult();
Data getData()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
Data data_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEINSTANCEDBPERFORMANCERESULT_H_
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEARCHIVETABLELISTRESULT_H_

45
polardbx/include/alibabacloud/polardbx/model/DescribeBackupPolicyRequest.h Normal file
View File

@@ -0,0 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEBACKUPPOLICYREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEBACKUPPOLICYREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT DescribeBackupPolicyRequest : public RpcServiceRequest {
public:
DescribeBackupPolicyRequest();
~DescribeBackupPolicyRequest();
std::string getDBInstanceName() const;
void setDBInstanceName(const std::string &dBInstanceName);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
private:
std::string dBInstanceName_;
std::string regionId_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEBACKUPPOLICYREQUEST_H_

77
polardbx/include/alibabacloud/polardbx/model/DescribeBackupPolicyResult.h Normal file
View File

@@ -0,0 +1,77 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEBACKUPPOLICYRESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEBACKUPPOLICYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT DescribeBackupPolicyResult : public ServiceResult
{
public:
struct Account
{
std::string backupPeriod;
int isEnabled;
bool isCrossRegionLogBackupEnabled;
int crossRegionDataBackupRetention;
int backupSetRetention;
std::string backupPlanBegin;
int coldDataBackupInterval;
std::string destCrossRegion;
int removeLogRetention;
int crossRegionLogBackupRetention;
int localLogRetentionNumber;
int coldDataBackupRetention;
int forceCleanOnHighSpaceUsage;
std::string backupWay;
int localLogRetention;
std::string backupType;
bool isCrossRegionDataBackupEnabled;
int logLocalRetentionSpace;
std::string dBInstanceName;
};
DescribeBackupPolicyResult();
explicit DescribeBackupPolicyResult(const std::string &payload);
~DescribeBackupPolicyResult();
std::string getMessage()const;
std::vector<Account> getData()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
std::vector<Account> data_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEBACKUPPOLICYRESULT_H_

60
polardbx/include/alibabacloud/polardbx/model/DescribeBackupSetListRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEBACKUPSETLISTREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEBACKUPSETLISTREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT DescribeBackupSetListRequest : public RpcServiceRequest {
public:
DescribeBackupSetListRequest();
~DescribeBackupSetListRequest();
std::string getDBInstanceName() const;
void setDBInstanceName(const std::string &dBInstanceName);
long getEndTime() const;
void setEndTime(long endTime);
long getStartTime() const;
void setStartTime(long startTime);
std::string getDestCrossRegion() const;
void setDestCrossRegion(const std::string &destCrossRegion);
int getPageNumber() const;
void setPageNumber(int pageNumber);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
int getPageSize() const;
void setPageSize(int pageSize);
private:
std::string dBInstanceName_;
long endTime_;
long startTime_;
std::string destCrossRegion_;
int pageNumber_;
std::string regionId_;
int pageSize_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEBACKUPSETLISTREQUEST_H_

65
polardbx/include/alibabacloud/polardbx/model/DescribeBackupSetListResult.h Normal file
View File

@@ -0,0 +1,65 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEBACKUPSETLISTRESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEBACKUPSETLISTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT DescribeBackupSetListResult : public ServiceResult
{
public:
struct BackupSet
{
int status;
int backupModel;
long endTime;
int backupType;
long beginTime;
long backupSetSize;
long backupSetId;
};
DescribeBackupSetListResult();
explicit DescribeBackupSetListResult(const std::string &payload);
~DescribeBackupSetListResult();
std::string getMessage()const;
std::vector<BackupSet> getData()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
std::vector<BackupSet> data_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEBACKUPSETLISTRESULT_H_

51
polardbx/include/alibabacloud/polardbx/model/DescribeBackupSetRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEBACKUPSETREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEBACKUPSETREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT DescribeBackupSetRequest : public RpcServiceRequest {
public:
DescribeBackupSetRequest();
~DescribeBackupSetRequest();
std::string getDBInstanceName() const;
void setDBInstanceName(const std::string &dBInstanceName);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getBackupSetId() const;
void setBackupSetId(const std::string &backupSetId);
std::string getDestCrossRegion() const;
void setDestCrossRegion(const std::string &destCrossRegion);
private:
std::string dBInstanceName_;
std::string regionId_;
std::string backupSetId_;
std::string destCrossRegion_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEBACKUPSETREQUEST_H_

43
polardbx/include/alibabacloud/polardbx/model/DescribeInstancePerformanceResult.h → polardbx/include/alibabacloud/polardbx/model/DescribeBackupSetResult.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEINSTANCEPERFORMANCERESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEINSTANCEPERFORMANCERESULT_H_
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEBACKUPSETRESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEBACKUPSETRESULT_H_
#include <string>
#include <vector>
@@ -29,42 +29,45 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT DescribeInstancePerformanceResult : public ServiceResult
class ALIBABACLOUD_POLARDBX_EXPORT DescribeBackupSetResult : public ServiceResult
{
public:
struct Data
struct BackupSet
{
struct PerformanceItem
struct OSS
{
struct Point
{
std::string value;
long timestamp;
};
std::string measurement;
std::string metricName;
std::vector<PerformanceItem::Point> points;
std::string downloadLink;
std::string linkExpiredTime;
std::string backupSetFile;
std::string intranetDownloadLink;
};
std::vector<PerformanceItem> performanceItems;
int status;
int backupModel;
long endTime;
std::vector<BackupSet::OSS> oSSList;
int backupType;
long beginTime;
long backupSetSize;
long backupSetId;
};
DescribeInstancePerformanceResult();
explicit DescribeInstancePerformanceResult(const std::string &payload);
~DescribeInstancePerformanceResult();
DescribeBackupSetResult();
explicit DescribeBackupSetResult(const std::string &payload);
~DescribeBackupSetResult();
std::string getMessage()const;
Data getData()const;
std::vector<BackupSet> getData()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
Data data_;
std::vector<BackupSet> data_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEINSTANCEPERFORMANCERESULT_H_
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEBACKUPSETRESULT_H_

60
polardbx/include/alibabacloud/polardbx/model/DescribeBinaryLogListRequest.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEBINARYLOGLISTREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEBINARYLOGLISTREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT DescribeBinaryLogListRequest : public RpcServiceRequest {
public:
DescribeBinaryLogListRequest();
~DescribeBinaryLogListRequest();
std::string getDBInstanceName() const;
void setDBInstanceName(const std::string &dBInstanceName);
std::string getStartTime() const;
void setStartTime(const std::string &startTime);
int getPageNumber() const;
void setPageNumber(int pageNumber);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
int getPageSize() const;
void setPageSize(int pageSize);
std::string getEndTime() const;
void setEndTime(const std::string &endTime);
std::string getInstanceName() const;
void setInstanceName(const std::string &instanceName);
private:
std::string dBInstanceName_;
std::string startTime_;
int pageNumber_;
std::string regionId_;
int pageSize_;
std::string endTime_;
std::string instanceName_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEBINARYLOGLISTREQUEST_H_

38
polardbx/include/alibabacloud/polardbx/model/DescribeModifyParameterLogResult.h → polardbx/include/alibabacloud/polardbx/model/DescribeBinaryLogListResult.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEMODIFYPARAMETERLOGRESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEMODIFYPARAMETERLOGRESULT_H_
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEBINARYLOGLISTRESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEBINARYLOGLISTRESULT_H_
#include <string>
#include <vector>
@@ -29,35 +29,43 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT DescribeModifyParameterLogResult : public ServiceResult
class ALIBABACLOUD_POLARDBX_EXPORT DescribeBinaryLogListResult : public ServiceResult
{
public:
struct ChangeLog
struct LogListItem
{
std::string newParameterValue;
std::string changeTime;
int synced;
std::string oldParameterValue;
std::string parameterName;
std::string downloadLink;
long logSize;
std::string createdTime;
std::string endTime;
std::string modifiedTime;
std::string uploadHost;
int uploadStatus;
std::string fileName;
std::string beginTime;
long id;
int purgeStatus;
};
DescribeModifyParameterLogResult();
explicit DescribeModifyParameterLogResult(const std::string &payload);
~DescribeModifyParameterLogResult();
std::vector<ChangeLog> getChangeLogs()const;
DescribeBinaryLogListResult();
explicit DescribeBinaryLogListResult(const std::string &payload);
~DescribeBinaryLogListResult();
std::vector<LogListItem> getLogList()const;
int getPageSize()const;
int getPageNumber()const;
int getTotalNumber()const;
protected:
void parse(const std::string &payload);
private:
std::vector<ChangeLog> changeLogs_;
std::vector<LogListItem> logList_;
int pageSize_;
int pageNumber_;
int totalNumber_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEMODIFYPARAMETERLOGRESULT_H_
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEBINARYLOGLISTRESULT_H_

74
polardbx/include/alibabacloud/polardbx/model/DescribeCharacterSetRequest.h
View File

@@ -1,51 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBECHARACTERSETREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBECHARACTERSETREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT DescribeCharacterSetRequest : public RpcServiceRequest
{
public:
DescribeCharacterSetRequest();
~DescribeCharacterSetRequest();
std::string getDBInstanceName()const;
void setDBInstanceName(const std::string& dBInstanceName);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
private:
std::string dBInstanceName_;
std::string regionId_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBECHARACTERSETREQUEST_H_
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBECHARACTERSETREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBECHARACTERSETREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT DescribeCharacterSetRequest : public RpcServiceRequest {
public:
DescribeCharacterSetRequest();
~DescribeCharacterSetRequest();
std::string getDBInstanceName() const;
void setDBInstanceName(const std::string &dBInstanceName);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
private:
std::string dBInstanceName_;
std::string regionId_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBECHARACTERSETREQUEST_H_

45
polardbx/include/alibabacloud/polardbx/model/DescribeColdDataBasicInfoRequest.h Normal file
View File

@@ -0,0 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBECOLDDATABASICINFOREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBECOLDDATABASICINFOREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT DescribeColdDataBasicInfoRequest : public RpcServiceRequest {
public:
DescribeColdDataBasicInfoRequest();
~DescribeColdDataBasicInfoRequest();
std::string getDBInstanceName() const;
void setDBInstanceName(const std::string &dBInstanceName);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
private:
std::string dBInstanceName_;
std::string regionId_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBECOLDDATABASICINFOREQUEST_H_

64
polardbx/include/alibabacloud/polardbx/model/DescribeColdDataBasicInfoResult.h Normal file
View File

@@ -0,0 +1,64 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBECOLDDATABASICINFORESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBECOLDDATABASICINFORESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT DescribeColdDataBasicInfoResult : public ServiceResult
{
public:
struct Data
{
std::string volumeName;
double writeAccessNum;
int backupSetCount;
double currentSpaceSize;
bool enableStatus;
std::string dataRedundancyType;
long readAccessNum;
std::string regionId;
std::string cloudProduct;
double backupSetSpaceSize;
};
DescribeColdDataBasicInfoResult();
explicit DescribeColdDataBasicInfoResult(const std::string &payload);
~DescribeColdDataBasicInfoResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBECOLDDATABASICINFORESULT_H_

77
polardbx/include/alibabacloud/polardbx/model/DescribeDBInstanceAttributeRequest.h
View File

@@ -1,51 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCEATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCEATTRIBUTEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT DescribeDBInstanceAttributeRequest : public RpcServiceRequest
{
public:
DescribeDBInstanceAttributeRequest();
~DescribeDBInstanceAttributeRequest();
std::string getDBInstanceName()const;
void setDBInstanceName(const std::string& dBInstanceName);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
private:
std::string dBInstanceName_;
std::string regionId_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCEATTRIBUTEREQUEST_H_
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCEATTRIBUTEREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCEATTRIBUTEREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT DescribeDBInstanceAttributeRequest : public RpcServiceRequest {
public:
DescribeDBInstanceAttributeRequest();
~DescribeDBInstanceAttributeRequest();
std::string getDBInstanceName() const;
void setDBInstanceName(const std::string &dBInstanceName);
std::string getResourceGroupId() const;
void setResourceGroupId(const std::string &resourceGroupId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
private:
std::string dBInstanceName_;
std::string resourceGroupId_;
std::string regionId_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCEATTRIBUTEREQUEST_H_

55
polardbx/include/alibabacloud/polardbx/model/DescribeDBInstanceAttributeResult.h
View File

@@ -38,48 +38,75 @@ namespace AlibabaCloud
{
std::string nodeClass;
std::string zoneId;
std::string computeNodeId;
std::string id;
std::string regionId;
std::string dataNodeId;
};
struct ConnAddr
{
std::string type;
std::string vPCId;
std::string port;
std::string vSwitchId;
long port;
std::string vpcInstanceId;
std::string connectionString;
};
std::string description;
struct TagSetItem
{
std::string value;
std::string key;
};
std::string expireDate;
std::string resourceGroupId;
bool differentDNSpec;
std::vector<std::string> readDBInstances;
std::vector<ConnAddr> connAddrs;
std::string port;
std::string dBInstanceType;
std::string cnNodeClassCode;
std::string dBType;
std::string tertiaryZone;
std::string dBVersion;
std::string maintainEndTime;
std::vector<std::string> columnarReadDBInstances;
std::vector<DBNode> dBNodes;
std::string network;
int dBNodeCount;
std::string commodityCode;
std::string primaryZone;
std::string engine;
std::string maintainStartTime;
std::string status;
std::string zoneId;
std::string vPCId;
std::string createTime;
std::string vSwitchId;
std::string minorVersion;
bool canNotCreateColumnar;
std::string expired;
std::string latestMinorVersion;
std::string payType;
std::string lockMode;
std::string storageUsed;
std::string dBNodeClass;
std::string type;
std::string regionId;
long storageUsed;
std::vector<std::string> lTSVersions;
std::string dnNodeClassCode;
std::string id;
std::string connectionString;
std::string topologyType;
std::string description;
std::vector<ConnAddr> connAddrs;
std::string maintainEndTime;
int dnNodeCount;
std::vector<TagSetItem> tagSet;
std::string rightsSeparationStatus;
std::string commodityCode;
std::string maintainStartTime;
std::string zoneId;
std::string createTime;
std::string minorVersion;
std::string latestMinorVersion;
bool rightsSeparationEnabled;
std::string dBNodeClass;
int cnNodeCount;
std::string secondaryZone;
std::string series;
std::string type;
std::string columnarInstanceName;
std::string regionId;
int kindCode;
};

80
polardbx/include/alibabacloud/polardbx/model/DescribeDBInstanceConfigRequest.h
View File

@@ -1,54 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCECONFIGREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCECONFIGREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT DescribeDBInstanceConfigRequest : public RpcServiceRequest
{
public:
DescribeDBInstanceConfigRequest();
~DescribeDBInstanceConfigRequest();
std::string getDBInstanceName()const;
void setDBInstanceName(const std::string& dBInstanceName);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getConfigName()const;
void setConfigName(const std::string& configName);
private:
std::string dBInstanceName_;
std::string regionId_;
std::string configName_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCECONFIGREQUEST_H_
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCECONFIGREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCECONFIGREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT DescribeDBInstanceConfigRequest : public RpcServiceRequest {
public:
DescribeDBInstanceConfigRequest();
~DescribeDBInstanceConfigRequest();
std::string getDBInstanceName() const;
void setDBInstanceName(const std::string &dBInstanceName);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getConfigName() const;
void setConfigName(const std::string &configName);
private:
std::string dBInstanceName_;
std::string regionId_;
std::string configName_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCECONFIGREQUEST_H_

45
polardbx/include/alibabacloud/polardbx/model/DescribeDBInstanceHARequest.h Normal file
View File

@@ -0,0 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCEHAREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCEHAREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT DescribeDBInstanceHARequest : public RpcServiceRequest {
public:
DescribeDBInstanceHARequest();
~DescribeDBInstanceHARequest();
std::string getDBInstanceName() const;
void setDBInstanceName(const std::string &dBInstanceName);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
private:
std::string dBInstanceName_;
std::string regionId_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCEHAREQUEST_H_

27
polardbx/include/alibabacloud/polardbx/model/DescribeTableDetailResult.h → polardbx/include/alibabacloud/polardbx/model/DescribeDBInstanceHAResult.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBETABLEDETAILRESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBETABLEDETAILRESULT_H_
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCEHARESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCEHARESULT_H_
#include <string>
#include <vector>
@@ -29,25 +29,22 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT DescribeTableDetailResult : public ServiceResult
class ALIBABACLOUD_POLARDBX_EXPORT DescribeDBInstanceHAResult : public ServiceResult
{
public:
struct Data
{
struct Field
{
std::string extra;
std::string column;
std::string dataType;
std::string key;
};
std::vector<Field> fields;
std::string topologyType;
std::string primaryAzoneId;
std::string secondaryRegionId;
std::string primaryRegionId;
std::string secondaryAzoneId;
};
DescribeTableDetailResult();
explicit DescribeTableDetailResult(const std::string &payload);
~DescribeTableDetailResult();
DescribeDBInstanceHAResult();
explicit DescribeDBInstanceHAResult(const std::string &payload);
~DescribeDBInstanceHAResult();
std::string getMessage()const;
Data getData()const;
bool getSuccess()const;
@@ -63,4 +60,4 @@ namespace AlibabaCloud
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBETABLEDETAILRESULT_H_
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCEHARESULT_H_

45
polardbx/include/alibabacloud/polardbx/model/DescribeDBInstanceSSLRequest.h Normal file
View File

@@ -0,0 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCESSLREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCESSLREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT DescribeDBInstanceSSLRequest : public RpcServiceRequest {
public:
DescribeDBInstanceSSLRequest();
~DescribeDBInstanceSSLRequest();
std::string getDBInstanceName() const;
void setDBInstanceName(const std::string &dBInstanceName);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
private:
std::string dBInstanceName_;
std::string regionId_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCESSLREQUEST_H_

21
polardbx/include/alibabacloud/polardbx/model/DescribeSqlAuditInfoResult.h → polardbx/include/alibabacloud/polardbx/model/DescribeDBInstanceSSLResult.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBESQLAUDITINFORESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBESQLAUDITINFORESULT_H_
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCESSLRESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCESSLRESULT_H_
#include <string>
#include <vector>
@@ -29,21 +29,20 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT DescribeSqlAuditInfoResult : public ServiceResult
class ALIBABACLOUD_POLARDBX_EXPORT DescribeDBInstanceSSLResult : public ServiceResult
{
public:
struct Data
{
std::string authenticated;
std::string sLSProject;
bool isEnabled;
std::string sLSLogStore;
std::string sSLExpiredTime;
bool sSLEnabled;
std::string certCommonName;
};
DescribeSqlAuditInfoResult();
explicit DescribeSqlAuditInfoResult(const std::string &payload);
~DescribeSqlAuditInfoResult();
DescribeDBInstanceSSLResult();
explicit DescribeDBInstanceSSLResult(const std::string &payload);
~DescribeDBInstanceSSLResult();
Data getData()const;
protected:
@@ -55,4 +54,4 @@ namespace AlibabaCloud
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBESQLAUDITINFORESULT_H_
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCESSLRESULT_H_

45
polardbx/include/alibabacloud/polardbx/model/DescribeDBInstanceTDERequest.h Normal file
View File

@@ -0,0 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCETDEREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCETDEREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT DescribeDBInstanceTDERequest : public RpcServiceRequest {
public:
DescribeDBInstanceTDERequest();
~DescribeDBInstanceTDERequest();
std::string getDBInstanceName() const;
void setDBInstanceName(const std::string &dBInstanceName);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
private:
std::string dBInstanceName_;
std::string regionId_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCETDEREQUEST_H_

19
polardbx/include/alibabacloud/polardbx/model/CreatePolarxInstanceResult.h → polardbx/include/alibabacloud/polardbx/model/DescribeDBInstanceTDEResult.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_CREATEPOLARXINSTANCERESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_CREATEPOLARXINSTANCERESULT_H_
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCETDERESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCETDERESULT_H_
#include <string>
#include <vector>
@@ -29,30 +29,27 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT CreatePolarxInstanceResult : public ServiceResult
class ALIBABACLOUD_POLARDBX_EXPORT DescribeDBInstanceTDEResult : public ServiceResult
{
public:
struct Data
{
long orderId;
std::vector<std::string> drdsInstanceIdList;
std::string tDEStatus;
};
CreatePolarxInstanceResult();
explicit CreatePolarxInstanceResult(const std::string &payload);
~CreatePolarxInstanceResult();
DescribeDBInstanceTDEResult();
explicit DescribeDBInstanceTDEResult(const std::string &payload);
~DescribeDBInstanceTDEResult();
Data getData()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_CREATEPOLARXINSTANCERESULT_H_
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCETDERESULT_H_

51
polardbx/include/alibabacloud/polardbx/model/DescribeDBInstanceTopologyRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCETOPOLOGYREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCETOPOLOGYREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT DescribeDBInstanceTopologyRequest : public RpcServiceRequest {
public:
DescribeDBInstanceTopologyRequest();
~DescribeDBInstanceTopologyRequest();
std::string getDBInstanceName() const;
void setDBInstanceName(const std::string &dBInstanceName);
std::string getStartTime() const;
void setStartTime(const std::string &startTime);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getEndTime() const;
void setEndTime(const std::string &endTime);
private:
std::string dBInstanceName_;
std::string startTime_;
std::string regionId_;
std::string endTime_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCETOPOLOGYREQUEST_H_

127
polardbx/include/alibabacloud/polardbx/model/DescribeDBInstanceTopologyResult.h Normal file
View File

@@ -0,0 +1,127 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCETOPOLOGYRESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCETOPOLOGYRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT DescribeDBInstanceTopologyResult : public ServiceResult
{
public:
struct Data
{
struct LogicInstanceTopology
{
struct ItemsItem
{
struct ConnectionIpItem
{
int dBInstanceNetType;
std::string port;
std::string connectionString;
};
struct AoneRoleMap
{
std::string azone;
std::string role;
};
std::string characterType;
int dBInstanceConnType;
int maxIops;
bool activated;
std::string nodeClass;
std::string maintainEndTime;
std::string dBInstanceId;
std::string version;
long diskSize;
std::string dBInstanceStatusDescription;
std::vector<ItemsItem::AoneRoleMap> azoneRoleList;
std::string dBInstanceCreateTime;
std::string lockReason;
std::string maintainStartTime;
std::string engine;
std::string dBInstanceDescription;
std::string dBInstanceName;
std::string azone;
std::string status;
std::string engineVersion;
int dBInstanceStatus;
int maxConnections;
std::string phyInstanceName;
int lockMode;
std::vector<ItemsItem::ConnectionIpItem> connectionIp;
std::string storageUsed;
std::string role;
std::string region;
};
struct HistoryItemsItem
{
std::string role;
std::string azone;
bool activated;
std::string dBInstanceId;
std::string phyInstanceName;
std::string region;
std::string characterType;
std::string dBInstanceName;
};
std::string engineVersion;
int dBInstanceStatus;
int lockMode;
std::string dBInstanceConnType;
std::vector<HistoryItemsItem> historyItems;
std::string maintainEndTime;
std::string dBInstanceId;
int dBInstanceStorage;
std::string dBInstanceStatusDescription;
std::string dBInstanceCreateTime;
std::vector<ItemsItem> items;
std::string lockReason;
std::string maintainStartTime;
std::string engine;
std::string dBInstanceDescription;
std::string dBInstanceName;
};
LogicInstanceTopology logicInstanceTopology;
};
DescribeDBInstanceTopologyResult();
explicit DescribeDBInstanceTopologyResult(const std::string &payload);
~DescribeDBInstanceTopologyResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCETOPOLOGYRESULT_H_

45
polardbx/include/alibabacloud/polardbx/model/DescribeDBInstanceViaEndpointRequest.h Normal file
View File

@@ -0,0 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCEVIAENDPOINTREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCEVIAENDPOINTREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT DescribeDBInstanceViaEndpointRequest : public RpcServiceRequest {
public:
DescribeDBInstanceViaEndpointRequest();
~DescribeDBInstanceViaEndpointRequest();
std::string getEndpoint() const;
void setEndpoint(const std::string &endpoint);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
private:
std::string endpoint_;
std::string regionId_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCEVIAENDPOINTREQUEST_H_

45
polardbx/include/alibabacloud/polardbx/model/GetPolarxCommodityResult.h → polardbx/include/alibabacloud/polardbx/model/DescribeDBInstanceViaEndpointResult.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_GETPOLARXCOMMODITYRESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_GETPOLARXCOMMODITYRESULT_H_
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCEVIAENDPOINTRESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCEVIAENDPOINTRESULT_H_
#include <string>
#include <vector>
@@ -29,7 +29,7 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT GetPolarxCommodityResult : public ServiceResult
class ALIBABACLOUD_POLARDBX_EXPORT DescribeDBInstanceViaEndpointResult : public ServiceResult
{
public:
struct DBInstance
@@ -38,32 +38,45 @@ namespace AlibabaCloud
{
std::string nodeClass;
std::string zoneId;
std::string computeNodeId;
std::string id;
std::string regionId;
std::string dataNodeId;
};
struct ConnAddr
{
std::string type;
std::string vPCId;
std::string port;
std::string vSwitchId;
long port;
std::string vpcInstanceId;
std::string connectionString;
};
struct TagSetItem
{
std::string value;
std::string key;
};
std::string description;
std::string expireDate;
std::string resourceGroupId;
std::vector<std::string> readDBInstances;
std::vector<ConnAddr> connAddrs;
std::string port;
std::string dBInstanceType;
std::string cnNodeClassCode;
std::string dBType;
std::string dBVersion;
std::string maintainEndTime;
int dnNodeCount;
std::vector<DBNode> dBNodes;
std::vector<TagSetItem> tagSet;
std::string rightsSeparationStatus;
std::string network;
int dBNodeCount;
std::string commodityCode;
std::string engine;
std::string maintainStartTime;
std::string engine;
std::string status;
std::string zoneId;
std::string vPCId;
@@ -74,35 +87,33 @@ namespace AlibabaCloud
std::string latestMinorVersion;
std::string payType;
std::string lockMode;
bool rightsSeparationEnabled;
long storageUsed;
std::string dBNodeClass;
int cnNodeCount;
std::string series;
std::vector<std::string> lTSVersions;
std::string type;
std::string dnNodeClassCode;
std::string regionId;
std::string id;
std::string connectionString;
};
struct Component
{
std::string type;
std::vector<std::string> values;
std::string name;
int kindCode;
};
GetPolarxCommodityResult();
explicit GetPolarxCommodityResult(const std::string &payload);
~GetPolarxCommodityResult();
DescribeDBInstanceViaEndpointResult();
explicit DescribeDBInstanceViaEndpointResult(const std::string &payload);
~DescribeDBInstanceViaEndpointResult();
DBInstance getDBInstance()const;
std::vector<Component> getComponentList()const;
protected:
void parse(const std::string &payload);
private:
DBInstance dBInstance_;
std::vector<Component> componentList_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_GETPOLARXCOMMODITYRESULT_H_
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCEVIAENDPOINTRESULT_H_

98
polardbx/include/alibabacloud/polardbx/model/DescribeDBInstancesRequest.h
View File

@@ -1,57 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCESREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT DescribeDBInstancesRequest : public RpcServiceRequest
{
public:
DescribeDBInstancesRequest();
~DescribeDBInstancesRequest();
int getPageNumber()const;
void setPageNumber(int pageNumber);
std::string getResourceGroupId()const;
void setResourceGroupId(const std::string& resourceGroupId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
int getPageSize()const;
void setPageSize(int pageSize);
private:
int pageNumber_;
std::string resourceGroupId_;
std::string regionId_;
int pageSize_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCESREQUEST_H_
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCESREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCESREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT DescribeDBInstancesRequest : public RpcServiceRequest {
public:
DescribeDBInstancesRequest();
~DescribeDBInstancesRequest();
std::string getResourceGroupId() const;
void setResourceGroupId(const std::string &resourceGroupId);
bool getMustHasCdc() const;
void setMustHasCdc(bool mustHasCdc);
std::string getTags() const;
void setTags(const std::string &tags);
std::string getInstanceId() const;
void setInstanceId(const std::string &instanceId);
int getPageNumber() const;
void setPageNumber(int pageNumber);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
int getPageSize() const;
void setPageSize(int pageSize);
std::string getSeries() const;
void setSeries(const std::string &series);
private:
std::string resourceGroupId_;
bool mustHasCdc_;
std::string tags_;
std::string instanceId_;
int pageNumber_;
std::string regionId_;
int pageSize_;
std::string series_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBINSTANCESREQUEST_H_

54
polardbx/include/alibabacloud/polardbx/model/DescribeDBInstancesResult.h
View File

@@ -41,29 +41,55 @@ namespace AlibabaCloud
std::string id;
std::string regionId;
};
std::string status;
struct TagSetItem
{
std::string value;
std::string key;
};
std::string topologyType;
std::string description;
std::string zoneId;
int nodeCount;
std::string vPCId;
std::string resourceGroupId;
std::vector<std::string> readDBInstances;
std::string createTime;
bool expired;
std::string payType;
bool containBinlogX;
std::string cnNodeClassCode;
std::string dBType;
std::string lockMode;
std::vector<DBInstance::PolarDBXNode> nodes;
int storageUsed;
std::string nodeClass;
std::string tertiaryZone;
std::string dBVersion;
std::string type;
std::vector<std::string> columnarReadDBInstances;
std::string gdnRole;
int dnNodeCount;
std::vector<DBInstance::TagSetItem> tagSet;
std::string network;
std::string commodityCode;
std::string id;
std::string regionId;
std::string expireTime;
std::string primaryZone;
std::string cpuType;
std::string lockReason;
std::string engine;
std::string dBInstanceName;
bool supportBinlogX;
std::string status;
int nodeCount;
std::string zoneId;
std::string vPCId;
std::string createTime;
std::string minorVersion;
std::string cdcInstanceName;
bool expired;
std::string payType;
std::string lockMode;
std::vector<DBInstance::PolarDBXNode> nodes;
long storageUsed;
int cnNodeCount;
std::string secondaryZone;
std::string series;
std::string type;
std::string dnNodeClassCode;
std::string columnarInstanceName;
std::string regionId;
std::string id;
std::string expireTime;
bool isInGdn;
};

63
polardbx/include/alibabacloud/polardbx/model/DescribeDBNodePerformanceRequest.h Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBNODEPERFORMANCEREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBNODEPERFORMANCEREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT DescribeDBNodePerformanceRequest : public RpcServiceRequest {
public:
DescribeDBNodePerformanceRequest();
~DescribeDBNodePerformanceRequest();
std::string getStartTime() const;
void setStartTime(const std::string &startTime);
std::string getDBNodeRole() const;
void setDBNodeRole(const std::string &dBNodeRole);
std::string getCharacterType() const;
void setCharacterType(const std::string &characterType);
std::string getDBInstanceName() const;
void setDBInstanceName(const std::string &dBInstanceName);
std::string getDBNodeIds() const;
void setDBNodeIds(const std::string &dBNodeIds);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getKey() const;
void setKey(const std::string &key);
std::string getEndTime() const;
void setEndTime(const std::string &endTime);
private:
std::string startTime_;
std::string dBNodeRole_;
std::string characterType_;
std::string dBInstanceName_;
std::string dBNodeIds_;
std::string regionId_;
std::string key_;
std::string endTime_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBNODEPERFORMANCEREQUEST_H_

71
polardbx/include/alibabacloud/polardbx/model/DescribeDBNodePerformanceResult.h Normal file
View File

@@ -0,0 +1,71 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBNODEPERFORMANCERESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBNODEPERFORMANCERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT DescribeDBNodePerformanceResult : public ServiceResult
{
public:
struct PerformanceItem
{
struct PerformanceItemValue
{
std::string value;
long timestamp;
};
std::string measurement;
std::string metricName;
std::vector<PerformanceItem::PerformanceItemValue> points;
std::string dBNodeId;
};
DescribeDBNodePerformanceResult();
explicit DescribeDBNodePerformanceResult(const std::string &payload);
~DescribeDBNodePerformanceResult();
std::vector<PerformanceItem> getPerformanceKeys()const;
std::string getEndTime()const;
std::string getStartTime()const;
std::string getEngine()const;
std::string getDBInstanceName()const;
protected:
void parse(const std::string &payload);
private:
std::vector<PerformanceItem> performanceKeys_;
std::string endTime_;
std::string startTime_;
std::string engine_;
std::string dBInstanceName_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBNODEPERFORMANCERESULT_H_

80
polardbx/include/alibabacloud/polardbx/model/DescribeDbListRequest.h
View File

@@ -1,54 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBLISTREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBLISTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT DescribeDbListRequest : public RpcServiceRequest
{
public:
DescribeDbListRequest();
~DescribeDbListRequest();
std::string getDBInstanceName()const;
void setDBInstanceName(const std::string& dBInstanceName);
std::string getDBName()const;
void setDBName(const std::string& dBName);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
private:
std::string dBInstanceName_;
std::string dBName_;
std::string regionId_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBLISTREQUEST_H_
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBLISTREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBLISTREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT DescribeDbListRequest : public RpcServiceRequest {
public:
DescribeDbListRequest();
~DescribeDbListRequest();
std::string getDBInstanceName() const;
void setDBInstanceName(const std::string &dBInstanceName);
std::string getDBName() const;
void setDBName(const std::string &dBName);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
private:
std::string dBInstanceName_;
std::string dBName_;
std::string regionId_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDBLISTREQUEST_H_

80
polardbx/include/alibabacloud/polardbx/model/DescribeDistributeTableListRequest.h
View File

@@ -1,54 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDISTRIBUTETABLELISTREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDISTRIBUTETABLELISTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT DescribeDistributeTableListRequest : public RpcServiceRequest
{
public:
DescribeDistributeTableListRequest();
~DescribeDistributeTableListRequest();
std::string getDBInstanceName()const;
void setDBInstanceName(const std::string& dBInstanceName);
std::string getDbName()const;
void setDbName(const std::string& dbName);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
private:
std::string dBInstanceName_;
std::string dbName_;
std::string regionId_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDISTRIBUTETABLELISTREQUEST_H_
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDISTRIBUTETABLELISTREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDISTRIBUTETABLELISTREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT DescribeDistributeTableListRequest : public RpcServiceRequest {
public:
DescribeDistributeTableListRequest();
~DescribeDistributeTableListRequest();
std::string getDBInstanceName() const;
void setDBInstanceName(const std::string &dBInstanceName);
std::string getDbName() const;
void setDbName(const std::string &dbName);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
private:
std::string dBInstanceName_;
std::string dbName_;
std::string regionId_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEDISTRIBUTETABLELISTREQUEST_H_

54
polardbx/include/alibabacloud/polardbx/model/DescribeEventsRequest.h Normal file
View File

@@ -0,0 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEEVENTSREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEEVENTSREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT DescribeEventsRequest : public RpcServiceRequest {
public:
DescribeEventsRequest();
~DescribeEventsRequest();
std::string getStartTime() const;
void setStartTime(const std::string &startTime);
int getPageNumber() const;
void setPageNumber(int pageNumber);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
int getPageSize() const;
void setPageSize(int pageSize);
std::string getEndTime() const;
void setEndTime(const std::string &endTime);
private:
std::string startTime_;
int pageNumber_;
std::string regionId_;
int pageSize_;
std::string endTime_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEEVENTSREQUEST_H_

50
polardbx/include/alibabacloud/polardbx/model/GetPolarXPriceResult.h → polardbx/include/alibabacloud/polardbx/model/DescribeEventsResult.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_GETPOLARXPRICERESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_GETPOLARXPRICERESULT_H_
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEEVENTSRESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEEVENTSRESULT_H_
#include <string>
#include <vector>
@@ -29,39 +29,43 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT GetPolarXPriceResult : public ServiceResult
class ALIBABACLOUD_POLARDBX_EXPORT DescribeEventsResult : public ServiceResult
{
public:
struct OrderPrice
struct EventItemsItem
{
struct Rule
{
long ruleDescId;
std::string title;
std::string name;
};
std::string totalCostAmount;
std::string tradeAmount;
std::string payType;
std::vector<OrderPrice::Rule> rules;
std::string originalAmount;
std::string discountAmount;
std::string dBInstanceName;
std::string eventReason;
std::string eventType;
std::string eventTime;
std::string resourceName;
long eventId;
std::string eventUserType;
std::string resourceType;
std::string eventName;
std::string regionId;
std::string eventRecordTime;
std::string eventPayload;
};
GetPolarXPriceResult();
explicit GetPolarXPriceResult(const std::string &payload);
~GetPolarXPriceResult();
std::vector<OrderPrice> getOrderPriceList()const;
DescribeEventsResult();
explicit DescribeEventsResult(const std::string &payload);
~DescribeEventsResult();
long getTotalRecordCount()const;
std::vector<EventItemsItem> getEventItems()const;
long getPageSize()const;
long getPageNumber()const;
protected:
void parse(const std::string &payload);
private:
std::vector<OrderPrice> orderPriceList_;
long totalRecordCount_;
std::vector<EventItemsItem> eventItems_;
long pageSize_;
long pageNumber_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_GETPOLARXPRICERESULT_H_
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEEVENTSRESULT_H_

63
polardbx/include/alibabacloud/polardbx/model/DescribeInstanceDbPerformanceRequest.h
View File

@@ -1,63 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEINSTANCEDBPERFORMANCEREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEINSTANCEDBPERFORMANCEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT DescribeInstanceDbPerformanceRequest : public RpcServiceRequest
{
public:
DescribeInstanceDbPerformanceRequest();
~DescribeInstanceDbPerformanceRequest();
std::string getDbInstanceName()const;
void setDbInstanceName(const std::string& dbInstanceName);
std::string getKeys()const;
void setKeys(const std::string& keys);
std::string getEndTime()const;
void setEndTime(const std::string& endTime);
std::string getStartTime()const;
void setStartTime(const std::string& startTime);
std::string getDbName()const;
void setDbName(const std::string& dbName);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
private:
std::string dbInstanceName_;
std::string keys_;
std::string endTime_;
std::string startTime_;
std::string dbName_;
std::string regionId_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEINSTANCEDBPERFORMANCEREQUEST_H_

60
polardbx/include/alibabacloud/polardbx/model/DescribeInstancePerformanceRequest.h
View File

@@ -1,60 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEINSTANCEPERFORMANCEREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEINSTANCEPERFORMANCEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT DescribeInstancePerformanceRequest : public RpcServiceRequest
{
public:
DescribeInstancePerformanceRequest();
~DescribeInstancePerformanceRequest();
std::string getDbInstanceName()const;
void setDbInstanceName(const std::string& dbInstanceName);
std::string getKeys()const;
void setKeys(const std::string& keys);
std::string getEndTime()const;
void setEndTime(const std::string& endTime);
std::string getStartTime()const;
void setStartTime(const std::string& startTime);
std::string getNodeId()const;
void setNodeId(const std::string& nodeId);
private:
std::string dbInstanceName_;
std::string keys_;
std::string endTime_;
std::string startTime_;
std::string nodeId_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEINSTANCEPERFORMANCEREQUEST_H_

63
polardbx/include/alibabacloud/polardbx/model/DescribeInstanceStoragePerformanceRequest.h
View File

@@ -1,63 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEINSTANCESTORAGEPERFORMANCEREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEINSTANCESTORAGEPERFORMANCEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT DescribeInstanceStoragePerformanceRequest : public RpcServiceRequest
{
public:
DescribeInstanceStoragePerformanceRequest();
~DescribeInstanceStoragePerformanceRequest();
std::string getDbInstanceName()const;
void setDbInstanceName(const std::string& dbInstanceName);
std::string getStorageInstanceId()const;
void setStorageInstanceId(const std::string& storageInstanceId);
std::string getKeys()const;
void setKeys(const std::string& keys);
std::string getEndTime()const;
void setEndTime(const std::string& endTime);
std::string getStartTime()const;
void setStartTime(const std::string& startTime);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
private:
std::string dbInstanceName_;
std::string storageInstanceId_;
std::string keys_;
std::string endTime_;
std::string startTime_;
std::string regionId_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEINSTANCESTORAGEPERFORMANCEREQUEST_H_

70
polardbx/include/alibabacloud/polardbx/model/DescribeInstanceStoragePerformanceResult.h
View File

@@ -1,70 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEINSTANCESTORAGEPERFORMANCERESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEINSTANCESTORAGEPERFORMANCERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT DescribeInstanceStoragePerformanceResult : public ServiceResult
{
public:
struct Data
{
struct PerformanceItem
{
struct Point
{
std::string value;
long timestamp;
};
std::string measurement;
std::string metricName;
std::vector<PerformanceItem::Point> points;
};
std::vector<PerformanceItem> performanceItems;
};
DescribeInstanceStoragePerformanceResult();
explicit DescribeInstanceStoragePerformanceResult(const std::string &payload);
~DescribeInstanceStoragePerformanceResult();
std::string getMessage()const;
Data getData()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
Data data_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEINSTANCESTORAGEPERFORMANCERESULT_H_

66
polardbx/include/alibabacloud/polardbx/model/DescribeModifyParameterLogRequest.h
View File

@@ -1,66 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEMODIFYPARAMETERLOGREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEMODIFYPARAMETERLOGREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT DescribeModifyParameterLogRequest : public RpcServiceRequest
{
public:
DescribeModifyParameterLogRequest();
~DescribeModifyParameterLogRequest();
std::string getStartTime()const;
void setStartTime(const std::string& startTime);
std::string getPageNumber()const;
void setPageNumber(const std::string& pageNumber);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getPageSize()const;
void setPageSize(const std::string& pageSize);
std::string getDBInstanceId()const;
void setDBInstanceId(const std::string& dBInstanceId);
std::string getParamLevel()const;
void setParamLevel(const std::string& paramLevel);
std::string getEndTime()const;
void setEndTime(const std::string& endTime);
private:
std::string startTime_;
std::string pageNumber_;
std::string regionId_;
std::string pageSize_;
std::string dBInstanceId_;
std::string paramLevel_;
std::string endTime_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEMODIFYPARAMETERLOGREQUEST_H_

80
polardbx/include/alibabacloud/polardbx/model/DescribeParameterTemplatesRequest.h
View File

@@ -1,54 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEPARAMETERTEMPLATESREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEPARAMETERTEMPLATESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT DescribeParameterTemplatesRequest : public RpcServiceRequest
{
public:
DescribeParameterTemplatesRequest();
~DescribeParameterTemplatesRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getDBInstanceId()const;
void setDBInstanceId(const std::string& dBInstanceId);
std::string getParamLevel()const;
void setParamLevel(const std::string& paramLevel);
private:
std::string regionId_;
std::string dBInstanceId_;
std::string paramLevel_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEPARAMETERTEMPLATESREQUEST_H_
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEPARAMETERTEMPLATESREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEPARAMETERTEMPLATESREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT DescribeParameterTemplatesRequest : public RpcServiceRequest {
public:
DescribeParameterTemplatesRequest();
~DescribeParameterTemplatesRequest();
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getDBInstanceId() const;
void setDBInstanceId(const std::string &dBInstanceId);
std::string getParamLevel() const;
void setParamLevel(const std::string &paramLevel);
private:
std::string regionId_;
std::string dBInstanceId_;
std::string paramLevel_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEPARAMETERTEMPLATESREQUEST_H_

80
polardbx/include/alibabacloud/polardbx/model/DescribeParametersRequest.h
View File

@@ -1,54 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEPARAMETERSREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEPARAMETERSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT DescribeParametersRequest : public RpcServiceRequest
{
public:
DescribeParametersRequest();
~DescribeParametersRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getDBInstanceId()const;
void setDBInstanceId(const std::string& dBInstanceId);
std::string getParamLevel()const;
void setParamLevel(const std::string& paramLevel);
private:
std::string regionId_;
std::string dBInstanceId_;
std::string paramLevel_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEPARAMETERSREQUEST_H_
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEPARAMETERSREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEPARAMETERSREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT DescribeParametersRequest : public RpcServiceRequest {
public:
DescribeParametersRequest();
~DescribeParametersRequest();
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getDBInstanceId() const;
void setDBInstanceId(const std::string &dBInstanceId);
std::string getParamLevel() const;
void setParamLevel(const std::string &paramLevel);
private:
std::string regionId_;
std::string dBInstanceId_;
std::string paramLevel_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEPARAMETERSREQUEST_H_

60
polardbx/include/alibabacloud/polardbx/model/DescribePolarxDbInstancesRequest.h
View File

@@ -1,60 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEPOLARXDBINSTANCESREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEPOLARXDBINSTANCESREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT DescribePolarxDbInstancesRequest : public RpcServiceRequest
{
public:
DescribePolarxDbInstancesRequest();
~DescribePolarxDbInstancesRequest();
std::string getDrdsInstanceId()const;
void setDrdsInstanceId(const std::string& drdsInstanceId);
int getPageNumber()const;
void setPageNumber(int pageNumber);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getDbName()const;
void setDbName(const std::string& dbName);
int getPageSize()const;
void setPageSize(int pageSize);
private:
std::string drdsInstanceId_;
int pageNumber_;
std::string accessKeyId_;
std::string dbName_;
int pageSize_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEPOLARXDBINSTANCESREQUEST_H_

81
polardbx/include/alibabacloud/polardbx/model/DescribePolarxDbInstancesResult.h
View File

@@ -1,81 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEPOLARXDBINSTANCESRESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEPOLARXDBINSTANCESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT DescribePolarxDbInstancesResult : public ServiceResult
{
public:
struct DbInstance
{
std::string status;
std::string description;
std::string zoneId;
int nodeCount;
std::string vPCId;
std::string createTime;
std::string payType;
std::string dBType;
std::string lockMode;
int storageUsed;
std::string statusDesc;
std::string nodeClass;
std::string dBVersion;
std::string dBInstanceId;
std::string network;
std::string regionId;
std::string expireTime;
std::string lockReason;
std::string engine;
};
DescribePolarxDbInstancesResult();
explicit DescribePolarxDbInstancesResult(const std::string &payload);
~DescribePolarxDbInstancesResult();
std::string getPageSize()const;
std::string getPageNumber()const;
std::string getTotal()const;
std::vector<DbInstance> getDbInstances()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string pageSize_;
std::string pageNumber_;
std::string total_;
std::vector<DbInstance> dbInstances_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEPOLARXDBINSTANCESRESULT_H_

68
polardbx/include/alibabacloud/polardbx/model/DescribeRegionsRequest.h
View File

@@ -1,48 +1,42 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEREGIONSREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEREGIONSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT DescribeRegionsRequest : public RpcServiceRequest
{
public:
DescribeRegionsRequest();
~DescribeRegionsRequest();
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
private:
std::string accessKeyId_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEREGIONSREQUEST_H_
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEREGIONSREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEREGIONSREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT DescribeRegionsRequest : public RpcServiceRequest {
public:
DescribeRegionsRequest();
~DescribeRegionsRequest();
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
private:
std::string accessKeyId_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEREGIONSREQUEST_H_

1
polardbx/include/alibabacloud/polardbx/model/DescribeRegionsResult.h
View File

@@ -41,6 +41,7 @@ namespace AlibabaCloud
};
bool supportPolarx20;
std::string regionId;
bool supportPolarx10;
std::vector<Region::Zone> zones;
};

98
polardbx/include/alibabacloud/polardbx/model/DescribeScaleOutMigrateTaskListRequest.h
View File

@@ -1,63 +1,57 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBESCALEOUTMIGRATETASKLISTREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBESCALEOUTMIGRATETASKLISTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT DescribeScaleOutMigrateTaskListRequest : public RpcServiceRequest
{
public:
DescribeScaleOutMigrateTaskListRequest();
~DescribeScaleOutMigrateTaskListRequest();
std::string getDBInstanceName()const;
void setDBInstanceName(const std::string& dBInstanceName);
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
std::string dBInstanceName_;
long resourceOwnerId_;
std::string accessKeyId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBESCALEOUTMIGRATETASKLISTREQUEST_H_
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBESCALEOUTMIGRATETASKLISTREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBESCALEOUTMIGRATETASKLISTREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT DescribeScaleOutMigrateTaskListRequest : public RpcServiceRequest {
public:
DescribeScaleOutMigrateTaskListRequest();
~DescribeScaleOutMigrateTaskListRequest();
std::string getDBInstanceName() const;
void setDBInstanceName(const std::string &dBInstanceName);
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
long getOwnerId() const;
void setOwnerId(long ownerId);
private:
std::string dBInstanceName_;
long resourceOwnerId_;
std::string accessKeyId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBESCALEOUTMIGRATETASKLISTREQUEST_H_

74
polardbx/include/alibabacloud/polardbx/model/DescribeSecurityIpsRequest.h
View File

@@ -1,51 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBESECURITYIPSREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBESECURITYIPSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT DescribeSecurityIpsRequest : public RpcServiceRequest
{
public:
DescribeSecurityIpsRequest();
~DescribeSecurityIpsRequest();
std::string getDBInstanceName()const;
void setDBInstanceName(const std::string& dBInstanceName);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
private:
std::string dBInstanceName_;
std::string regionId_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBESECURITYIPSREQUEST_H_
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBESECURITYIPSREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBESECURITYIPSREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT DescribeSecurityIpsRequest : public RpcServiceRequest {
public:
DescribeSecurityIpsRequest();
~DescribeSecurityIpsRequest();
std::string getDBInstanceName() const;
void setDBInstanceName(const std::string &dBInstanceName);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
private:
std::string dBInstanceName_;
std::string regionId_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBESECURITYIPSREQUEST_H_

51
polardbx/include/alibabacloud/polardbx/model/DescribeSqlAuditInfoRequest.h
View File

@@ -1,51 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBESQLAUDITINFOREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBESQLAUDITINFOREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT DescribeSqlAuditInfoRequest : public RpcServiceRequest
{
public:
DescribeSqlAuditInfoRequest();
~DescribeSqlAuditInfoRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getDBInstanceId()const;
void setDBInstanceId(const std::string& dBInstanceId);
private:
std::string regionId_;
std::string dBInstanceId_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBESQLAUDITINFOREQUEST_H_

57
polardbx/include/alibabacloud/polardbx/model/DescribeTableDetailRequest.h
View File

@@ -1,57 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBETABLEDETAILREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBETABLEDETAILREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT DescribeTableDetailRequest : public RpcServiceRequest
{
public:
DescribeTableDetailRequest();
~DescribeTableDetailRequest();
std::string getDBInstanceName()const;
void setDBInstanceName(const std::string& dBInstanceName);
std::string getDbName()const;
void setDbName(const std::string& dbName);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getTableName()const;
void setTableName(const std::string& tableName);
private:
std::string dBInstanceName_;
std::string dbName_;
std::string regionId_;
std::string tableName_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBETABLEDETAILREQUEST_H_

48
polardbx/include/alibabacloud/polardbx/model/DescribeTagsRequest.h Normal file
View File

@@ -0,0 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBETAGSREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBETAGSREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT DescribeTagsRequest : public RpcServiceRequest {
public:
DescribeTagsRequest();
~DescribeTagsRequest();
std::string getDBInstanceName() const;
void setDBInstanceName(const std::string &dBInstanceName);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getTagKey() const;
void setTagKey(const std::string &tagKey);
private:
std::string dBInstanceName_;
std::string regionId_;
std::string tagKey_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBETAGSREQUEST_H_

25
polardbx/include/alibabacloud/polardbx/model/CreatePolarxOrderResult.h → polardbx/include/alibabacloud/polardbx/model/DescribeTagsResult.h
View File

@@ -14,8 +14,8 @@
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_CREATEPOLARXORDERRESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_CREATEPOLARXORDERRESULT_H_
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBETAGSRESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBETAGSRESULT_H_
#include <string>
#include <vector>
@@ -29,28 +29,29 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT CreatePolarxOrderResult : public ServiceResult
class ALIBABACLOUD_POLARDBX_EXPORT DescribeTagsResult : public ServiceResult
{
public:
struct OrderResult
struct TagInfo
{
long orderId;
std::string dBInstanceName;
std::string tagKey;
std::string tagValue;
std::vector<std::string> dBInstanceIds;
};
CreatePolarxOrderResult();
explicit CreatePolarxOrderResult(const std::string &payload);
~CreatePolarxOrderResult();
std::vector<OrderResult> getOrderResultList()const;
DescribeTagsResult();
explicit DescribeTagsResult(const std::string &payload);
~DescribeTagsResult();
std::vector<TagInfo> getTagInfos()const;
protected:
void parse(const std::string &payload);
private:
std::vector<OrderResult> orderResultList_;
std::vector<TagInfo> tagInfos_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_CREATEPOLARXORDERRESULT_H_
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBETAGSRESULT_H_

134
polardbx/include/alibabacloud/polardbx/model/DescribeTasksRequest.h
View File

@@ -1,84 +1,72 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBETASKSREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBETASKSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT DescribeTasksRequest : public RpcServiceRequest
{
public:
DescribeTasksRequest();
~DescribeTasksRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getStartTime()const;
void setStartTime(const std::string& startTime);
int getPageNumber()const;
void setPageNumber(int pageNumber);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
int getPageSize()const;
void setPageSize(int pageSize);
std::string getDBInstanceId()const;
void setDBInstanceId(const std::string& dBInstanceId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
std::string getEndTime()const;
void setEndTime(const std::string& endTime);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getTaskAction()const;
void setTaskAction(const std::string& taskAction);
std::string getStatus()const;
void setStatus(const std::string& status);
private:
long resourceOwnerId_;
std::string startTime_;
int pageNumber_;
std::string accessKeyId_;
std::string regionId_;
int pageSize_;
std::string dBInstanceId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
std::string endTime_;
long ownerId_;
std::string taskAction_;
std::string status_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBETASKSREQUEST_H_
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBETASKSREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBETASKSREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT DescribeTasksRequest : public RpcServiceRequest {
public:
DescribeTasksRequest();
~DescribeTasksRequest();
long getResourceOwnerId() const;
void setResourceOwnerId(long resourceOwnerId);
std::string getStartTime() const;
void setStartTime(const std::string &startTime);
int getPageNumber() const;
void setPageNumber(int pageNumber);
std::string getAccessKeyId() const;
void setAccessKeyId(const std::string &accessKeyId);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
int getPageSize() const;
void setPageSize(int pageSize);
std::string getDBInstanceId() const;
void setDBInstanceId(const std::string &dBInstanceId);
std::string getResourceOwnerAccount() const;
void setResourceOwnerAccount(const std::string &resourceOwnerAccount);
std::string getOwnerAccount() const;
void setOwnerAccount(const std::string &ownerAccount);
std::string getEndTime() const;
void setEndTime(const std::string &endTime);
long getOwnerId() const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string startTime_;
int pageNumber_;
std::string accessKeyId_;
std::string regionId_;
int pageSize_;
std::string dBInstanceId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
std::string endTime_;
long ownerId_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBETASKSREQUEST_H_

3
polardbx/include/alibabacloud/polardbx/model/DescribeTasksResult.h
View File

@@ -34,7 +34,6 @@ namespace AlibabaCloud
public:
struct TaskProgressInfo
{
std::string finishTime1;
std::string status;
std::string progress;
std::string taskId;
@@ -42,8 +41,8 @@ namespace AlibabaCloud
std::string taskAction;
std::string progressInfo;
std::string scaleOutToken;
std::string dBName;
std::string beginTime;
std::string dBName;
std::string taskErrorCode;
std::string taskErrorMessage;
};

45
polardbx/include/alibabacloud/polardbx/model/DescribeUserEncryptionKeyListRequest.h Normal file
View File

@@ -0,0 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEUSERENCRYPTIONKEYLISTREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEUSERENCRYPTIONKEYLISTREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT DescribeUserEncryptionKeyListRequest : public RpcServiceRequest {
public:
DescribeUserEncryptionKeyListRequest();
~DescribeUserEncryptionKeyListRequest();
std::string getDBInstanceName() const;
void setDBInstanceName(const std::string &dBInstanceName);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
private:
std::string dBInstanceName_;
std::string regionId_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEUSERENCRYPTIONKEYLISTREQUEST_H_

55
polardbx/include/alibabacloud/polardbx/model/DescribeUserEncryptionKeyListResult.h Normal file
View File

@@ -0,0 +1,55 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEUSERENCRYPTIONKEYLISTRESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEUSERENCRYPTIONKEYLISTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT DescribeUserEncryptionKeyListResult : public ServiceResult
{
public:
struct Data
{
std::vector<std::string> keyIds;
};
DescribeUserEncryptionKeyListResult();
explicit DescribeUserEncryptionKeyListResult(const std::string &payload);
~DescribeUserEncryptionKeyListResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DESCRIBEUSERENCRYPTIONKEYLISTRESULT_H_

51
polardbx/include/alibabacloud/polardbx/model/DisableRightsSeparationRequest.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DISABLERIGHTSSEPARATIONREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DISABLERIGHTSSEPARATIONREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT DisableRightsSeparationRequest : public RpcServiceRequest {
public:
DisableRightsSeparationRequest();
~DisableRightsSeparationRequest();
std::string getDBInstanceName() const;
void setDBInstanceName(const std::string &dBInstanceName);
std::string getDbaAccountPassword() const;
void setDbaAccountPassword(const std::string &dbaAccountPassword);
std::string getDbaAccountName() const;
void setDbaAccountName(const std::string &dbaAccountName);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
private:
std::string dBInstanceName_;
std::string dbaAccountPassword_;
std::string dbaAccountName_;
std::string regionId_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DISABLERIGHTSSEPARATIONREQUEST_H_

53
polardbx/include/alibabacloud/polardbx/model/DisableRightsSeparationResult.h Normal file
View File

@@ -0,0 +1,53 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DISABLERIGHTSSEPARATIONRESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DISABLERIGHTSSEPARATIONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT DisableRightsSeparationResult : public ServiceResult
{
public:
DisableRightsSeparationResult();
explicit DisableRightsSeparationResult(const std::string &payload);
~DisableRightsSeparationResult();
std::string getMessage()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DISABLERIGHTSSEPARATIONRESULT_H_

51
polardbx/include/alibabacloud/polardbx/model/DisableSqlAuditRequest.h
View File

@@ -1,51 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_DISABLESQLAUDITREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_DISABLESQLAUDITREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT DisableSqlAuditRequest : public RpcServiceRequest
{
public:
DisableSqlAuditRequest();
~DisableSqlAuditRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getDBInstanceId()const;
void setDBInstanceId(const std::string& dBInstanceId);
private:
std::string regionId_;
std::string dBInstanceId_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_DISABLESQLAUDITREQUEST_H_

63
polardbx/include/alibabacloud/polardbx/model/EnableRightsSeparationRequest.h Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_ENABLERIGHTSSEPARATIONREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_ENABLERIGHTSSEPARATIONREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT EnableRightsSeparationRequest : public RpcServiceRequest {
public:
EnableRightsSeparationRequest();
~EnableRightsSeparationRequest();
std::string getSecurityAccountPassword() const;
void setSecurityAccountPassword(const std::string &securityAccountPassword);
std::string getSecurityAccountDescription() const;
void setSecurityAccountDescription(const std::string &securityAccountDescription);
std::string getAuditAccountPassword() const;
void setAuditAccountPassword(const std::string &auditAccountPassword);
std::string getDBInstanceName() const;
void setDBInstanceName(const std::string &dBInstanceName);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getSecurityAccountName() const;
void setSecurityAccountName(const std::string &securityAccountName);
std::string getAuditAccountName() const;
void setAuditAccountName(const std::string &auditAccountName);
std::string getAuditAccountDescription() const;
void setAuditAccountDescription(const std::string &auditAccountDescription);
private:
std::string securityAccountPassword_;
std::string securityAccountDescription_;
std::string auditAccountPassword_;
std::string dBInstanceName_;
std::string regionId_;
std::string securityAccountName_;
std::string auditAccountName_;
std::string auditAccountDescription_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_ENABLERIGHTSSEPARATIONREQUEST_H_

53
polardbx/include/alibabacloud/polardbx/model/EnableRightsSeparationResult.h Normal file
View File

@@ -0,0 +1,53 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_ENABLERIGHTSSEPARATIONRESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_ENABLERIGHTSSEPARATIONRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT EnableRightsSeparationResult : public ServiceResult
{
public:
EnableRightsSeparationResult();
explicit EnableRightsSeparationResult(const std::string &payload);
~EnableRightsSeparationResult();
std::string getMessage()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_ENABLERIGHTSSEPARATIONRESULT_H_

54
polardbx/include/alibabacloud/polardbx/model/EnableSqlAuditRequest.h
View File

@@ -1,54 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_ENABLESQLAUDITREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_ENABLESQLAUDITREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT EnableSqlAuditRequest : public RpcServiceRequest
{
public:
EnableSqlAuditRequest();
~EnableSqlAuditRequest();
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getDBInstanceId()const;
void setDBInstanceId(const std::string& dBInstanceId);
int getExpireAfterDays()const;
void setExpireAfterDays(int expireAfterDays);
private:
std::string regionId_;
std::string dBInstanceId_;
int expireAfterDays_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_ENABLESQLAUDITREQUEST_H_

54
polardbx/include/alibabacloud/polardbx/model/GetPolarXPriceRequest.h
View File

@@ -1,54 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_GETPOLARXPRICEREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_GETPOLARXPRICEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT GetPolarXPriceRequest : public RpcServiceRequest
{
public:
GetPolarXPriceRequest();
~GetPolarXPriceRequest();
std::string getDBInstanceName()const;
void setDBInstanceName(const std::string& dBInstanceName);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getNodeCount()const;
void setNodeCount(const std::string& nodeCount);
private:
std::string dBInstanceName_;
std::string regionId_;
std::string nodeCount_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_GETPOLARXPRICEREQUEST_H_

54
polardbx/include/alibabacloud/polardbx/model/GetPolarxCommodityRequest.h
View File

@@ -1,54 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_GETPOLARXCOMMODITYREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_GETPOLARXCOMMODITYREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT GetPolarxCommodityRequest : public RpcServiceRequest
{
public:
GetPolarxCommodityRequest();
~GetPolarxCommodityRequest();
std::string getDBInstanceName()const;
void setDBInstanceName(const std::string& dBInstanceName);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getOrderType()const;
void setOrderType(const std::string& orderType);
private:
std::string dBInstanceName_;
std::string regionId_;
std::string orderType_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_GETPOLARXCOMMODITYREQUEST_H_

58
polardbx/include/alibabacloud/polardbx/model/ListTagResourcesRequest.h Normal file
View File

@@ -0,0 +1,58 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_LISTTAGRESOURCESREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_LISTTAGRESOURCESREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT ListTagResourcesRequest : public RpcServiceRequest {
public:
struct Tag {
std::string value;
std::string key;
};
ListTagResourcesRequest();
~ListTagResourcesRequest();
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
std::string getNextToken() const;
void setNextToken(const std::string &nextToken);
std::vector<Tag> getTag() const;
void setTag(const std::vector<Tag> &tag);
std::vector<std::string> getResourceId() const;
void setResourceId(const std::vector<std::string> &resourceId);
std::string getResourceType() const;
void setResourceType(const std::string &resourceType);
private:
std::string regionId_;
std::string nextToken_;
std::vector<Tag> tag_;
std::vector<std::string> resourceId_;
std::string resourceType_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_LISTTAGRESOURCESREQUEST_H_

60
polardbx/include/alibabacloud/polardbx/model/ListTagResourcesResult.h Normal file
View File

@@ -0,0 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_LISTTAGRESOURCESRESULT_H_
#define ALIBABACLOUD_POLARDBX_MODEL_LISTTAGRESOURCESRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT ListTagResourcesResult : public ServiceResult
{
public:
struct TagResource
{
std::string resourceId;
std::string tagKey;
std::string resourceType;
std::string tagValue;
};
ListTagResourcesResult();
explicit ListTagResourcesResult(const std::string &payload);
~ListTagResourcesResult();
std::string getNextToken()const;
std::vector<TagResource> getTagResources()const;
protected:
void parse(const std::string &payload);
private:
std::string nextToken_;
std::vector<TagResource> tagResources_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_LISTTAGRESOURCESRESULT_H_

86
polardbx/include/alibabacloud/polardbx/model/ModifyAccountDescriptionRequest.h
View File

@@ -1,57 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*
* http://www.apache.org/licenses/LICENSE-2.0
*
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_MODIFYACCOUNTDESCRIPTIONREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_MODIFYACCOUNTDESCRIPTIONREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardbx/PolardbxExport.h>
namespace AlibabaCloud
{
namespace Polardbx
{
namespace Model
{
class ALIBABACLOUD_POLARDBX_EXPORT ModifyAccountDescriptionRequest : public RpcServiceRequest
{
public:
ModifyAccountDescriptionRequest();
~ModifyAccountDescriptionRequest();
std::string getDBInstanceName()const;
void setDBInstanceName(const std::string& dBInstanceName);
std::string getAccountDescription()const;
void setAccountDescription(const std::string& accountDescription);
std::string getAccountName()const;
void setAccountName(const std::string& accountName);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
private:
std::string dBInstanceName_;
std::string accountDescription_;
std::string accountName_;
std::string regionId_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDBX_MODEL_MODIFYACCOUNTDESCRIPTIONREQUEST_H_
*/
#ifndef ALIBABACLOUD_POLARDBX_MODEL_MODIFYACCOUNTDESCRIPTIONREQUEST_H_
#define ALIBABACLOUD_POLARDBX_MODEL_MODIFYACCOUNTDESCRIPTIONREQUEST_H_
#include <alibabacloud/polardbx/PolardbxExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Polardbx {
namespace Model {
class ALIBABACLOUD_POLARDBX_EXPORT ModifyAccountDescriptionRequest : public RpcServiceRequest {
public:
ModifyAccountDescriptionRequest();
~ModifyAccountDescriptionRequest();
std::string getDBInstanceName() const;
void setDBInstanceName(const std::string &dBInstanceName);
std::string getAccountDescription() const;
void setAccountDescription(const std::string &accountDescription);
std::string getAccountName() const;
void setAccountName(const std::string &accountName);
std::string getRegionId() const;
void setRegionId(const std::string &regionId);
private:
std::string dBInstanceName_;
std::string accountDescription_;
std::string accountName_;
std::string regionId_;
};
} // namespace Model
} // namespace Polardbx
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_POLARDBX_MODEL_MODIFYACCOUNTDESCRIPTIONREQUEST_H_

Some files were not shown because too many files have changed in this diff Show More