regenerate the rds c++ sdk.

rds/CMakeLists.txt

@@ -43,6 +43,8 @@ set(rds_public_header_model
 	include/alibabacloud/rds/model/CheckInstanceExistResult.h
 	include/alibabacloud/rds/model/CheckRecoveryConditionsRequest.h
 	include/alibabacloud/rds/model/CheckRecoveryConditionsResult.h
+	include/alibabacloud/rds/model/CheckRegionSupportBackupEncryptionRequest.h
+	include/alibabacloud/rds/model/CheckRegionSupportBackupEncryptionResult.h
 	include/alibabacloud/rds/model/ClearDedicatedHostRequest.h
 	include/alibabacloud/rds/model/ClearDedicatedHostResult.h
 	include/alibabacloud/rds/model/CloneDBInstanceRequest.h
@@ -155,6 +157,8 @@ set(rds_public_header_model
 	include/alibabacloud/rds/model/DescribeDBInstanceAttributeResult.h
 	include/alibabacloud/rds/model/DescribeDBInstanceByTagsRequest.h
 	include/alibabacloud/rds/model/DescribeDBInstanceByTagsResult.h
+	include/alibabacloud/rds/model/DescribeDBInstanceDetailRequest.h
+	include/alibabacloud/rds/model/DescribeDBInstanceDetailResult.h
 	include/alibabacloud/rds/model/DescribeDBInstanceHAConfigRequest.h
 	include/alibabacloud/rds/model/DescribeDBInstanceHAConfigResult.h
 	include/alibabacloud/rds/model/DescribeDBInstanceIPArrayListRequest.h
@@ -293,6 +297,10 @@ set(rds_public_header_model
 	include/alibabacloud/rds/model/DropDedicatedHostUserResult.h
 	include/alibabacloud/rds/model/EvaluateDedicatedHostInstanceResourceRequest.h
 	include/alibabacloud/rds/model/EvaluateDedicatedHostInstanceResourceResult.h
+	include/alibabacloud/rds/model/GetDBInstanceTopologyRequest.h
+	include/alibabacloud/rds/model/GetDBInstanceTopologyResult.h
+	include/alibabacloud/rds/model/GetDbProxyInstanceSslRequest.h
+	include/alibabacloud/rds/model/GetDbProxyInstanceSslResult.h
 	include/alibabacloud/rds/model/GrantAccountPrivilegeRequest.h
 	include/alibabacloud/rds/model/GrantAccountPrivilegeResult.h
 	include/alibabacloud/rds/model/GrantOperatorPermissionRequest.h
@@ -303,6 +311,8 @@ set(rds_public_header_model
 	include/alibabacloud/rds/model/ListTagResourcesResult.h
 	include/alibabacloud/rds/model/LockAccountRequest.h
 	include/alibabacloud/rds/model/LockAccountResult.h
+	include/alibabacloud/rds/model/MigrateConnectionToOtherZoneRequest.h
+	include/alibabacloud/rds/model/MigrateConnectionToOtherZoneResult.h
 	include/alibabacloud/rds/model/MigrateDBInstanceRequest.h
 	include/alibabacloud/rds/model/MigrateDBInstanceResult.h
 	include/alibabacloud/rds/model/MigrateSecurityIPModeRequest.h
@@ -361,6 +371,8 @@ set(rds_public_header_model
 	include/alibabacloud/rds/model/ModifyDTCSecurityIpHostsForSQLServerResult.h
 	include/alibabacloud/rds/model/ModifyDasInstanceConfigRequest.h
 	include/alibabacloud/rds/model/ModifyDasInstanceConfigResult.h
+	include/alibabacloud/rds/model/ModifyDbProxyInstanceSslRequest.h
+	include/alibabacloud/rds/model/ModifyDbProxyInstanceSslResult.h
 	include/alibabacloud/rds/model/ModifyDedicatedHostAccountRequest.h
 	include/alibabacloud/rds/model/ModifyDedicatedHostAccountResult.h
 	include/alibabacloud/rds/model/ModifyDedicatedHostAttributeRequest.h
@@ -375,6 +387,8 @@ set(rds_public_header_model
 	include/alibabacloud/rds/model/ModifyInstanceAutoRenewalAttributeResult.h
 	include/alibabacloud/rds/model/ModifyInstanceCrossBackupPolicyRequest.h
 	include/alibabacloud/rds/model/ModifyInstanceCrossBackupPolicyResult.h
+	include/alibabacloud/rds/model/ModifyLicenseInfoRequest.h
+	include/alibabacloud/rds/model/ModifyLicenseInfoResult.h
 	include/alibabacloud/rds/model/ModifyParameterRequest.h
 	include/alibabacloud/rds/model/ModifyParameterResult.h
 	include/alibabacloud/rds/model/ModifyParameterGroupRequest.h
@@ -484,6 +498,8 @@ set(rds_src
 	src/model/CheckInstanceExistResult.cc
 	src/model/CheckRecoveryConditionsRequest.cc
 	src/model/CheckRecoveryConditionsResult.cc
+	src/model/CheckRegionSupportBackupEncryptionRequest.cc
+	src/model/CheckRegionSupportBackupEncryptionResult.cc
 	src/model/ClearDedicatedHostRequest.cc
 	src/model/ClearDedicatedHostResult.cc
 	src/model/CloneDBInstanceRequest.cc
@@ -596,6 +612,8 @@ set(rds_src
 	src/model/DescribeDBInstanceAttributeResult.cc
 	src/model/DescribeDBInstanceByTagsRequest.cc
 	src/model/DescribeDBInstanceByTagsResult.cc
+	src/model/DescribeDBInstanceDetailRequest.cc
+	src/model/DescribeDBInstanceDetailResult.cc
 	src/model/DescribeDBInstanceHAConfigRequest.cc
 	src/model/DescribeDBInstanceHAConfigResult.cc
 	src/model/DescribeDBInstanceIPArrayListRequest.cc
@@ -734,6 +752,10 @@ set(rds_src
 	src/model/DropDedicatedHostUserResult.cc
 	src/model/EvaluateDedicatedHostInstanceResourceRequest.cc
 	src/model/EvaluateDedicatedHostInstanceResourceResult.cc
+	src/model/GetDBInstanceTopologyRequest.cc
+	src/model/GetDBInstanceTopologyResult.cc
+	src/model/GetDbProxyInstanceSslRequest.cc
+	src/model/GetDbProxyInstanceSslResult.cc
 	src/model/GrantAccountPrivilegeRequest.cc
 	src/model/GrantAccountPrivilegeResult.cc
 	src/model/GrantOperatorPermissionRequest.cc
@@ -744,6 +766,8 @@ set(rds_src
 	src/model/ListTagResourcesResult.cc
 	src/model/LockAccountRequest.cc
 	src/model/LockAccountResult.cc
+	src/model/MigrateConnectionToOtherZoneRequest.cc
+	src/model/MigrateConnectionToOtherZoneResult.cc
 	src/model/MigrateDBInstanceRequest.cc
 	src/model/MigrateDBInstanceResult.cc
 	src/model/MigrateSecurityIPModeRequest.cc
@@ -802,6 +826,8 @@ set(rds_src
 	src/model/ModifyDTCSecurityIpHostsForSQLServerResult.cc
 	src/model/ModifyDasInstanceConfigRequest.cc
 	src/model/ModifyDasInstanceConfigResult.cc
+	src/model/ModifyDbProxyInstanceSslRequest.cc
+	src/model/ModifyDbProxyInstanceSslResult.cc
 	src/model/ModifyDedicatedHostAccountRequest.cc
 	src/model/ModifyDedicatedHostAccountResult.cc
 	src/model/ModifyDedicatedHostAttributeRequest.cc
@@ -816,6 +842,8 @@ set(rds_src
 	src/model/ModifyInstanceAutoRenewalAttributeResult.cc
 	src/model/ModifyInstanceCrossBackupPolicyRequest.cc
 	src/model/ModifyInstanceCrossBackupPolicyResult.cc
+	src/model/ModifyLicenseInfoRequest.cc
+	src/model/ModifyLicenseInfoResult.cc
 	src/model/ModifyParameterRequest.cc
 	src/model/ModifyParameterResult.cc
 	src/model/ModifyParameterGroupRequest.cc

rds/include/alibabacloud/rds/RdsClient.h

@@ -44,6 +44,8 @@
 #include "model/CheckInstanceExistResult.h"
 #include "model/CheckRecoveryConditionsRequest.h"
 #include "model/CheckRecoveryConditionsResult.h"
+#include "model/CheckRegionSupportBackupEncryptionRequest.h"
+#include "model/CheckRegionSupportBackupEncryptionResult.h"
 #include "model/ClearDedicatedHostRequest.h"
 #include "model/ClearDedicatedHostResult.h"
 #include "model/CloneDBInstanceRequest.h"
@@ -156,6 +158,8 @@
 #include "model/DescribeDBInstanceAttributeResult.h"
 #include "model/DescribeDBInstanceByTagsRequest.h"
 #include "model/DescribeDBInstanceByTagsResult.h"
+#include "model/DescribeDBInstanceDetailRequest.h"
+#include "model/DescribeDBInstanceDetailResult.h"
 #include "model/DescribeDBInstanceHAConfigRequest.h"
 #include "model/DescribeDBInstanceHAConfigResult.h"
 #include "model/DescribeDBInstanceIPArrayListRequest.h"
@@ -294,6 +298,10 @@
 #include "model/DropDedicatedHostUserResult.h"
 #include "model/EvaluateDedicatedHostInstanceResourceRequest.h"
 #include "model/EvaluateDedicatedHostInstanceResourceResult.h"
+#include "model/GetDBInstanceTopologyRequest.h"
+#include "model/GetDBInstanceTopologyResult.h"
+#include "model/GetDbProxyInstanceSslRequest.h"
+#include "model/GetDbProxyInstanceSslResult.h"
 #include "model/GrantAccountPrivilegeRequest.h"
 #include "model/GrantAccountPrivilegeResult.h"
 #include "model/GrantOperatorPermissionRequest.h"
@@ -304,6 +312,8 @@
 #include "model/ListTagResourcesResult.h"
 #include "model/LockAccountRequest.h"
 #include "model/LockAccountResult.h"
+#include "model/MigrateConnectionToOtherZoneRequest.h"
+#include "model/MigrateConnectionToOtherZoneResult.h"
 #include "model/MigrateDBInstanceRequest.h"
 #include "model/MigrateDBInstanceResult.h"
 #include "model/MigrateSecurityIPModeRequest.h"
@@ -362,6 +372,8 @@
 #include "model/ModifyDTCSecurityIpHostsForSQLServerResult.h"
 #include "model/ModifyDasInstanceConfigRequest.h"
 #include "model/ModifyDasInstanceConfigResult.h"
+#include "model/ModifyDbProxyInstanceSslRequest.h"
+#include "model/ModifyDbProxyInstanceSslResult.h"
 #include "model/ModifyDedicatedHostAccountRequest.h"
 #include "model/ModifyDedicatedHostAccountResult.h"
 #include "model/ModifyDedicatedHostAttributeRequest.h"
@@ -376,6 +388,8 @@
 #include "model/ModifyInstanceAutoRenewalAttributeResult.h"
 #include "model/ModifyInstanceCrossBackupPolicyRequest.h"
 #include "model/ModifyInstanceCrossBackupPolicyResult.h"
+#include "model/ModifyLicenseInfoRequest.h"
+#include "model/ModifyLicenseInfoResult.h"
 #include "model/ModifyParameterRequest.h"
 #include "model/ModifyParameterResult.h"
 #include "model/ModifyParameterGroupRequest.h"
@@ -502,6 +516,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::CheckRecoveryConditionsResult> CheckRecoveryConditionsOutcome;
 			typedef std::future<CheckRecoveryConditionsOutcome> CheckRecoveryConditionsOutcomeCallable;
 			typedef std::function<void(const RdsClient*, const Model::CheckRecoveryConditionsRequest&, const CheckRecoveryConditionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckRecoveryConditionsAsyncHandler;
+			typedef Outcome<Error, Model::CheckRegionSupportBackupEncryptionResult> CheckRegionSupportBackupEncryptionOutcome;
+			typedef std::future<CheckRegionSupportBackupEncryptionOutcome> CheckRegionSupportBackupEncryptionOutcomeCallable;
+			typedef std::function<void(const RdsClient*, const Model::CheckRegionSupportBackupEncryptionRequest&, const CheckRegionSupportBackupEncryptionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckRegionSupportBackupEncryptionAsyncHandler;
 			typedef Outcome<Error, Model::ClearDedicatedHostResult> ClearDedicatedHostOutcome;
 			typedef std::future<ClearDedicatedHostOutcome> ClearDedicatedHostOutcomeCallable;
 			typedef std::function<void(const RdsClient*, const Model::ClearDedicatedHostRequest&, const ClearDedicatedHostOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ClearDedicatedHostAsyncHandler;
@@ -670,6 +687,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeDBInstanceByTagsResult> DescribeDBInstanceByTagsOutcome;
 			typedef std::future<DescribeDBInstanceByTagsOutcome> DescribeDBInstanceByTagsOutcomeCallable;
 			typedef std::function<void(const RdsClient*, const Model::DescribeDBInstanceByTagsRequest&, const DescribeDBInstanceByTagsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBInstanceByTagsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDBInstanceDetailResult> DescribeDBInstanceDetailOutcome;
+			typedef std::future<DescribeDBInstanceDetailOutcome> DescribeDBInstanceDetailOutcomeCallable;
+			typedef std::function<void(const RdsClient*, const Model::DescribeDBInstanceDetailRequest&, const DescribeDBInstanceDetailOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBInstanceDetailAsyncHandler;
 			typedef Outcome<Error, Model::DescribeDBInstanceHAConfigResult> DescribeDBInstanceHAConfigOutcome;
 			typedef std::future<DescribeDBInstanceHAConfigOutcome> DescribeDBInstanceHAConfigOutcomeCallable;
 			typedef std::function<void(const RdsClient*, const Model::DescribeDBInstanceHAConfigRequest&, const DescribeDBInstanceHAConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBInstanceHAConfigAsyncHandler;
@@ -877,6 +897,12 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::EvaluateDedicatedHostInstanceResourceResult> EvaluateDedicatedHostInstanceResourceOutcome;
 			typedef std::future<EvaluateDedicatedHostInstanceResourceOutcome> EvaluateDedicatedHostInstanceResourceOutcomeCallable;
 			typedef std::function<void(const RdsClient*, const Model::EvaluateDedicatedHostInstanceResourceRequest&, const EvaluateDedicatedHostInstanceResourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> EvaluateDedicatedHostInstanceResourceAsyncHandler;
+			typedef Outcome<Error, Model::GetDBInstanceTopologyResult> GetDBInstanceTopologyOutcome;
+			typedef std::future<GetDBInstanceTopologyOutcome> GetDBInstanceTopologyOutcomeCallable;
+			typedef std::function<void(const RdsClient*, const Model::GetDBInstanceTopologyRequest&, const GetDBInstanceTopologyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetDBInstanceTopologyAsyncHandler;
+			typedef Outcome<Error, Model::GetDbProxyInstanceSslResult> GetDbProxyInstanceSslOutcome;
+			typedef std::future<GetDbProxyInstanceSslOutcome> GetDbProxyInstanceSslOutcomeCallable;
+			typedef std::function<void(const RdsClient*, const Model::GetDbProxyInstanceSslRequest&, const GetDbProxyInstanceSslOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetDbProxyInstanceSslAsyncHandler;
 			typedef Outcome<Error, Model::GrantAccountPrivilegeResult> GrantAccountPrivilegeOutcome;
 			typedef std::future<GrantAccountPrivilegeOutcome> GrantAccountPrivilegeOutcomeCallable;
 			typedef std::function<void(const RdsClient*, const Model::GrantAccountPrivilegeRequest&, const GrantAccountPrivilegeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GrantAccountPrivilegeAsyncHandler;
@@ -892,6 +918,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::LockAccountResult> LockAccountOutcome;
 			typedef std::future<LockAccountOutcome> LockAccountOutcomeCallable;
 			typedef std::function<void(const RdsClient*, const Model::LockAccountRequest&, const LockAccountOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> LockAccountAsyncHandler;
+			typedef Outcome<Error, Model::MigrateConnectionToOtherZoneResult> MigrateConnectionToOtherZoneOutcome;
+			typedef std::future<MigrateConnectionToOtherZoneOutcome> MigrateConnectionToOtherZoneOutcomeCallable;
+			typedef std::function<void(const RdsClient*, const Model::MigrateConnectionToOtherZoneRequest&, const MigrateConnectionToOtherZoneOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> MigrateConnectionToOtherZoneAsyncHandler;
 			typedef Outcome<Error, Model::MigrateDBInstanceResult> MigrateDBInstanceOutcome;
 			typedef std::future<MigrateDBInstanceOutcome> MigrateDBInstanceOutcomeCallable;
 			typedef std::function<void(const RdsClient*, const Model::MigrateDBInstanceRequest&, const MigrateDBInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> MigrateDBInstanceAsyncHandler;
@@ -979,6 +1008,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ModifyDasInstanceConfigResult> ModifyDasInstanceConfigOutcome;
 			typedef std::future<ModifyDasInstanceConfigOutcome> ModifyDasInstanceConfigOutcomeCallable;
 			typedef std::function<void(const RdsClient*, const Model::ModifyDasInstanceConfigRequest&, const ModifyDasInstanceConfigOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDasInstanceConfigAsyncHandler;
+			typedef Outcome<Error, Model::ModifyDbProxyInstanceSslResult> ModifyDbProxyInstanceSslOutcome;
+			typedef std::future<ModifyDbProxyInstanceSslOutcome> ModifyDbProxyInstanceSslOutcomeCallable;
+			typedef std::function<void(const RdsClient*, const Model::ModifyDbProxyInstanceSslRequest&, const ModifyDbProxyInstanceSslOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDbProxyInstanceSslAsyncHandler;
 			typedef Outcome<Error, Model::ModifyDedicatedHostAccountResult> ModifyDedicatedHostAccountOutcome;
 			typedef std::future<ModifyDedicatedHostAccountOutcome> ModifyDedicatedHostAccountOutcomeCallable;
 			typedef std::function<void(const RdsClient*, const Model::ModifyDedicatedHostAccountRequest&, const ModifyDedicatedHostAccountOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDedicatedHostAccountAsyncHandler;
@@ -1000,6 +1032,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ModifyInstanceCrossBackupPolicyResult> ModifyInstanceCrossBackupPolicyOutcome;
 			typedef std::future<ModifyInstanceCrossBackupPolicyOutcome> ModifyInstanceCrossBackupPolicyOutcomeCallable;
 			typedef std::function<void(const RdsClient*, const Model::ModifyInstanceCrossBackupPolicyRequest&, const ModifyInstanceCrossBackupPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyInstanceCrossBackupPolicyAsyncHandler;
+			typedef Outcome<Error, Model::ModifyLicenseInfoResult> ModifyLicenseInfoOutcome;
+			typedef std::future<ModifyLicenseInfoOutcome> ModifyLicenseInfoOutcomeCallable;
+			typedef std::function<void(const RdsClient*, const Model::ModifyLicenseInfoRequest&, const ModifyLicenseInfoOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyLicenseInfoAsyncHandler;
 			typedef Outcome<Error, Model::ModifyParameterResult> ModifyParameterOutcome;
 			typedef std::future<ModifyParameterOutcome> ModifyParameterOutcomeCallable;
 			typedef std::function<void(const RdsClient*, const Model::ModifyParameterRequest&, const ModifyParameterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyParameterAsyncHandler;
@@ -1164,6 +1199,9 @@ namespace AlibabaCloud
 			CheckRecoveryConditionsOutcome checkRecoveryConditions(const Model::CheckRecoveryConditionsRequest &request)const;
 			void checkRecoveryConditionsAsync(const Model::CheckRecoveryConditionsRequest& request, const CheckRecoveryConditionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			CheckRecoveryConditionsOutcomeCallable checkRecoveryConditionsCallable(const Model::CheckRecoveryConditionsRequest& request) const;
+			CheckRegionSupportBackupEncryptionOutcome checkRegionSupportBackupEncryption(const Model::CheckRegionSupportBackupEncryptionRequest &request)const;
+			void checkRegionSupportBackupEncryptionAsync(const Model::CheckRegionSupportBackupEncryptionRequest& request, const CheckRegionSupportBackupEncryptionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			CheckRegionSupportBackupEncryptionOutcomeCallable checkRegionSupportBackupEncryptionCallable(const Model::CheckRegionSupportBackupEncryptionRequest& request) const;
 			ClearDedicatedHostOutcome clearDedicatedHost(const Model::ClearDedicatedHostRequest &request)const;
 			void clearDedicatedHostAsync(const Model::ClearDedicatedHostRequest& request, const ClearDedicatedHostAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ClearDedicatedHostOutcomeCallable clearDedicatedHostCallable(const Model::ClearDedicatedHostRequest& request) const;
@@ -1332,6 +1370,9 @@ namespace AlibabaCloud
 			DescribeDBInstanceByTagsOutcome describeDBInstanceByTags(const Model::DescribeDBInstanceByTagsRequest &request)const;
 			void describeDBInstanceByTagsAsync(const Model::DescribeDBInstanceByTagsRequest& request, const DescribeDBInstanceByTagsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDBInstanceByTagsOutcomeCallable describeDBInstanceByTagsCallable(const Model::DescribeDBInstanceByTagsRequest& request) const;
+			DescribeDBInstanceDetailOutcome describeDBInstanceDetail(const Model::DescribeDBInstanceDetailRequest &request)const;
+			void describeDBInstanceDetailAsync(const Model::DescribeDBInstanceDetailRequest& request, const DescribeDBInstanceDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDBInstanceDetailOutcomeCallable describeDBInstanceDetailCallable(const Model::DescribeDBInstanceDetailRequest& request) const;
 			DescribeDBInstanceHAConfigOutcome describeDBInstanceHAConfig(const Model::DescribeDBInstanceHAConfigRequest &request)const;
 			void describeDBInstanceHAConfigAsync(const Model::DescribeDBInstanceHAConfigRequest& request, const DescribeDBInstanceHAConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDBInstanceHAConfigOutcomeCallable describeDBInstanceHAConfigCallable(const Model::DescribeDBInstanceHAConfigRequest& request) const;
@@ -1539,6 +1580,12 @@ namespace AlibabaCloud
 			EvaluateDedicatedHostInstanceResourceOutcome evaluateDedicatedHostInstanceResource(const Model::EvaluateDedicatedHostInstanceResourceRequest &request)const;
 			void evaluateDedicatedHostInstanceResourceAsync(const Model::EvaluateDedicatedHostInstanceResourceRequest& request, const EvaluateDedicatedHostInstanceResourceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			EvaluateDedicatedHostInstanceResourceOutcomeCallable evaluateDedicatedHostInstanceResourceCallable(const Model::EvaluateDedicatedHostInstanceResourceRequest& request) const;
+			GetDBInstanceTopologyOutcome getDBInstanceTopology(const Model::GetDBInstanceTopologyRequest &request)const;
+			void getDBInstanceTopologyAsync(const Model::GetDBInstanceTopologyRequest& request, const GetDBInstanceTopologyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetDBInstanceTopologyOutcomeCallable getDBInstanceTopologyCallable(const Model::GetDBInstanceTopologyRequest& request) const;
+			GetDbProxyInstanceSslOutcome getDbProxyInstanceSsl(const Model::GetDbProxyInstanceSslRequest &request)const;
+			void getDbProxyInstanceSslAsync(const Model::GetDbProxyInstanceSslRequest& request, const GetDbProxyInstanceSslAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			GetDbProxyInstanceSslOutcomeCallable getDbProxyInstanceSslCallable(const Model::GetDbProxyInstanceSslRequest& request) const;
 			GrantAccountPrivilegeOutcome grantAccountPrivilege(const Model::GrantAccountPrivilegeRequest &request)const;
 			void grantAccountPrivilegeAsync(const Model::GrantAccountPrivilegeRequest& request, const GrantAccountPrivilegeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			GrantAccountPrivilegeOutcomeCallable grantAccountPrivilegeCallable(const Model::GrantAccountPrivilegeRequest& request) const;
@@ -1554,6 +1601,9 @@ namespace AlibabaCloud
 			LockAccountOutcome lockAccount(const Model::LockAccountRequest &request)const;
 			void lockAccountAsync(const Model::LockAccountRequest& request, const LockAccountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			LockAccountOutcomeCallable lockAccountCallable(const Model::LockAccountRequest& request) const;
+			MigrateConnectionToOtherZoneOutcome migrateConnectionToOtherZone(const Model::MigrateConnectionToOtherZoneRequest &request)const;
+			void migrateConnectionToOtherZoneAsync(const Model::MigrateConnectionToOtherZoneRequest& request, const MigrateConnectionToOtherZoneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			MigrateConnectionToOtherZoneOutcomeCallable migrateConnectionToOtherZoneCallable(const Model::MigrateConnectionToOtherZoneRequest& request) const;
 			MigrateDBInstanceOutcome migrateDBInstance(const Model::MigrateDBInstanceRequest &request)const;
 			void migrateDBInstanceAsync(const Model::MigrateDBInstanceRequest& request, const MigrateDBInstanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			MigrateDBInstanceOutcomeCallable migrateDBInstanceCallable(const Model::MigrateDBInstanceRequest& request) const;
@@ -1641,6 +1691,9 @@ namespace AlibabaCloud
 			ModifyDasInstanceConfigOutcome modifyDasInstanceConfig(const Model::ModifyDasInstanceConfigRequest &request)const;
 			void modifyDasInstanceConfigAsync(const Model::ModifyDasInstanceConfigRequest& request, const ModifyDasInstanceConfigAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ModifyDasInstanceConfigOutcomeCallable modifyDasInstanceConfigCallable(const Model::ModifyDasInstanceConfigRequest& request) const;
+			ModifyDbProxyInstanceSslOutcome modifyDbProxyInstanceSsl(const Model::ModifyDbProxyInstanceSslRequest &request)const;
+			void modifyDbProxyInstanceSslAsync(const Model::ModifyDbProxyInstanceSslRequest& request, const ModifyDbProxyInstanceSslAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyDbProxyInstanceSslOutcomeCallable modifyDbProxyInstanceSslCallable(const Model::ModifyDbProxyInstanceSslRequest& request) const;
 			ModifyDedicatedHostAccountOutcome modifyDedicatedHostAccount(const Model::ModifyDedicatedHostAccountRequest &request)const;
 			void modifyDedicatedHostAccountAsync(const Model::ModifyDedicatedHostAccountRequest& request, const ModifyDedicatedHostAccountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ModifyDedicatedHostAccountOutcomeCallable modifyDedicatedHostAccountCallable(const Model::ModifyDedicatedHostAccountRequest& request) const;
@@ -1662,6 +1715,9 @@ namespace AlibabaCloud
 			ModifyInstanceCrossBackupPolicyOutcome modifyInstanceCrossBackupPolicy(const Model::ModifyInstanceCrossBackupPolicyRequest &request)const;
 			void modifyInstanceCrossBackupPolicyAsync(const Model::ModifyInstanceCrossBackupPolicyRequest& request, const ModifyInstanceCrossBackupPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ModifyInstanceCrossBackupPolicyOutcomeCallable modifyInstanceCrossBackupPolicyCallable(const Model::ModifyInstanceCrossBackupPolicyRequest& request) const;
+			ModifyLicenseInfoOutcome modifyLicenseInfo(const Model::ModifyLicenseInfoRequest &request)const;
+			void modifyLicenseInfoAsync(const Model::ModifyLicenseInfoRequest& request, const ModifyLicenseInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyLicenseInfoOutcomeCallable modifyLicenseInfoCallable(const Model::ModifyLicenseInfoRequest& request) const;
 			ModifyParameterOutcome modifyParameter(const Model::ModifyParameterRequest &request)const;
 			void modifyParameterAsync(const Model::ModifyParameterRequest& request, const ModifyParameterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ModifyParameterOutcomeCallable modifyParameterCallable(const Model::ModifyParameterRequest& request) const;

rds/include/alibabacloud/rds/model/CheckRegionSupportBackupEncryptionRequest.h

@@ -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_RDS_MODEL_CHECKREGIONSUPPORTBACKUPENCRYPTIONREQUEST_H_
+#define ALIBABACLOUD_RDS_MODEL_CHECKREGIONSUPPORTBACKUPENCRYPTIONREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/rds/RdsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rds
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RDS_EXPORT CheckRegionSupportBackupEncryptionRequest : public RpcServiceRequest
+			{
+
+			public:
+				CheckRegionSupportBackupEncryptionRequest();
+				~CheckRegionSupportBackupEncryptionRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getDBInstanceID()const;
+				void setDBInstanceID(const std::string& dBInstanceID);
+
+            private:
+				long resourceOwnerId_;
+				std::string resourceOwnerAccount_;
+				long ownerId_;
+				std::string accessKeyId_;
+				std::string regionId_;
+				std::string dBInstanceID_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RDS_MODEL_CHECKREGIONSUPPORTBACKUPENCRYPTIONREQUEST_H_

rds/include/alibabacloud/rds/model/CheckRegionSupportBackupEncryptionResult.h

@@ -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_RDS_MODEL_CHECKREGIONSUPPORTBACKUPENCRYPTIONRESULT_H_
+#define ALIBABACLOUD_RDS_MODEL_CHECKREGIONSUPPORTBACKUPENCRYPTIONRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/rds/RdsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rds
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RDS_EXPORT CheckRegionSupportBackupEncryptionResult : public ServiceResult
+			{
+			public:
+
+
+				CheckRegionSupportBackupEncryptionResult();
+				explicit CheckRegionSupportBackupEncryptionResult(const std::string &payload);
+				~CheckRegionSupportBackupEncryptionResult();
+				bool getSupportBackupEncryption()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				bool supportBackupEncryption_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RDS_MODEL_CHECKREGIONSUPPORTBACKUPENCRYPTIONRESULT_H_

rds/include/alibabacloud/rds/model/DescribeAvailableClassesRequest.h

@@ -53,10 +53,14 @@ namespace AlibabaCloud
 				void setDBInstanceStorageType(const std::string& dBInstanceStorageType);
 				std::string getInstanceChargeType()const;
 				void setInstanceChargeType(const std::string& instanceChargeType);
+				std::string getDispenseMode()const;
+				void setDispenseMode(const std::string& dispenseMode);
 				std::string getResourceOwnerAccount()const;
 				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
 				std::string getOwnerAccount()const;
 				void setOwnerAccount(const std::string& ownerAccount);
+				std::string getCommodityCode()const;
+				void setCommodityCode(const std::string& commodityCode);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
 				bool getEvaluateResource()const;
@@ -78,8 +82,10 @@ namespace AlibabaCloud
 				std::string dBInstanceId_;
 				std::string dBInstanceStorageType_;
 				std::string instanceChargeType_;
+				std::string dispenseMode_;
 				std::string resourceOwnerAccount_;
 				std::string ownerAccount_;
+				std::string commodityCode_;
 				long ownerId_;
 				bool evaluateResource_;
 				std::string zoneId_;

rds/include/alibabacloud/rds/model/DescribeAvailableZonesRequest.h

@@ -47,8 +47,12 @@ namespace AlibabaCloud
 				void setEngine(const std::string& engine);
 				std::string getInstanceChargeType()const;
 				void setInstanceChargeType(const std::string& instanceChargeType);
+				std::string getDispenseMode()const;
+				void setDispenseMode(const std::string& dispenseMode);
 				std::string getResourceOwnerAccount()const;
 				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getCommodityCode()const;
+				void setCommodityCode(const std::string& commodityCode);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
 				bool getEvaluateResource()const;
@@ -63,7 +67,9 @@ namespace AlibabaCloud
 				std::string regionId_;
 				std::string engine_;
 				std::string instanceChargeType_;
+				std::string dispenseMode_;
 				std::string resourceOwnerAccount_;
+				std::string commodityCode_;
 				long ownerId_;
 				bool evaluateResource_;
 				std::string zoneId_;

rds/include/alibabacloud/rds/model/DescribeBackupsResult.h

@@ -36,6 +36,7 @@ namespace AlibabaCloud
 				{
 					std::string backupMode;
 					std::string backupId;
+					std::string encryption;
 					std::string backupDBNames;
 					std::string dBInstanceId;
 					std::string backupType;

rds/include/alibabacloud/rds/model/DescribeDBInstanceDetailRequest.h

@@ -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_RDS_MODEL_DESCRIBEDBINSTANCEDETAILREQUEST_H_
+#define ALIBABACLOUD_RDS_MODEL_DESCRIBEDBINSTANCEDETAILREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/rds/RdsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rds
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RDS_EXPORT DescribeDBInstanceDetailRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeDBInstanceDetailRequest();
+				~DescribeDBInstanceDetailRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getDBInstanceId()const;
+				void setDBInstanceId(const std::string& dBInstanceId);
+
+            private:
+				long resourceOwnerId_;
+				std::string resourceOwnerAccount_;
+				std::string clientToken_;
+				long ownerId_;
+				std::string accessKeyId_;
+				std::string dBInstanceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RDS_MODEL_DESCRIBEDBINSTANCEDETAILREQUEST_H_

rds/include/alibabacloud/rds/model/DescribeDBInstanceDetailResult.h

@@ -0,0 +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_RDS_MODEL_DESCRIBEDBINSTANCEDETAILRESULT_H_
+#define ALIBABACLOUD_RDS_MODEL_DESCRIBEDBINSTANCEDETAILRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/rds/RdsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rds
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RDS_EXPORT DescribeDBInstanceDetailResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeDBInstanceDetailResult();
+				explicit DescribeDBInstanceDetailResult(const std::string &payload);
+				~DescribeDBInstanceDetailResult();
+				std::string getDBInstanceId()const;
+				std::string getActivationState()const;
+				std::string getRegionId()const;
+				std::string getLicenseType()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string dBInstanceId_;
+				std::string activationState_;
+				std::string regionId_;
+				std::string licenseType_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RDS_MODEL_DESCRIBEDBINSTANCEDETAILRESULT_H_

rds/include/alibabacloud/rds/model/DescribeDBInstanceNetInfoRequest.h

@@ -37,8 +37,8 @@ namespace AlibabaCloud
 
 				long getResourceOwnerId()const;
 				void setResourceOwnerId(long resourceOwnerId);
-				std::string getFlag()const;
-				void setFlag(const std::string& flag);
+				int getFlag()const;
+				void setFlag(int flag);
 				std::string getClientToken()const;
 				void setClientToken(const std::string& clientToken);
 				std::string getAccessKeyId()const;
@@ -56,7 +56,7 @@ namespace AlibabaCloud
 
             private:
 				long resourceOwnerId_;
-				std::string flag_;
+				int flag_;
 				std::string clientToken_;
 				std::string accessKeyId_;
 				std::string dBInstanceId_;

rds/include/alibabacloud/rds/model/DescribeDBInstancesOverviewRequest.h

@@ -41,6 +41,8 @@ namespace AlibabaCloud
 				void setClientToken(const std::string& clientToken);
 				std::string getAccessKeyId()const;
 				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getResourceGroupId()const;
+				void setResourceGroupId(const std::string& resourceGroupId);
 				std::string getExpired()const;
 				void setExpired(const std::string& expired);
 				std::string getEngine()const;
@@ -62,6 +64,7 @@ namespace AlibabaCloud
 				long resourceOwnerId_;
 				std::string clientToken_;
 				std::string accessKeyId_;
+				std::string resourceGroupId_;
 				std::string expired_;
 				std::string engine_;
 				std::string regionId_;

rds/include/alibabacloud/rds/model/DescribeDBInstancesRequest.h

@@ -41,6 +41,8 @@ namespace AlibabaCloud
 				void setResourceOwnerId(long resourceOwnerId);
 				std::string getTag2key()const;
 				void setTag2key(const std::string& tag2key);
+				bool getNeedVpcName()const;
+				void setNeedVpcName(bool needVpcName);
 				std::string getTag3key()const;
 				void setTag3key(const std::string& tag3key);
 				std::string getEngineVersion()const;
@@ -118,6 +120,7 @@ namespace AlibabaCloud
 				std::string tag4value_;
 				long resourceOwnerId_;
 				std::string tag2key_;
+				bool needVpcName_;
 				std::string tag3key_;
 				std::string engineVersion_;
 				std::string tag1value_;

rds/include/alibabacloud/rds/model/DescribeDBInstancesResult.h

@@ -65,6 +65,7 @@ namespace AlibabaCloud
 					std::string dBInstanceClass;
 					std::string createTime;
 					std::string vSwitchId;
+					std::string dedicatedHostGroupName;
 					std::string payType;
 					std::string lockMode;
 					std::string guardDBInstanceId;
@@ -76,6 +77,7 @@ namespace AlibabaCloud
 					std::string connectionMode;
 					std::string dedicatedHostZoneIdForLog;
 					std::string vpcCloudInstanceId;
+					std::string vpcName;
 					std::string regionId;
 					std::string expireTime;
 					std::string dedicatedHostIdForMaster;

rds/include/alibabacloud/rds/model/DescribeErrorLogsResult.h

@@ -34,8 +34,8 @@ namespace AlibabaCloud
 			public:
 				struct ErrorLog
 				{
-					std::string errorInfo;
 					std::string createTime;
+					std::string errorInfo;
 				};
 
 

rds/include/alibabacloud/rds/model/DescribeSlowLogRecordsResult.h

@@ -34,15 +34,24 @@ namespace AlibabaCloud
 			public:
 				struct SQLSlowRecord
 				{
-					long queryTimes;
+					long writeIOCount;
+					std::string userName;
+					std::string applicationName;
 					std::string executionStartTime;
-					long returnRowCounts;
-					long lockTimes;
-					std::string dBName;
+					long lastRowsAffectedCount;
+					long rowsAffectedCount;
 					long parseRowCounts;
+					long physicalIORead;
 					std::string hostAddress;
 					long queryTimeMS;
+					long cpuTime;
+					long logicalIORead;
 					std::string sQLText;
+					long queryTimes;
+					long returnRowCounts;
+					long lockTimes;
+					std::string dBName;
+					std::string clientHostName;
 				};
 
 
@@ -51,6 +60,14 @@ namespace AlibabaCloud
 				~DescribeSlowLogRecordsResult();
 				int getTotalRecordCount()const;
 				int getPageRecordCount()const;
+				std::string getUserName()const;
+				long getLastRowsAffectedCount()const;
+				long getRowsAffectedCount()const;
+				long getPhysicalIORead()const;
+				long getWritesIOCount()const;
+				long getLogicalIORead()const;
+				long getCPUTime()const;
+				std::string getSQLHash()const;
 				std::string getDBInstanceId()const;
 				int getPageNumber()const;
 				std::vector<SQLSlowRecord> getItems()const;
@@ -61,6 +78,14 @@ namespace AlibabaCloud
 			private:
 				int totalRecordCount_;
 				int pageRecordCount_;
+				std::string userName_;
+				long lastRowsAffectedCount_;
+				long rowsAffectedCount_;
+				long physicalIORead_;
+				long writesIOCount_;
+				long logicalIORead_;
+				long cPUTime_;
+				std::string sQLHash_;
 				std::string dBInstanceId_;
 				int pageNumber_;
 				std::vector<SQLSlowRecord> items_;

rds/include/alibabacloud/rds/model/DescribeSlowLogsResult.h

@@ -34,27 +34,52 @@ namespace AlibabaCloud
 			public:
 				struct SQLSlowLog
 				{
-					long maxLockTime;
-					std::string createTime;
-					long slowLogId;
+					long minLogicalReadCounts;
+					long avgLastRowsAffectedCounts;
 					long totalPhysicalReadCounts;
-					long totalLogicalReadCounts;
 					long totalLockTimes;
-					long returnMaxRowCount;
 					long avgExecutionTime;
 					std::string sQLText;
 					long parseMaxRowCount;
+					long maxLogicalReadCounts;
+					long avgIOWriteCounts;
+					std::string sQLHASH;
+					long minPhysicalReadCounts;
+					long sQLServerMaxCpuTime;
+					long minRowsAffectedCounts;
+					long maxIOWriteCounts;
+					long minIOWriteCounts;
+					long sQLServerTotalExecutionCounts;
+					long sQLServerAvgExecutionTime;
+					long totalIOWriteCounts;
+					long sQLServerAvgCpuTime;
+					long mySQLTotalExecutionTimes;
+					long totalLastRowsAffectedCounts;
+					long maxRowsAffectedCounts;
+					long maxLockTime;
+					long sQLServerMinExecutionTime;
+					long sQLServerTotalCpuTime;
+					std::string createTime;
+					long maxLastRowsAffectedCounts;
+					long slowLogId;
+					long totalPhysicalReadCounts1;
+					long totalLogicalReadCounts;
+					long returnMaxRowCount;
 					long maxExecutionTime;
+					long minLastRowsAffectedCounts;
 					std::string reportTime;
-					std::string sQLHASH;
 					long sQLServerTotalExecutionTimes;
+					long avgLogicalReadCounts;
 					std::string sQLIdStr;
 					long returnTotalRowCounts;
-					long sQLServerTotalExecutionCounts;
+					long avgPhysicalReadCounts;
+					long totalRowsAffectedCounts;
 					long mySQLTotalExecutionCounts;
 					long parseTotalRowCounts;
 					std::string dBName;
-					long mySQLTotalExecutionTimes;
+					long avgRowsAffectedCounts;
+					long sQLServerMinCpuTime;
+					long maxPhysicalReadCounts;
 				};
 
 

rds/include/alibabacloud/rds/model/GetDBInstanceTopologyRequest.h

@@ -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_RDS_MODEL_GETDBINSTANCETOPOLOGYREQUEST_H_
+#define ALIBABACLOUD_RDS_MODEL_GETDBINSTANCETOPOLOGYREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/rds/RdsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rds
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RDS_EXPORT GetDBInstanceTopologyRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetDBInstanceTopologyRequest();
+				~GetDBInstanceTopologyRequest();
+
+				std::string getDBInstanceId()const;
+				void setDBInstanceId(const std::string& dBInstanceId);
+
+            private:
+				std::string dBInstanceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RDS_MODEL_GETDBINSTANCETOPOLOGYREQUEST_H_

rds/include/alibabacloud/rds/model/GetDBInstanceTopologyResult.h

@@ -0,0 +1,74 @@
+/*
+ * 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_RDS_MODEL_GETDBINSTANCETOPOLOGYRESULT_H_
+#define ALIBABACLOUD_RDS_MODEL_GETDBINSTANCETOPOLOGYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/rds/RdsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rds
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RDS_EXPORT GetDBInstanceTopologyResult : public ServiceResult
+			{
+			public:
+				struct Data
+				{
+					struct Connection
+					{
+						std::string zoneId;
+						std::string connectionString;
+						std::string netType;
+					};
+					struct Node
+					{
+						std::string role;
+						std::string dedicatedHostId;
+						std::string zoneId;
+						std::string dedicatedHostGroupId;
+					};
+					std::vector<Connection> connections;
+					std::vector<Node> nodes;
+					std::string dBInstanceName;
+				};
+
+
+				GetDBInstanceTopologyResult();
+				explicit GetDBInstanceTopologyResult(const std::string &payload);
+				~GetDBInstanceTopologyResult();
+				std::string getMessage()const;
+				Data getData()const;
+				std::string getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				Data data_;
+				std::string code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RDS_MODEL_GETDBINSTANCETOPOLOGYRESULT_H_

rds/include/alibabacloud/rds/model/GetDbProxyInstanceSslRequest.h

@@ -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_RDS_MODEL_GETDBPROXYINSTANCESSLREQUEST_H_
+#define ALIBABACLOUD_RDS_MODEL_GETDBPROXYINSTANCESSLREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/rds/RdsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rds
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RDS_EXPORT GetDbProxyInstanceSslRequest : public RpcServiceRequest
+			{
+
+			public:
+				GetDbProxyInstanceSslRequest();
+				~GetDbProxyInstanceSslRequest();
+
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getDbInstanceId()const;
+				void setDbInstanceId(const std::string& dbInstanceId);
+
+            private:
+				std::string accessKeyId_;
+				std::string regionId_;
+				std::string dbInstanceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RDS_MODEL_GETDBPROXYINSTANCESSLREQUEST_H_

rds/include/alibabacloud/rds/model/GetDbProxyInstanceSslResult.h

@@ -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_RDS_MODEL_GETDBPROXYINSTANCESSLRESULT_H_
+#define ALIBABACLOUD_RDS_MODEL_GETDBPROXYINSTANCESSLRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/rds/RdsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rds
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RDS_EXPORT GetDbProxyInstanceSslResult : public ServiceResult
+			{
+			public:
+				struct DbProxyCertListItemsItem
+				{
+					std::string endpointName;
+					std::string endpointType;
+					std::string certCommonName;
+					std::string sslExpiredTime;
+					std::string dbInstanceName;
+				};
+
+
+				GetDbProxyInstanceSslResult();
+				explicit GetDbProxyInstanceSslResult(const std::string &payload);
+				~GetDbProxyInstanceSslResult();
+				std::vector<DbProxyCertListItemsItem> getDbProxyCertListItems()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<DbProxyCertListItemsItem> dbProxyCertListItems_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RDS_MODEL_GETDBPROXYINSTANCESSLRESULT_H_

rds/include/alibabacloud/rds/model/MigrateConnectionToOtherZoneRequest.h

@@ -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_RDS_MODEL_MIGRATECONNECTIONTOOTHERZONEREQUEST_H_
+#define ALIBABACLOUD_RDS_MODEL_MIGRATECONNECTIONTOOTHERZONEREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/rds/RdsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rds
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RDS_EXPORT MigrateConnectionToOtherZoneRequest : public RpcServiceRequest
+			{
+
+			public:
+				MigrateConnectionToOtherZoneRequest();
+				~MigrateConnectionToOtherZoneRequest();
+
+				std::string getConnectionString()const;
+				void setConnectionString(const std::string& connectionString);
+				std::string getZoneId()const;
+				void setZoneId(const std::string& zoneId);
+				std::string getDBInstanceId()const;
+				void setDBInstanceId(const std::string& dBInstanceId);
+
+            private:
+				std::string connectionString_;
+				std::string zoneId_;
+				std::string dBInstanceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RDS_MODEL_MIGRATECONNECTIONTOOTHERZONEREQUEST_H_

rds/include/alibabacloud/rds/model/MigrateConnectionToOtherZoneResult.h

@@ -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_RDS_MODEL_MIGRATECONNECTIONTOOTHERZONERESULT_H_
+#define ALIBABACLOUD_RDS_MODEL_MIGRATECONNECTIONTOOTHERZONERESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/rds/RdsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rds
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RDS_EXPORT MigrateConnectionToOtherZoneResult : public ServiceResult
+			{
+			public:
+
+
+				MigrateConnectionToOtherZoneResult();
+				explicit MigrateConnectionToOtherZoneResult(const std::string &payload);
+				~MigrateConnectionToOtherZoneResult();
+				std::string getMessage()const;
+				std::string getCode()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string message_;
+				std::string code_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RDS_MODEL_MIGRATECONNECTIONTOOTHERZONERESULT_H_

rds/include/alibabacloud/rds/model/MigrateDBInstanceRequest.h

@@ -49,6 +49,8 @@ namespace AlibabaCloud
 				void setEngineVersion(const std::string& engineVersion);
 				int getStorage()const;
 				void setStorage(int storage);
+				std::string getZoneIdForFollower()const;
+				void setZoneIdForFollower(const std::string& zoneIdForFollower);
 				std::string getAccessKeyId()const;
 				void setAccessKeyId(const std::string& accessKeyId);
 				std::string getRegionId()const;
@@ -65,6 +67,8 @@ namespace AlibabaCloud
 				void setDedicatedHostGroupId(const std::string& dedicatedHostGroupId);
 				std::string getResourceOwnerAccount()const;
 				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getZoneIdForLog()const;
+				void setZoneIdForLog(const std::string& zoneIdForLog);
 				long getOwnerId()const;
 				void setOwnerId(long ownerId);
 				std::string getTargetDBInstanceClass()const;
@@ -84,6 +88,7 @@ namespace AlibabaCloud
 				std::string zoneIdSlave2_;
 				std::string engineVersion_;
 				int storage_;
+				std::string zoneIdForFollower_;
 				std::string accessKeyId_;
 				std::string regionId_;
 				std::string effectiveTime_;
@@ -92,6 +97,7 @@ namespace AlibabaCloud
 				std::string dBInstanceId_;
 				std::string dedicatedHostGroupId_;
 				std::string resourceOwnerAccount_;
+				std::string zoneIdForLog_;
 				long ownerId_;
 				std::string targetDBInstanceClass_;
 				std::string vSwitchId_;

rds/include/alibabacloud/rds/model/ModifyDbProxyInstanceSslRequest.h

@@ -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_RDS_MODEL_MODIFYDBPROXYINSTANCESSLREQUEST_H_
+#define ALIBABACLOUD_RDS_MODEL_MODIFYDBPROXYINSTANCESSLREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/rds/RdsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rds
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RDS_EXPORT ModifyDbProxyInstanceSslRequest : public RpcServiceRequest
+			{
+
+			public:
+				ModifyDbProxyInstanceSslRequest();
+				~ModifyDbProxyInstanceSslRequest();
+
+				std::string getDbProxySslEnabled()const;
+				void setDbProxySslEnabled(const std::string& dbProxySslEnabled);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getDbProxyConnectString()const;
+				void setDbProxyConnectString(const std::string& dbProxyConnectString);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				std::string getDbInstanceId()const;
+				void setDbInstanceId(const std::string& dbInstanceId);
+				std::string getDbProxyEndpointId()const;
+				void setDbProxyEndpointId(const std::string& dbProxyEndpointId);
+
+            private:
+				std::string dbProxySslEnabled_;
+				std::string accessKeyId_;
+				std::string dbProxyConnectString_;
+				std::string regionId_;
+				std::string dbInstanceId_;
+				std::string dbProxyEndpointId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RDS_MODEL_MODIFYDBPROXYINSTANCESSLREQUEST_H_

rds/include/alibabacloud/rds/model/ModifyDbProxyInstanceSslResult.h

@@ -0,0 +1,49 @@
+/*
+ * 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_RDS_MODEL_MODIFYDBPROXYINSTANCESSLRESULT_H_
+#define ALIBABACLOUD_RDS_MODEL_MODIFYDBPROXYINSTANCESSLRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/rds/RdsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rds
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RDS_EXPORT ModifyDbProxyInstanceSslResult : public ServiceResult
+			{
+			public:
+
+
+				ModifyDbProxyInstanceSslResult();
+				explicit ModifyDbProxyInstanceSslResult(const std::string &payload);
+				~ModifyDbProxyInstanceSslResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RDS_MODEL_MODIFYDBPROXYINSTANCESSLRESULT_H_

rds/include/alibabacloud/rds/model/ModifyLicenseInfoRequest.h

@@ -0,0 +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_RDS_MODEL_MODIFYLICENSEINFOREQUEST_H_
+#define ALIBABACLOUD_RDS_MODEL_MODIFYLICENSEINFOREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/rds/RdsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rds
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RDS_EXPORT ModifyLicenseInfoRequest : public RpcServiceRequest
+			{
+
+			public:
+				ModifyLicenseInfoRequest();
+				~ModifyLicenseInfoRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getClientToken()const;
+				void setClientToken(const std::string& clientToken);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getLicense()const;
+				void setLicense(const std::string& license);
+				std::string getDBInstanceId()const;
+				void setDBInstanceId(const std::string& dBInstanceId);
+
+            private:
+				long resourceOwnerId_;
+				std::string resourceOwnerAccount_;
+				std::string clientToken_;
+				long ownerId_;
+				std::string accessKeyId_;
+				std::string license_;
+				std::string dBInstanceId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RDS_MODEL_MODIFYLICENSEINFOREQUEST_H_

rds/include/alibabacloud/rds/model/ModifyLicenseInfoResult.h

@@ -0,0 +1,49 @@
+/*
+ * 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_RDS_MODEL_MODIFYLICENSEINFORESULT_H_
+#define ALIBABACLOUD_RDS_MODEL_MODIFYLICENSEINFORESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/rds/RdsExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Rds
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_RDS_EXPORT ModifyLicenseInfoResult : public ServiceResult
+			{
+			public:
+
+
+				ModifyLicenseInfoResult();
+				explicit ModifyLicenseInfoResult(const std::string &payload);
+				~ModifyLicenseInfoResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_RDS_MODEL_MODIFYLICENSEINFORESULT_H_

rds/include/alibabacloud/rds/model/RebuildDBInstanceRequest.h

@@ -37,6 +37,8 @@ namespace AlibabaCloud
 
 				long getResourceOwnerId()const;
 				void setResourceOwnerId(long resourceOwnerId);
+				std::string getRebuildNodeType()const;
+				void setRebuildNodeType(const std::string& rebuildNodeType);
 				std::string getAccessKeyId()const;
 				void setAccessKeyId(const std::string& accessKeyId);
 				std::string getRegionId()const;
@@ -54,6 +56,7 @@ namespace AlibabaCloud
 
             private:
 				long resourceOwnerId_;
+				std::string rebuildNodeType_;
 				std::string accessKeyId_;
 				std::string regionId_;
 				std::string dBInstanceId_;

rds/include/alibabacloud/rds/model/UpgradeDBInstanceKernelVersionRequest.h

@@ -37,27 +37,30 @@ namespace AlibabaCloud
 
 				long getResourceOwnerId()const;
 				void setResourceOwnerId(long resourceOwnerId);
-				std::string getResourceOwnerAccount()const;
-				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
-				long getOwnerId()const;
-				void setOwnerId(long ownerId);
 				std::string getAccessKeyId()const;
 				void setAccessKeyId(const std::string& accessKeyId);
-				std::string getUpgradeTime()const;
-				void setUpgradeTime(const std::string& upgradeTime);
 				std::string getDBInstanceId()const;
 				void setDBInstanceId(const std::string& dBInstanceId);
 				std::string getSwitchTime()const;
 				void setSwitchTime(const std::string& switchTime);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getTargetMinorVersion()const;
+				void setTargetMinorVersion(const std::string& targetMinorVersion);
+				std::string getUpgradeTime()const;
+				void setUpgradeTime(const std::string& upgradeTime);
 
             private:
 				long resourceOwnerId_;
-				std::string resourceOwnerAccount_;
-				long ownerId_;
 				std::string accessKeyId_;
-				std::string upgradeTime_;
 				std::string dBInstanceId_;
 				std::string switchTime_;
+				std::string resourceOwnerAccount_;
+				long ownerId_;
+				std::string targetMinorVersion_;
+				std::string upgradeTime_;
 
 			};
 		}

rds/src/RdsClient.cc

@@ -31,21 +31,21 @@ RdsClient::RdsClient(const Credentials &credentials, const ClientConfiguration &
 	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(credentials), configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(credentials, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "rds");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
 }
 
 RdsClient::RdsClient(const std::shared_ptr<CredentialsProvider>& credentialsProvider, const ClientConfiguration & configuration) :
 	RpcServiceClient(SERVICE_NAME, credentialsProvider, configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(credentialsProvider, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "rds");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
 }
 
 RdsClient::RdsClient(const std::string & accessKeyId, const std::string & accessKeySecret, const ClientConfiguration & configuration) :
 	RpcServiceClient(SERVICE_NAME, std::make_shared<SimpleCredentialsProvider>(accessKeyId, accessKeySecret), configuration)
 {
 	auto locationClient = std::make_shared<LocationClient>(accessKeyId, accessKeySecret, configuration);
-	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "rds");
+	endpointProvider_ = std::make_shared<EndpointProvider>(locationClient, configuration.regionId(), SERVICE_NAME, "");
 }
 
 RdsClient::~RdsClient()
@@ -447,6 +447,42 @@ RdsClient::CheckRecoveryConditionsOutcomeCallable RdsClient::checkRecoveryCondit
 	return task->get_future();
 }
 
+RdsClient::CheckRegionSupportBackupEncryptionOutcome RdsClient::checkRegionSupportBackupEncryption(const CheckRegionSupportBackupEncryptionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CheckRegionSupportBackupEncryptionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CheckRegionSupportBackupEncryptionOutcome(CheckRegionSupportBackupEncryptionResult(outcome.result()));
+	else
+		return CheckRegionSupportBackupEncryptionOutcome(outcome.error());
+}
+
+void RdsClient::checkRegionSupportBackupEncryptionAsync(const CheckRegionSupportBackupEncryptionRequest& request, const CheckRegionSupportBackupEncryptionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, checkRegionSupportBackupEncryption(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+RdsClient::CheckRegionSupportBackupEncryptionOutcomeCallable RdsClient::checkRegionSupportBackupEncryptionCallable(const CheckRegionSupportBackupEncryptionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CheckRegionSupportBackupEncryptionOutcome()>>(
+			[this, request]()
+			{
+			return this->checkRegionSupportBackupEncryption(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 RdsClient::ClearDedicatedHostOutcome RdsClient::clearDedicatedHost(const ClearDedicatedHostRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2463,6 +2499,42 @@ RdsClient::DescribeDBInstanceByTagsOutcomeCallable RdsClient::describeDBInstance
 	return task->get_future();
 }
 
+RdsClient::DescribeDBInstanceDetailOutcome RdsClient::describeDBInstanceDetail(const DescribeDBInstanceDetailRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDBInstanceDetailOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDBInstanceDetailOutcome(DescribeDBInstanceDetailResult(outcome.result()));
+	else
+		return DescribeDBInstanceDetailOutcome(outcome.error());
+}
+
+void RdsClient::describeDBInstanceDetailAsync(const DescribeDBInstanceDetailRequest& request, const DescribeDBInstanceDetailAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDBInstanceDetail(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+RdsClient::DescribeDBInstanceDetailOutcomeCallable RdsClient::describeDBInstanceDetailCallable(const DescribeDBInstanceDetailRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDBInstanceDetailOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDBInstanceDetail(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 RdsClient::DescribeDBInstanceHAConfigOutcome RdsClient::describeDBInstanceHAConfig(const DescribeDBInstanceHAConfigRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -4947,6 +5019,78 @@ RdsClient::EvaluateDedicatedHostInstanceResourceOutcomeCallable RdsClient::evalu
 	return task->get_future();
 }
 
+RdsClient::GetDBInstanceTopologyOutcome RdsClient::getDBInstanceTopology(const GetDBInstanceTopologyRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetDBInstanceTopologyOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetDBInstanceTopologyOutcome(GetDBInstanceTopologyResult(outcome.result()));
+	else
+		return GetDBInstanceTopologyOutcome(outcome.error());
+}
+
+void RdsClient::getDBInstanceTopologyAsync(const GetDBInstanceTopologyRequest& request, const GetDBInstanceTopologyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getDBInstanceTopology(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+RdsClient::GetDBInstanceTopologyOutcomeCallable RdsClient::getDBInstanceTopologyCallable(const GetDBInstanceTopologyRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetDBInstanceTopologyOutcome()>>(
+			[this, request]()
+			{
+			return this->getDBInstanceTopology(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+RdsClient::GetDbProxyInstanceSslOutcome RdsClient::getDbProxyInstanceSsl(const GetDbProxyInstanceSslRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return GetDbProxyInstanceSslOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return GetDbProxyInstanceSslOutcome(GetDbProxyInstanceSslResult(outcome.result()));
+	else
+		return GetDbProxyInstanceSslOutcome(outcome.error());
+}
+
+void RdsClient::getDbProxyInstanceSslAsync(const GetDbProxyInstanceSslRequest& request, const GetDbProxyInstanceSslAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, getDbProxyInstanceSsl(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+RdsClient::GetDbProxyInstanceSslOutcomeCallable RdsClient::getDbProxyInstanceSslCallable(const GetDbProxyInstanceSslRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<GetDbProxyInstanceSslOutcome()>>(
+			[this, request]()
+			{
+			return this->getDbProxyInstanceSsl(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 RdsClient::GrantAccountPrivilegeOutcome RdsClient::grantAccountPrivilege(const GrantAccountPrivilegeRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -5127,6 +5271,42 @@ RdsClient::LockAccountOutcomeCallable RdsClient::lockAccountCallable(const LockA
 	return task->get_future();
 }
 
+RdsClient::MigrateConnectionToOtherZoneOutcome RdsClient::migrateConnectionToOtherZone(const MigrateConnectionToOtherZoneRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return MigrateConnectionToOtherZoneOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return MigrateConnectionToOtherZoneOutcome(MigrateConnectionToOtherZoneResult(outcome.result()));
+	else
+		return MigrateConnectionToOtherZoneOutcome(outcome.error());
+}
+
+void RdsClient::migrateConnectionToOtherZoneAsync(const MigrateConnectionToOtherZoneRequest& request, const MigrateConnectionToOtherZoneAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, migrateConnectionToOtherZone(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+RdsClient::MigrateConnectionToOtherZoneOutcomeCallable RdsClient::migrateConnectionToOtherZoneCallable(const MigrateConnectionToOtherZoneRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<MigrateConnectionToOtherZoneOutcome()>>(
+			[this, request]()
+			{
+			return this->migrateConnectionToOtherZone(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 RdsClient::MigrateDBInstanceOutcome RdsClient::migrateDBInstance(const MigrateDBInstanceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -6171,6 +6351,42 @@ RdsClient::ModifyDasInstanceConfigOutcomeCallable RdsClient::modifyDasInstanceCo
 	return task->get_future();
 }
 
+RdsClient::ModifyDbProxyInstanceSslOutcome RdsClient::modifyDbProxyInstanceSsl(const ModifyDbProxyInstanceSslRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifyDbProxyInstanceSslOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyDbProxyInstanceSslOutcome(ModifyDbProxyInstanceSslResult(outcome.result()));
+	else
+		return ModifyDbProxyInstanceSslOutcome(outcome.error());
+}
+
+void RdsClient::modifyDbProxyInstanceSslAsync(const ModifyDbProxyInstanceSslRequest& request, const ModifyDbProxyInstanceSslAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyDbProxyInstanceSsl(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+RdsClient::ModifyDbProxyInstanceSslOutcomeCallable RdsClient::modifyDbProxyInstanceSslCallable(const ModifyDbProxyInstanceSslRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyDbProxyInstanceSslOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyDbProxyInstanceSsl(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 RdsClient::ModifyDedicatedHostAccountOutcome RdsClient::modifyDedicatedHostAccount(const ModifyDedicatedHostAccountRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -6423,6 +6639,42 @@ RdsClient::ModifyInstanceCrossBackupPolicyOutcomeCallable RdsClient::modifyInsta
 	return task->get_future();
 }
 
+RdsClient::ModifyLicenseInfoOutcome RdsClient::modifyLicenseInfo(const ModifyLicenseInfoRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifyLicenseInfoOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyLicenseInfoOutcome(ModifyLicenseInfoResult(outcome.result()));
+	else
+		return ModifyLicenseInfoOutcome(outcome.error());
+}
+
+void RdsClient::modifyLicenseInfoAsync(const ModifyLicenseInfoRequest& request, const ModifyLicenseInfoAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyLicenseInfo(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+RdsClient::ModifyLicenseInfoOutcomeCallable RdsClient::modifyLicenseInfoCallable(const ModifyLicenseInfoRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyLicenseInfoOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyLicenseInfo(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 RdsClient::ModifyParameterOutcome RdsClient::modifyParameter(const ModifyParameterRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

rds/src/model/CheckRegionSupportBackupEncryptionRequest.cc

@@ -0,0 +1,95 @@
+/*
+ * 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.
+ */
+
+#include <alibabacloud/rds/model/CheckRegionSupportBackupEncryptionRequest.h>
+
+using AlibabaCloud::Rds::Model::CheckRegionSupportBackupEncryptionRequest;
+
+CheckRegionSupportBackupEncryptionRequest::CheckRegionSupportBackupEncryptionRequest() :
+	RpcServiceRequest("rds", "2014-08-15", "CheckRegionSupportBackupEncryption")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+CheckRegionSupportBackupEncryptionRequest::~CheckRegionSupportBackupEncryptionRequest()
+{}
+
+long CheckRegionSupportBackupEncryptionRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void CheckRegionSupportBackupEncryptionRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string CheckRegionSupportBackupEncryptionRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void CheckRegionSupportBackupEncryptionRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+long CheckRegionSupportBackupEncryptionRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void CheckRegionSupportBackupEncryptionRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string CheckRegionSupportBackupEncryptionRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void CheckRegionSupportBackupEncryptionRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string CheckRegionSupportBackupEncryptionRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void CheckRegionSupportBackupEncryptionRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string CheckRegionSupportBackupEncryptionRequest::getDBInstanceID()const
+{
+	return dBInstanceID_;
+}
+
+void CheckRegionSupportBackupEncryptionRequest::setDBInstanceID(const std::string& dBInstanceID)
+{
+	dBInstanceID_ = dBInstanceID;
+	setParameter("DBInstanceID", dBInstanceID);
+}
+

rds/src/model/CheckRegionSupportBackupEncryptionResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/rds/model/CheckRegionSupportBackupEncryptionResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Rds;
+using namespace AlibabaCloud::Rds::Model;
+
+CheckRegionSupportBackupEncryptionResult::CheckRegionSupportBackupEncryptionResult() :
+	ServiceResult()
+{}
+
+CheckRegionSupportBackupEncryptionResult::CheckRegionSupportBackupEncryptionResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+CheckRegionSupportBackupEncryptionResult::~CheckRegionSupportBackupEncryptionResult()
+{}
+
+void CheckRegionSupportBackupEncryptionResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["SupportBackupEncryption"].isNull())
+		supportBackupEncryption_ = value["SupportBackupEncryption"].asString() == "true";
+
+}
+
+bool CheckRegionSupportBackupEncryptionResult::getSupportBackupEncryption()const
+{
+	return supportBackupEncryption_;
+}
+

rds/src/model/DescribeAccountsResult.cc

@@ -55,16 +55,16 @@ void DescribeAccountsResult::parse(const std::string &payload)
 			accountsObject.accountDescription = valueAccountsDBInstanceAccount["AccountDescription"].asString();
 		if(!valueAccountsDBInstanceAccount["PrivExceeded"].isNull())
 			accountsObject.privExceeded = valueAccountsDBInstanceAccount["PrivExceeded"].asString();
-		auto allDatabasePrivilegesNode = allAccountsNode["DatabasePrivileges"]["DatabasePrivilege"];
-		for (auto allAccountsNodeDatabasePrivilegesDatabasePrivilege : allDatabasePrivilegesNode)
+		auto allDatabasePrivilegesNode = valueAccountsDBInstanceAccount["DatabasePrivileges"]["DatabasePrivilege"];
+		for (auto valueAccountsDBInstanceAccountDatabasePrivilegesDatabasePrivilege : allDatabasePrivilegesNode)
 		{
 			DBInstanceAccount::DatabasePrivilege databasePrivilegesObject;
-			if(!allAccountsNodeDatabasePrivilegesDatabasePrivilege["DBName"].isNull())
-				databasePrivilegesObject.dBName = allAccountsNodeDatabasePrivilegesDatabasePrivilege["DBName"].asString();
-			if(!allAccountsNodeDatabasePrivilegesDatabasePrivilege["AccountPrivilege"].isNull())
-				databasePrivilegesObject.accountPrivilege = allAccountsNodeDatabasePrivilegesDatabasePrivilege["AccountPrivilege"].asString();
-			if(!allAccountsNodeDatabasePrivilegesDatabasePrivilege["AccountPrivilegeDetail"].isNull())
-				databasePrivilegesObject.accountPrivilegeDetail = allAccountsNodeDatabasePrivilegesDatabasePrivilege["AccountPrivilegeDetail"].asString();
+			if(!valueAccountsDBInstanceAccountDatabasePrivilegesDatabasePrivilege["DBName"].isNull())
+				databasePrivilegesObject.dBName = valueAccountsDBInstanceAccountDatabasePrivilegesDatabasePrivilege["DBName"].asString();
+			if(!valueAccountsDBInstanceAccountDatabasePrivilegesDatabasePrivilege["AccountPrivilege"].isNull())
+				databasePrivilegesObject.accountPrivilege = valueAccountsDBInstanceAccountDatabasePrivilegesDatabasePrivilege["AccountPrivilege"].asString();
+			if(!valueAccountsDBInstanceAccountDatabasePrivilegesDatabasePrivilege["AccountPrivilegeDetail"].isNull())
+				databasePrivilegesObject.accountPrivilegeDetail = valueAccountsDBInstanceAccountDatabasePrivilegesDatabasePrivilege["AccountPrivilegeDetail"].asString();
 			accountsObject.databasePrivileges.push_back(databasePrivilegesObject);
 		}
 		accounts_.push_back(accountsObject);

rds/src/model/DescribeAvailableClassesRequest.cc

@@ -126,6 +126,17 @@ void DescribeAvailableClassesRequest::setInstanceChargeType(const std::string& i
 	setParameter("InstanceChargeType", instanceChargeType);
 }
 
+std::string DescribeAvailableClassesRequest::getDispenseMode()const
+{
+	return dispenseMode_;
+}
+
+void DescribeAvailableClassesRequest::setDispenseMode(const std::string& dispenseMode)
+{
+	dispenseMode_ = dispenseMode;
+	setParameter("DispenseMode", dispenseMode);
+}
+
 std::string DescribeAvailableClassesRequest::getResourceOwnerAccount()const
 {
 	return resourceOwnerAccount_;
@@ -148,6 +159,17 @@ void DescribeAvailableClassesRequest::setOwnerAccount(const std::string& ownerAc
 	setParameter("OwnerAccount", ownerAccount);
 }
 
+std::string DescribeAvailableClassesRequest::getCommodityCode()const
+{
+	return commodityCode_;
+}
+
+void DescribeAvailableClassesRequest::setCommodityCode(const std::string& commodityCode)
+{
+	commodityCode_ = commodityCode;
+	setParameter("CommodityCode", commodityCode);
+}
+
 long DescribeAvailableClassesRequest::getOwnerId()const
 {
 	return ownerId_;

rds/src/model/DescribeAvailableResourceResult.cc

@@ -51,38 +51,38 @@ void DescribeAvailableResourceResult::parse(const std::string &payload)
 			availableZonesObject.status = valueAvailableZonesAvailableZone["Status"].asString();
 		if(!valueAvailableZonesAvailableZone["NetworkTypes"].isNull())
 			availableZonesObject.networkTypes = valueAvailableZonesAvailableZone["NetworkTypes"].asString();
-		auto allSupportedEnginesNode = allAvailableZonesNode["SupportedEngines"]["SupportedEngine"];
-		for (auto allAvailableZonesNodeSupportedEnginesSupportedEngine : allSupportedEnginesNode)
+		auto allSupportedEnginesNode = valueAvailableZonesAvailableZone["SupportedEngines"]["SupportedEngine"];
+		for (auto valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngine : allSupportedEnginesNode)
 		{
 			AvailableZone::SupportedEngine supportedEnginesObject;
-			if(!allAvailableZonesNodeSupportedEnginesSupportedEngine["Engine"].isNull())
-				supportedEnginesObject.engine = allAvailableZonesNodeSupportedEnginesSupportedEngine["Engine"].asString();
-			auto allSupportedEngineVersionsNode = allSupportedEnginesNode["SupportedEngineVersions"]["SupportedEngineVersion"];
-			for (auto allSupportedEnginesNodeSupportedEngineVersionsSupportedEngineVersion : allSupportedEngineVersionsNode)
+			if(!valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngine["Engine"].isNull())
+				supportedEnginesObject.engine = valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngine["Engine"].asString();
+			auto allSupportedEngineVersionsNode = valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngine["SupportedEngineVersions"]["SupportedEngineVersion"];
+			for (auto valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngineSupportedEngineVersionsSupportedEngineVersion : allSupportedEngineVersionsNode)
 			{
 				AvailableZone::SupportedEngine::SupportedEngineVersion supportedEngineVersionsObject;
-				if(!allSupportedEnginesNodeSupportedEngineVersionsSupportedEngineVersion["Version"].isNull())
-					supportedEngineVersionsObject.version = allSupportedEnginesNodeSupportedEngineVersionsSupportedEngineVersion["Version"].asString();
-				auto allSupportedCategorysNode = allSupportedEngineVersionsNode["SupportedCategorys"]["SupportedCategory"];
-				for (auto allSupportedEngineVersionsNodeSupportedCategorysSupportedCategory : allSupportedCategorysNode)
+				if(!valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngineSupportedEngineVersionsSupportedEngineVersion["Version"].isNull())
+					supportedEngineVersionsObject.version = valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngineSupportedEngineVersionsSupportedEngineVersion["Version"].asString();
+				auto allSupportedCategorysNode = valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngineSupportedEngineVersionsSupportedEngineVersion["SupportedCategorys"]["SupportedCategory"];
+				for (auto valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngineSupportedEngineVersionsSupportedEngineVersionSupportedCategorysSupportedCategory : allSupportedCategorysNode)
 				{
 					AvailableZone::SupportedEngine::SupportedEngineVersion::SupportedCategory supportedCategorysObject;
-					if(!allSupportedEngineVersionsNodeSupportedCategorysSupportedCategory["Category"].isNull())
-						supportedCategorysObject.category = allSupportedEngineVersionsNodeSupportedCategorysSupportedCategory["Category"].asString();
-					auto allSupportedStorageTypesNode = allSupportedCategorysNode["SupportedStorageTypes"]["SupportedStorageType"];
-					for (auto allSupportedCategorysNodeSupportedStorageTypesSupportedStorageType : allSupportedStorageTypesNode)
+					if(!valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngineSupportedEngineVersionsSupportedEngineVersionSupportedCategorysSupportedCategory["Category"].isNull())
+						supportedCategorysObject.category = valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngineSupportedEngineVersionsSupportedEngineVersionSupportedCategorysSupportedCategory["Category"].asString();
+					auto allSupportedStorageTypesNode = valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngineSupportedEngineVersionsSupportedEngineVersionSupportedCategorysSupportedCategory["SupportedStorageTypes"]["SupportedStorageType"];
+					for (auto valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngineSupportedEngineVersionsSupportedEngineVersionSupportedCategorysSupportedCategorySupportedStorageTypesSupportedStorageType : allSupportedStorageTypesNode)
 					{
 						AvailableZone::SupportedEngine::SupportedEngineVersion::SupportedCategory::SupportedStorageType supportedStorageTypesObject;
-						if(!allSupportedCategorysNodeSupportedStorageTypesSupportedStorageType["StorageType"].isNull())
-							supportedStorageTypesObject.storageType = allSupportedCategorysNodeSupportedStorageTypesSupportedStorageType["StorageType"].asString();
-						auto allAvailableResourcesNode = allSupportedStorageTypesNode["AvailableResources"]["AvailableResource"];
-						for (auto allSupportedStorageTypesNodeAvailableResourcesAvailableResource : allAvailableResourcesNode)
+						if(!valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngineSupportedEngineVersionsSupportedEngineVersionSupportedCategorysSupportedCategorySupportedStorageTypesSupportedStorageType["StorageType"].isNull())
+							supportedStorageTypesObject.storageType = valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngineSupportedEngineVersionsSupportedEngineVersionSupportedCategorysSupportedCategorySupportedStorageTypesSupportedStorageType["StorageType"].asString();
+						auto allAvailableResourcesNode = valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngineSupportedEngineVersionsSupportedEngineVersionSupportedCategorysSupportedCategorySupportedStorageTypesSupportedStorageType["AvailableResources"]["AvailableResource"];
+						for (auto valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngineSupportedEngineVersionsSupportedEngineVersionSupportedCategorysSupportedCategorySupportedStorageTypesSupportedStorageTypeAvailableResourcesAvailableResource : allAvailableResourcesNode)
 						{
 							AvailableZone::SupportedEngine::SupportedEngineVersion::SupportedCategory::SupportedStorageType::AvailableResource availableResourcesObject;
-							if(!allSupportedStorageTypesNodeAvailableResourcesAvailableResource["DBInstanceClass"].isNull())
-								availableResourcesObject.dBInstanceClass = allSupportedStorageTypesNodeAvailableResourcesAvailableResource["DBInstanceClass"].asString();
-							if(!allSupportedStorageTypesNodeAvailableResourcesAvailableResource["StorageRange"].isNull())
-								availableResourcesObject.storageRange = allSupportedStorageTypesNodeAvailableResourcesAvailableResource["StorageRange"].asString();
+							if(!valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngineSupportedEngineVersionsSupportedEngineVersionSupportedCategorysSupportedCategorySupportedStorageTypesSupportedStorageTypeAvailableResourcesAvailableResource["DBInstanceClass"].isNull())
+								availableResourcesObject.dBInstanceClass = valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngineSupportedEngineVersionsSupportedEngineVersionSupportedCategorysSupportedCategorySupportedStorageTypesSupportedStorageTypeAvailableResourcesAvailableResource["DBInstanceClass"].asString();
+							if(!valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngineSupportedEngineVersionsSupportedEngineVersionSupportedCategorysSupportedCategorySupportedStorageTypesSupportedStorageTypeAvailableResourcesAvailableResource["StorageRange"].isNull())
+								availableResourcesObject.storageRange = valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngineSupportedEngineVersionsSupportedEngineVersionSupportedCategorysSupportedCategorySupportedStorageTypesSupportedStorageTypeAvailableResourcesAvailableResource["StorageRange"].asString();
 							auto dBInstanceStorageRangeNode = value["DBInstanceStorageRange"];
 							if(!dBInstanceStorageRangeNode["Max"].isNull())
 								availableResourcesObject.dBInstanceStorageRange.max = std::stoi(dBInstanceStorageRangeNode["Max"].asString());

rds/src/model/DescribeAvailableZonesRequest.cc

@@ -93,6 +93,17 @@ void DescribeAvailableZonesRequest::setInstanceChargeType(const std::string& ins
 	setParameter("InstanceChargeType", instanceChargeType);
 }
 
+std::string DescribeAvailableZonesRequest::getDispenseMode()const
+{
+	return dispenseMode_;
+}
+
+void DescribeAvailableZonesRequest::setDispenseMode(const std::string& dispenseMode)
+{
+	dispenseMode_ = dispenseMode;
+	setParameter("DispenseMode", dispenseMode);
+}
+
 std::string DescribeAvailableZonesRequest::getResourceOwnerAccount()const
 {
 	return resourceOwnerAccount_;
@@ -104,6 +115,17 @@ void DescribeAvailableZonesRequest::setResourceOwnerAccount(const std::string& r
 	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
+std::string DescribeAvailableZonesRequest::getCommodityCode()const
+{
+	return commodityCode_;
+}
+
+void DescribeAvailableZonesRequest::setCommodityCode(const std::string& commodityCode)
+{
+	commodityCode_ = commodityCode;
+	setParameter("CommodityCode", commodityCode);
+}
+
 long DescribeAvailableZonesRequest::getOwnerId()const
 {
 	return ownerId_;

rds/src/model/DescribeAvailableZonesResult.cc

@@ -49,30 +49,30 @@ void DescribeAvailableZonesResult::parse(const std::string &payload)
 			availableZonesObject.zoneId = valueAvailableZonesAvailableZone["ZoneId"].asString();
 		if(!valueAvailableZonesAvailableZone["NetworkTypes"].isNull())
 			availableZonesObject.networkTypes = valueAvailableZonesAvailableZone["NetworkTypes"].asString();
-		auto allSupportedEnginesNode = allAvailableZonesNode["SupportedEngines"]["SupportedEngine"];
-		for (auto allAvailableZonesNodeSupportedEnginesSupportedEngine : allSupportedEnginesNode)
+		auto allSupportedEnginesNode = valueAvailableZonesAvailableZone["SupportedEngines"]["SupportedEngine"];
+		for (auto valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngine : allSupportedEnginesNode)
 		{
 			AvailableZone::SupportedEngine supportedEnginesObject;
-			if(!allAvailableZonesNodeSupportedEnginesSupportedEngine["Engine"].isNull())
-				supportedEnginesObject.engine = allAvailableZonesNodeSupportedEnginesSupportedEngine["Engine"].asString();
-			auto allSupportedEngineVersionsNode = allSupportedEnginesNode["SupportedEngineVersions"]["SupportedEngineVersion"];
-			for (auto allSupportedEnginesNodeSupportedEngineVersionsSupportedEngineVersion : allSupportedEngineVersionsNode)
+			if(!valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngine["Engine"].isNull())
+				supportedEnginesObject.engine = valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngine["Engine"].asString();
+			auto allSupportedEngineVersionsNode = valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngine["SupportedEngineVersions"]["SupportedEngineVersion"];
+			for (auto valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngineSupportedEngineVersionsSupportedEngineVersion : allSupportedEngineVersionsNode)
 			{
 				AvailableZone::SupportedEngine::SupportedEngineVersion supportedEngineVersionsObject;
-				if(!allSupportedEnginesNodeSupportedEngineVersionsSupportedEngineVersion["Version"].isNull())
-					supportedEngineVersionsObject.version = allSupportedEnginesNodeSupportedEngineVersionsSupportedEngineVersion["Version"].asString();
-				auto allSupportedCategorysNode = allSupportedEngineVersionsNode["SupportedCategorys"]["SupportedCategory"];
-				for (auto allSupportedEngineVersionsNodeSupportedCategorysSupportedCategory : allSupportedCategorysNode)
+				if(!valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngineSupportedEngineVersionsSupportedEngineVersion["Version"].isNull())
+					supportedEngineVersionsObject.version = valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngineSupportedEngineVersionsSupportedEngineVersion["Version"].asString();
+				auto allSupportedCategorysNode = valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngineSupportedEngineVersionsSupportedEngineVersion["SupportedCategorys"]["SupportedCategory"];
+				for (auto valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngineSupportedEngineVersionsSupportedEngineVersionSupportedCategorysSupportedCategory : allSupportedCategorysNode)
 				{
 					AvailableZone::SupportedEngine::SupportedEngineVersion::SupportedCategory supportedCategorysObject;
-					if(!allSupportedEngineVersionsNodeSupportedCategorysSupportedCategory["Category"].isNull())
-						supportedCategorysObject.category = allSupportedEngineVersionsNodeSupportedCategorysSupportedCategory["Category"].asString();
-					auto allSupportedStorageTypesNode = allSupportedCategorysNode["SupportedStorageTypes"]["SupportedStorageType"];
-					for (auto allSupportedCategorysNodeSupportedStorageTypesSupportedStorageType : allSupportedStorageTypesNode)
+					if(!valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngineSupportedEngineVersionsSupportedEngineVersionSupportedCategorysSupportedCategory["Category"].isNull())
+						supportedCategorysObject.category = valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngineSupportedEngineVersionsSupportedEngineVersionSupportedCategorysSupportedCategory["Category"].asString();
+					auto allSupportedStorageTypesNode = valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngineSupportedEngineVersionsSupportedEngineVersionSupportedCategorysSupportedCategory["SupportedStorageTypes"]["SupportedStorageType"];
+					for (auto valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngineSupportedEngineVersionsSupportedEngineVersionSupportedCategorysSupportedCategorySupportedStorageTypesSupportedStorageType : allSupportedStorageTypesNode)
 					{
 						AvailableZone::SupportedEngine::SupportedEngineVersion::SupportedCategory::SupportedStorageType supportedStorageTypesObject;
-						if(!allSupportedCategorysNodeSupportedStorageTypesSupportedStorageType["StorageType"].isNull())
-							supportedStorageTypesObject.storageType = allSupportedCategorysNodeSupportedStorageTypesSupportedStorageType["StorageType"].asString();
+						if(!valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngineSupportedEngineVersionsSupportedEngineVersionSupportedCategorysSupportedCategorySupportedStorageTypesSupportedStorageType["StorageType"].isNull())
+							supportedStorageTypesObject.storageType = valueAvailableZonesAvailableZoneSupportedEnginesSupportedEngineSupportedEngineVersionsSupportedEngineVersionSupportedCategorysSupportedCategorySupportedStorageTypesSupportedStorageType["StorageType"].asString();
 						supportedCategorysObject.supportedStorageTypes.push_back(supportedStorageTypesObject);
 					}
 					supportedEngineVersionsObject.supportedCategorys.push_back(supportedCategorysObject);

rds/src/model/DescribeBackupsResult.cc

@@ -93,6 +93,8 @@ void DescribeBackupsResult::parse(const std::string &payload)
 			itemsObject.storageClass = valueItemsBackup["StorageClass"].asString();
 		if(!valueItemsBackup["IsAvail"].isNull())
 			itemsObject.isAvail = std::stoi(valueItemsBackup["IsAvail"].asString());
+		if(!valueItemsBackup["Encryption"].isNull())
+			itemsObject.encryption = valueItemsBackup["Encryption"].asString();
 		items_.push_back(itemsObject);
 	}
 	if(!value["TotalRecordCount"].isNull())

rds/src/model/DescribeDBInstanceAttributeResult.cc

@@ -191,20 +191,20 @@ void DescribeDBInstanceAttributeResult::parse(const std::string &payload)
 			itemsObject.dedicatedHostGroupId = valueItemsDBInstanceAttribute["DedicatedHostGroupId"].asString();
 		if(!valueItemsDBInstanceAttribute["SuperPermissionMode"].isNull())
 			itemsObject.superPermissionMode = valueItemsDBInstanceAttribute["SuperPermissionMode"].asString();
-		auto allSlaveZonesNode = allItemsNode["SlaveZones"]["SlaveZone"];
-		for (auto allItemsNodeSlaveZonesSlaveZone : allSlaveZonesNode)
+		auto allSlaveZonesNode = valueItemsDBInstanceAttribute["SlaveZones"]["SlaveZone"];
+		for (auto valueItemsDBInstanceAttributeSlaveZonesSlaveZone : allSlaveZonesNode)
 		{
 			DBInstanceAttribute::SlaveZone slaveZonesObject;
-			if(!allItemsNodeSlaveZonesSlaveZone["ZoneId"].isNull())
-				slaveZonesObject.zoneId = allItemsNodeSlaveZonesSlaveZone["ZoneId"].asString();
+			if(!valueItemsDBInstanceAttributeSlaveZonesSlaveZone["ZoneId"].isNull())
+				slaveZonesObject.zoneId = valueItemsDBInstanceAttributeSlaveZonesSlaveZone["ZoneId"].asString();
 			itemsObject.slaveZones.push_back(slaveZonesObject);
 		}
-		auto allReadOnlyDBInstanceIdsNode = allItemsNode["ReadOnlyDBInstanceIds"]["ReadOnlyDBInstanceId"];
-		for (auto allItemsNodeReadOnlyDBInstanceIdsReadOnlyDBInstanceId : allReadOnlyDBInstanceIdsNode)
+		auto allReadOnlyDBInstanceIdsNode = valueItemsDBInstanceAttribute["ReadOnlyDBInstanceIds"]["ReadOnlyDBInstanceId"];
+		for (auto valueItemsDBInstanceAttributeReadOnlyDBInstanceIdsReadOnlyDBInstanceId : allReadOnlyDBInstanceIdsNode)
 		{
 			DBInstanceAttribute::ReadOnlyDBInstanceId readOnlyDBInstanceIdsObject;
-			if(!allItemsNodeReadOnlyDBInstanceIdsReadOnlyDBInstanceId["DBInstanceId"].isNull())
-				readOnlyDBInstanceIdsObject.dBInstanceId = allItemsNodeReadOnlyDBInstanceIdsReadOnlyDBInstanceId["DBInstanceId"].asString();
+			if(!valueItemsDBInstanceAttributeReadOnlyDBInstanceIdsReadOnlyDBInstanceId["DBInstanceId"].isNull())
+				readOnlyDBInstanceIdsObject.dBInstanceId = valueItemsDBInstanceAttributeReadOnlyDBInstanceIdsReadOnlyDBInstanceId["DBInstanceId"].asString();
 			itemsObject.readOnlyDBInstanceIds.push_back(readOnlyDBInstanceIdsObject);
 		}
 		auto extraNode = value["Extra"];

rds/src/model/DescribeDBInstanceByTagsResult.cc

@@ -45,14 +45,14 @@ void DescribeDBInstanceByTagsResult::parse(const std::string &payload)
 		DBInstanceTag itemsObject;
 		if(!valueItemsDBInstanceTag["DBInstanceId"].isNull())
 			itemsObject.dBInstanceId = valueItemsDBInstanceTag["DBInstanceId"].asString();
-		auto allTagsNode = allItemsNode["Tags"]["Tag"];
-		for (auto allItemsNodeTagsTag : allTagsNode)
+		auto allTagsNode = valueItemsDBInstanceTag["Tags"]["Tag"];
+		for (auto valueItemsDBInstanceTagTagsTag : allTagsNode)
 		{
 			DBInstanceTag::Tag tagsObject;
-			if(!allItemsNodeTagsTag["TagKey"].isNull())
-				tagsObject.tagKey = allItemsNodeTagsTag["TagKey"].asString();
-			if(!allItemsNodeTagsTag["TagValue"].isNull())
-				tagsObject.tagValue = allItemsNodeTagsTag["TagValue"].asString();
+			if(!valueItemsDBInstanceTagTagsTag["TagKey"].isNull())
+				tagsObject.tagKey = valueItemsDBInstanceTagTagsTag["TagKey"].asString();
+			if(!valueItemsDBInstanceTagTagsTag["TagValue"].isNull())
+				tagsObject.tagValue = valueItemsDBInstanceTagTagsTag["TagValue"].asString();
 			itemsObject.tags.push_back(tagsObject);
 		}
 		items_.push_back(itemsObject);

rds/src/model/DescribeDBInstanceDetailRequest.cc

@@ -0,0 +1,95 @@
+/*
+ * 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.
+ */
+
+#include <alibabacloud/rds/model/DescribeDBInstanceDetailRequest.h>
+
+using AlibabaCloud::Rds::Model::DescribeDBInstanceDetailRequest;
+
+DescribeDBInstanceDetailRequest::DescribeDBInstanceDetailRequest() :
+	RpcServiceRequest("rds", "2014-08-15", "DescribeDBInstanceDetail")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDBInstanceDetailRequest::~DescribeDBInstanceDetailRequest()
+{}
+
+long DescribeDBInstanceDetailRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DescribeDBInstanceDetailRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string DescribeDBInstanceDetailRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DescribeDBInstanceDetailRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DescribeDBInstanceDetailRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void DescribeDBInstanceDetailRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+long DescribeDBInstanceDetailRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeDBInstanceDetailRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeDBInstanceDetailRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeDBInstanceDetailRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DescribeDBInstanceDetailRequest::getDBInstanceId()const
+{
+	return dBInstanceId_;
+}
+
+void DescribeDBInstanceDetailRequest::setDBInstanceId(const std::string& dBInstanceId)
+{
+	dBInstanceId_ = dBInstanceId;
+	setParameter("DBInstanceId", dBInstanceId);
+}
+

rds/src/model/DescribeDBInstanceDetailResult.cc

@@ -0,0 +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.
+ */
+
+#include <alibabacloud/rds/model/DescribeDBInstanceDetailResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Rds;
+using namespace AlibabaCloud::Rds::Model;
+
+DescribeDBInstanceDetailResult::DescribeDBInstanceDetailResult() :
+	ServiceResult()
+{}
+
+DescribeDBInstanceDetailResult::DescribeDBInstanceDetailResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDBInstanceDetailResult::~DescribeDBInstanceDetailResult()
+{}
+
+void DescribeDBInstanceDetailResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["DBInstanceId"].isNull())
+		dBInstanceId_ = value["DBInstanceId"].asString();
+	if(!value["RegionId"].isNull())
+		regionId_ = value["RegionId"].asString();
+	if(!value["LicenseType"].isNull())
+		licenseType_ = value["LicenseType"].asString();
+	if(!value["ActivationState"].isNull())
+		activationState_ = value["ActivationState"].asString();
+
+}
+
+std::string DescribeDBInstanceDetailResult::getDBInstanceId()const
+{
+	return dBInstanceId_;
+}
+
+std::string DescribeDBInstanceDetailResult::getActivationState()const
+{
+	return activationState_;
+}
+
+std::string DescribeDBInstanceDetailResult::getRegionId()const
+{
+	return regionId_;
+}
+
+std::string DescribeDBInstanceDetailResult::getLicenseType()const
+{
+	return licenseType_;
+}
+

rds/src/model/DescribeDBInstanceNetInfoRequest.cc

@@ -38,15 +38,15 @@ void DescribeDBInstanceNetInfoRequest::setResourceOwnerId(long resourceOwnerId)
 	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
-std::string DescribeDBInstanceNetInfoRequest::getFlag()const
+int DescribeDBInstanceNetInfoRequest::getFlag()const
 {
 	return flag_;
 }
 
-void DescribeDBInstanceNetInfoRequest::setFlag(const std::string& flag)
+void DescribeDBInstanceNetInfoRequest::setFlag(int flag)
 {
 	flag_ = flag;
-	setParameter("Flag", flag);
+	setParameter("Flag", std::to_string(flag));
 }
 
 std::string DescribeDBInstanceNetInfoRequest::getClientToken()const

rds/src/model/DescribeDBInstanceNetInfoResult.cc

@@ -65,28 +65,28 @@ void DescribeDBInstanceNetInfoResult::parse(const std::string &payload)
 			dBInstanceNetInfosObject.maxDelayTime = valueDBInstanceNetInfosDBInstanceNetInfo["MaxDelayTime"].asString();
 		if(!valueDBInstanceNetInfosDBInstanceNetInfo["DistributionType"].isNull())
 			dBInstanceNetInfosObject.distributionType = valueDBInstanceNetInfosDBInstanceNetInfo["DistributionType"].asString();
-		auto allSecurityIPGroupsNode = allDBInstanceNetInfosNode["SecurityIPGroups"]["securityIPGroup"];
-		for (auto allDBInstanceNetInfosNodeSecurityIPGroupssecurityIPGroup : allSecurityIPGroupsNode)
+		auto allSecurityIPGroupsNode = valueDBInstanceNetInfosDBInstanceNetInfo["SecurityIPGroups"]["securityIPGroup"];
+		for (auto valueDBInstanceNetInfosDBInstanceNetInfoSecurityIPGroupssecurityIPGroup : allSecurityIPGroupsNode)
 		{
 			DBInstanceNetInfo::SecurityIPGroup securityIPGroupsObject;
-			if(!allDBInstanceNetInfosNodeSecurityIPGroupssecurityIPGroup["SecurityIPGroupName"].isNull())
-				securityIPGroupsObject.securityIPGroupName = allDBInstanceNetInfosNodeSecurityIPGroupssecurityIPGroup["SecurityIPGroupName"].asString();
-			if(!allDBInstanceNetInfosNodeSecurityIPGroupssecurityIPGroup["SecurityIPs"].isNull())
-				securityIPGroupsObject.securityIPs = allDBInstanceNetInfosNodeSecurityIPGroupssecurityIPGroup["SecurityIPs"].asString();
+			if(!valueDBInstanceNetInfosDBInstanceNetInfoSecurityIPGroupssecurityIPGroup["SecurityIPGroupName"].isNull())
+				securityIPGroupsObject.securityIPGroupName = valueDBInstanceNetInfosDBInstanceNetInfoSecurityIPGroupssecurityIPGroup["SecurityIPGroupName"].asString();
+			if(!valueDBInstanceNetInfosDBInstanceNetInfoSecurityIPGroupssecurityIPGroup["SecurityIPs"].isNull())
+				securityIPGroupsObject.securityIPs = valueDBInstanceNetInfosDBInstanceNetInfoSecurityIPGroupssecurityIPGroup["SecurityIPs"].asString();
 			dBInstanceNetInfosObject.securityIPGroups.push_back(securityIPGroupsObject);
 		}
-		auto allDBInstanceWeightsNode = allDBInstanceNetInfosNode["DBInstanceWeights"]["DBInstanceWeight"];
-		for (auto allDBInstanceNetInfosNodeDBInstanceWeightsDBInstanceWeight : allDBInstanceWeightsNode)
+		auto allDBInstanceWeightsNode = valueDBInstanceNetInfosDBInstanceNetInfo["DBInstanceWeights"]["DBInstanceWeight"];
+		for (auto valueDBInstanceNetInfosDBInstanceNetInfoDBInstanceWeightsDBInstanceWeight : allDBInstanceWeightsNode)
 		{
 			DBInstanceNetInfo::DBInstanceWeight dBInstanceWeightsObject;
-			if(!allDBInstanceNetInfosNodeDBInstanceWeightsDBInstanceWeight["DBInstanceId"].isNull())
-				dBInstanceWeightsObject.dBInstanceId = allDBInstanceNetInfosNodeDBInstanceWeightsDBInstanceWeight["DBInstanceId"].asString();
-			if(!allDBInstanceNetInfosNodeDBInstanceWeightsDBInstanceWeight["DBInstanceType"].isNull())
-				dBInstanceWeightsObject.dBInstanceType = allDBInstanceNetInfosNodeDBInstanceWeightsDBInstanceWeight["DBInstanceType"].asString();
-			if(!allDBInstanceNetInfosNodeDBInstanceWeightsDBInstanceWeight["Availability"].isNull())
-				dBInstanceWeightsObject.availability = allDBInstanceNetInfosNodeDBInstanceWeightsDBInstanceWeight["Availability"].asString();
-			if(!allDBInstanceNetInfosNodeDBInstanceWeightsDBInstanceWeight["Weight"].isNull())
-				dBInstanceWeightsObject.weight = allDBInstanceNetInfosNodeDBInstanceWeightsDBInstanceWeight["Weight"].asString();
+			if(!valueDBInstanceNetInfosDBInstanceNetInfoDBInstanceWeightsDBInstanceWeight["DBInstanceId"].isNull())
+				dBInstanceWeightsObject.dBInstanceId = valueDBInstanceNetInfosDBInstanceNetInfoDBInstanceWeightsDBInstanceWeight["DBInstanceId"].asString();
+			if(!valueDBInstanceNetInfosDBInstanceNetInfoDBInstanceWeightsDBInstanceWeight["DBInstanceType"].isNull())
+				dBInstanceWeightsObject.dBInstanceType = valueDBInstanceNetInfosDBInstanceNetInfoDBInstanceWeightsDBInstanceWeight["DBInstanceType"].asString();
+			if(!valueDBInstanceNetInfosDBInstanceNetInfoDBInstanceWeightsDBInstanceWeight["Availability"].isNull())
+				dBInstanceWeightsObject.availability = valueDBInstanceNetInfosDBInstanceNetInfoDBInstanceWeightsDBInstanceWeight["Availability"].asString();
+			if(!valueDBInstanceNetInfosDBInstanceNetInfoDBInstanceWeightsDBInstanceWeight["Weight"].isNull())
+				dBInstanceWeightsObject.weight = valueDBInstanceNetInfosDBInstanceNetInfoDBInstanceWeightsDBInstanceWeight["Weight"].asString();
 			dBInstanceNetInfosObject.dBInstanceWeights.push_back(dBInstanceWeightsObject);
 		}
 		dBInstanceNetInfos_.push_back(dBInstanceNetInfosObject);

rds/src/model/DescribeDBInstancePerformanceResult.cc

@@ -49,14 +49,14 @@ void DescribeDBInstancePerformanceResult::parse(const std::string &payload)
 			performanceKeysObject.unit = valuePerformanceKeysPerformanceKey["Unit"].asString();
 		if(!valuePerformanceKeysPerformanceKey["ValueFormat"].isNull())
 			performanceKeysObject.valueFormat = valuePerformanceKeysPerformanceKey["ValueFormat"].asString();
-		auto allValuesNode = allPerformanceKeysNode["Values"]["PerformanceValue"];
-		for (auto allPerformanceKeysNodeValuesPerformanceValue : allValuesNode)
+		auto allValuesNode = valuePerformanceKeysPerformanceKey["Values"]["PerformanceValue"];
+		for (auto valuePerformanceKeysPerformanceKeyValuesPerformanceValue : allValuesNode)
 		{
 			PerformanceKey::PerformanceValue valuesObject;
-			if(!allPerformanceKeysNodeValuesPerformanceValue["Value"].isNull())
-				valuesObject.value = allPerformanceKeysNodeValuesPerformanceValue["Value"].asString();
-			if(!allPerformanceKeysNodeValuesPerformanceValue["Date"].isNull())
-				valuesObject.date = allPerformanceKeysNodeValuesPerformanceValue["Date"].asString();
+			if(!valuePerformanceKeysPerformanceKeyValuesPerformanceValue["Value"].isNull())
+				valuesObject.value = valuePerformanceKeysPerformanceKeyValuesPerformanceValue["Value"].asString();
+			if(!valuePerformanceKeysPerformanceKeyValuesPerformanceValue["Date"].isNull())
+				valuesObject.date = valuePerformanceKeysPerformanceKeyValuesPerformanceValue["Date"].asString();
 			performanceKeysObject.values.push_back(valuesObject);
 		}
 		performanceKeys_.push_back(performanceKeysObject);

rds/src/model/DescribeDBInstancesForCloneResult.cc

@@ -103,12 +103,12 @@ void DescribeDBInstancesForCloneResult::parse(const std::string &payload)
 			itemsObject.replicateId = valueItemsDBInstance["ReplicateId"].asString();
 		if(!valueItemsDBInstance["ResourceGroupId"].isNull())
 			itemsObject.resourceGroupId = valueItemsDBInstance["ResourceGroupId"].asString();
-		auto allReadOnlyDBInstanceIdsNode = allItemsNode["ReadOnlyDBInstanceIds"]["ReadOnlyDBInstanceId"];
-		for (auto allItemsNodeReadOnlyDBInstanceIdsReadOnlyDBInstanceId : allReadOnlyDBInstanceIdsNode)
+		auto allReadOnlyDBInstanceIdsNode = valueItemsDBInstance["ReadOnlyDBInstanceIds"]["ReadOnlyDBInstanceId"];
+		for (auto valueItemsDBInstanceReadOnlyDBInstanceIdsReadOnlyDBInstanceId : allReadOnlyDBInstanceIdsNode)
 		{
 			DBInstance::ReadOnlyDBInstanceId readOnlyDBInstanceIdsObject;
-			if(!allItemsNodeReadOnlyDBInstanceIdsReadOnlyDBInstanceId["DBInstanceId"].isNull())
-				readOnlyDBInstanceIdsObject.dBInstanceId = allItemsNodeReadOnlyDBInstanceIdsReadOnlyDBInstanceId["DBInstanceId"].asString();
+			if(!valueItemsDBInstanceReadOnlyDBInstanceIdsReadOnlyDBInstanceId["DBInstanceId"].isNull())
+				readOnlyDBInstanceIdsObject.dBInstanceId = valueItemsDBInstanceReadOnlyDBInstanceIdsReadOnlyDBInstanceId["DBInstanceId"].asString();
 			itemsObject.readOnlyDBInstanceIds.push_back(readOnlyDBInstanceIdsObject);
 		}
 		items_.push_back(itemsObject);

rds/src/model/DescribeDBInstancesOverviewRequest.cc

@@ -60,6 +60,17 @@ void DescribeDBInstancesOverviewRequest::setAccessKeyId(const std::string& acces
 	setParameter("AccessKeyId", accessKeyId);
 }
 
+std::string DescribeDBInstancesOverviewRequest::getResourceGroupId()const
+{
+	return resourceGroupId_;
+}
+
+void DescribeDBInstancesOverviewRequest::setResourceGroupId(const std::string& resourceGroupId)
+{
+	resourceGroupId_ = resourceGroupId;
+	setParameter("ResourceGroupId", resourceGroupId);
+}
+
 std::string DescribeDBInstancesOverviewRequest::getExpired()const
 {
 	return expired_;

rds/src/model/DescribeDBInstancesOverviewResult.cc

@@ -49,36 +49,36 @@ void DescribeDBInstancesOverviewResult::parse(const std::string &payload)
 			regionsObject.engineCount = valueRegionsRegionModel["EngineCount"].asString();
 		if(!valueRegionsRegionModel["TotalCount"].isNull())
 			regionsObject.totalCount = std::stoi(valueRegionsRegionModel["TotalCount"].asString());
-		auto allTypeModelsNode = allRegionsNode["TypeModels"]["TypeModel"];
-		for (auto allRegionsNodeTypeModelsTypeModel : allTypeModelsNode)
+		auto allTypeModelsNode = valueRegionsRegionModel["TypeModels"]["TypeModel"];
+		for (auto valueRegionsRegionModelTypeModelsTypeModel : allTypeModelsNode)
 		{
 			RegionModel::TypeModel typeModelsObject;
-			if(!allRegionsNodeTypeModelsTypeModel["InstanceDateType"].isNull())
-				typeModelsObject.instanceDateType = allRegionsNodeTypeModelsTypeModel["InstanceDateType"].asString();
-			if(!allRegionsNodeTypeModelsTypeModel["Count"].isNull())
-				typeModelsObject.count = std::stoi(allRegionsNodeTypeModelsTypeModel["Count"].asString());
-			auto allInstanceModelsNode = allTypeModelsNode["InstanceModels"]["InstanceModel"];
-			for (auto allTypeModelsNodeInstanceModelsInstanceModel : allInstanceModelsNode)
+			if(!valueRegionsRegionModelTypeModelsTypeModel["InstanceDateType"].isNull())
+				typeModelsObject.instanceDateType = valueRegionsRegionModelTypeModelsTypeModel["InstanceDateType"].asString();
+			if(!valueRegionsRegionModelTypeModelsTypeModel["Count"].isNull())
+				typeModelsObject.count = std::stoi(valueRegionsRegionModelTypeModelsTypeModel["Count"].asString());
+			auto allInstanceModelsNode = valueRegionsRegionModelTypeModelsTypeModel["InstanceModels"]["InstanceModel"];
+			for (auto valueRegionsRegionModelTypeModelsTypeModelInstanceModelsInstanceModel : allInstanceModelsNode)
 			{
 				RegionModel::TypeModel::InstanceModel instanceModelsObject;
-				if(!allTypeModelsNodeInstanceModelsInstanceModel["DBInstanceId"].isNull())
-					instanceModelsObject.dBInstanceId = allTypeModelsNodeInstanceModelsInstanceModel["DBInstanceId"].asString();
-				if(!allTypeModelsNodeInstanceModelsInstanceModel["Region"].isNull())
-					instanceModelsObject.region = allTypeModelsNodeInstanceModelsInstanceModel["Region"].asString();
-				if(!allTypeModelsNodeInstanceModelsInstanceModel["ZoneId"].isNull())
-					instanceModelsObject.zoneId = allTypeModelsNodeInstanceModelsInstanceModel["ZoneId"].asString();
-				if(!allTypeModelsNodeInstanceModelsInstanceModel["Engine"].isNull())
-					instanceModelsObject.engine = allTypeModelsNodeInstanceModelsInstanceModel["Engine"].asString();
-				if(!allTypeModelsNodeInstanceModelsInstanceModel["PayType"].isNull())
-					instanceModelsObject.payType = allTypeModelsNodeInstanceModelsInstanceModel["PayType"].asString();
-				if(!allTypeModelsNodeInstanceModelsInstanceModel["CreatedTime"].isNull())
-					instanceModelsObject.createdTime = allTypeModelsNodeInstanceModelsInstanceModel["CreatedTime"].asString();
-				if(!allTypeModelsNodeInstanceModelsInstanceModel["ExpireTime"].isNull())
-					instanceModelsObject.expireTime = allTypeModelsNodeInstanceModelsInstanceModel["ExpireTime"].asString();
-				if(!allTypeModelsNodeInstanceModelsInstanceModel["LockMode"].isNull())
-					instanceModelsObject.lockMode = allTypeModelsNodeInstanceModelsInstanceModel["LockMode"].asString();
-				if(!allTypeModelsNodeInstanceModelsInstanceModel["DBInstanceStatus"].isNull())
-					instanceModelsObject.dBInstanceStatus = allTypeModelsNodeInstanceModelsInstanceModel["DBInstanceStatus"].asString();
+				if(!valueRegionsRegionModelTypeModelsTypeModelInstanceModelsInstanceModel["DBInstanceId"].isNull())
+					instanceModelsObject.dBInstanceId = valueRegionsRegionModelTypeModelsTypeModelInstanceModelsInstanceModel["DBInstanceId"].asString();
+				if(!valueRegionsRegionModelTypeModelsTypeModelInstanceModelsInstanceModel["Region"].isNull())
+					instanceModelsObject.region = valueRegionsRegionModelTypeModelsTypeModelInstanceModelsInstanceModel["Region"].asString();
+				if(!valueRegionsRegionModelTypeModelsTypeModelInstanceModelsInstanceModel["ZoneId"].isNull())
+					instanceModelsObject.zoneId = valueRegionsRegionModelTypeModelsTypeModelInstanceModelsInstanceModel["ZoneId"].asString();
+				if(!valueRegionsRegionModelTypeModelsTypeModelInstanceModelsInstanceModel["Engine"].isNull())
+					instanceModelsObject.engine = valueRegionsRegionModelTypeModelsTypeModelInstanceModelsInstanceModel["Engine"].asString();
+				if(!valueRegionsRegionModelTypeModelsTypeModelInstanceModelsInstanceModel["PayType"].isNull())
+					instanceModelsObject.payType = valueRegionsRegionModelTypeModelsTypeModelInstanceModelsInstanceModel["PayType"].asString();
+				if(!valueRegionsRegionModelTypeModelsTypeModelInstanceModelsInstanceModel["CreatedTime"].isNull())
+					instanceModelsObject.createdTime = valueRegionsRegionModelTypeModelsTypeModelInstanceModelsInstanceModel["CreatedTime"].asString();
+				if(!valueRegionsRegionModelTypeModelsTypeModelInstanceModelsInstanceModel["ExpireTime"].isNull())
+					instanceModelsObject.expireTime = valueRegionsRegionModelTypeModelsTypeModelInstanceModelsInstanceModel["ExpireTime"].asString();
+				if(!valueRegionsRegionModelTypeModelsTypeModelInstanceModelsInstanceModel["LockMode"].isNull())
+					instanceModelsObject.lockMode = valueRegionsRegionModelTypeModelsTypeModelInstanceModelsInstanceModel["LockMode"].asString();
+				if(!valueRegionsRegionModelTypeModelsTypeModelInstanceModelsInstanceModel["DBInstanceStatus"].isNull())
+					instanceModelsObject.dBInstanceStatus = valueRegionsRegionModelTypeModelsTypeModelInstanceModelsInstanceModel["DBInstanceStatus"].asString();
 				typeModelsObject.instanceModels.push_back(instanceModelsObject);
 			}
 			regionsObject.typeModels.push_back(typeModelsObject);

rds/src/model/DescribeDBInstancesRequest.cc

@@ -60,6 +60,17 @@ void DescribeDBInstancesRequest::setTag2key(const std::string& tag2key)
 	setParameter("Tag2key", tag2key);
 }
 
+bool DescribeDBInstancesRequest::getNeedVpcName()const
+{
+	return needVpcName_;
+}
+
+void DescribeDBInstancesRequest::setNeedVpcName(bool needVpcName)
+{
+	needVpcName_ = needVpcName;
+	setParameter("NeedVpcName", needVpcName ? "true" : "false");
+}
+
 std::string DescribeDBInstancesRequest::getTag3key()const
 {
 	return tag3key_;

rds/src/model/DescribeDBInstancesResult.cc

@@ -125,12 +125,16 @@ void DescribeDBInstancesResult::parse(const std::string &payload)
 			itemsObject.dedicatedHostZoneIdForSlave = valueItemsDBInstance["DedicatedHostZoneIdForSlave"].asString();
 		if(!valueItemsDBInstance["DedicatedHostZoneIdForLog"].isNull())
 			itemsObject.dedicatedHostZoneIdForLog = valueItemsDBInstance["DedicatedHostZoneIdForLog"].asString();
-		auto allReadOnlyDBInstanceIdsNode = allItemsNode["ReadOnlyDBInstanceIds"]["ReadOnlyDBInstanceId"];
-		for (auto allItemsNodeReadOnlyDBInstanceIdsReadOnlyDBInstanceId : allReadOnlyDBInstanceIdsNode)
+		if(!valueItemsDBInstance["VpcName"].isNull())
+			itemsObject.vpcName = valueItemsDBInstance["VpcName"].asString();
+		if(!valueItemsDBInstance["DedicatedHostGroupName"].isNull())
+			itemsObject.dedicatedHostGroupName = valueItemsDBInstance["DedicatedHostGroupName"].asString();
+		auto allReadOnlyDBInstanceIdsNode = valueItemsDBInstance["ReadOnlyDBInstanceIds"]["ReadOnlyDBInstanceId"];
+		for (auto valueItemsDBInstanceReadOnlyDBInstanceIdsReadOnlyDBInstanceId : allReadOnlyDBInstanceIdsNode)
 		{
 			DBInstance::ReadOnlyDBInstanceId readOnlyDBInstanceIdsObject;
-			if(!allItemsNodeReadOnlyDBInstanceIdsReadOnlyDBInstanceId["DBInstanceId"].isNull())
-				readOnlyDBInstanceIdsObject.dBInstanceId = allItemsNodeReadOnlyDBInstanceIdsReadOnlyDBInstanceId["DBInstanceId"].asString();
+			if(!valueItemsDBInstanceReadOnlyDBInstanceIdsReadOnlyDBInstanceId["DBInstanceId"].isNull())
+				readOnlyDBInstanceIdsObject.dBInstanceId = valueItemsDBInstanceReadOnlyDBInstanceIdsReadOnlyDBInstanceId["DBInstanceId"].asString();
 			itemsObject.readOnlyDBInstanceIds.push_back(readOnlyDBInstanceIdsObject);
 		}
 		items_.push_back(itemsObject);

rds/src/model/DescribeDBProxyPerformanceResult.cc

@@ -47,14 +47,14 @@ void DescribeDBProxyPerformanceResult::parse(const std::string &payload)
 			performanceKeysObject.key = valuePerformanceKeysPerformanceKey["Key"].asString();
 		if(!valuePerformanceKeysPerformanceKey["ValueFormat"].isNull())
 			performanceKeysObject.valueFormat = valuePerformanceKeysPerformanceKey["ValueFormat"].asString();
-		auto allValuesNode = allPerformanceKeysNode["Values"]["PerformanceValue"];
-		for (auto allPerformanceKeysNodeValuesPerformanceValue : allValuesNode)
+		auto allValuesNode = valuePerformanceKeysPerformanceKey["Values"]["PerformanceValue"];
+		for (auto valuePerformanceKeysPerformanceKeyValuesPerformanceValue : allValuesNode)
 		{
 			PerformanceKey::PerformanceValue valuesObject;
-			if(!allPerformanceKeysNodeValuesPerformanceValue["Value"].isNull())
-				valuesObject.value = allPerformanceKeysNodeValuesPerformanceValue["Value"].asString();
-			if(!allPerformanceKeysNodeValuesPerformanceValue["Date"].isNull())
-				valuesObject.date = allPerformanceKeysNodeValuesPerformanceValue["Date"].asString();
+			if(!valuePerformanceKeysPerformanceKeyValuesPerformanceValue["Value"].isNull())
+				valuesObject.value = valuePerformanceKeysPerformanceKeyValuesPerformanceValue["Value"].asString();
+			if(!valuePerformanceKeysPerformanceKeyValuesPerformanceValue["Date"].isNull())
+				valuesObject.date = valuePerformanceKeysPerformanceKeyValuesPerformanceValue["Date"].asString();
 			performanceKeysObject.values.push_back(valuesObject);
 		}
 		performanceKeys_.push_back(performanceKeysObject);

rds/src/model/DescribeDatabasesResult.cc

@@ -55,16 +55,16 @@ void DescribeDatabasesResult::parse(const std::string &payload)
 			databasesObject.characterSetName = valueDatabasesDatabase["CharacterSetName"].asString();
 		if(!valueDatabasesDatabase["DBDescription"].isNull())
 			databasesObject.dBDescription = valueDatabasesDatabase["DBDescription"].asString();
-		auto allAccountsNode = allDatabasesNode["Accounts"]["AccountPrivilegeInfo"];
-		for (auto allDatabasesNodeAccountsAccountPrivilegeInfo : allAccountsNode)
+		auto allAccountsNode = valueDatabasesDatabase["Accounts"]["AccountPrivilegeInfo"];
+		for (auto valueDatabasesDatabaseAccountsAccountPrivilegeInfo : allAccountsNode)
 		{
 			Database::AccountPrivilegeInfo accountsObject;
-			if(!allDatabasesNodeAccountsAccountPrivilegeInfo["Account"].isNull())
-				accountsObject.account = allDatabasesNodeAccountsAccountPrivilegeInfo["Account"].asString();
-			if(!allDatabasesNodeAccountsAccountPrivilegeInfo["AccountPrivilege"].isNull())
-				accountsObject.accountPrivilege = allDatabasesNodeAccountsAccountPrivilegeInfo["AccountPrivilege"].asString();
-			if(!allDatabasesNodeAccountsAccountPrivilegeInfo["AccountPrivilegeDetail"].isNull())
-				accountsObject.accountPrivilegeDetail = allDatabasesNodeAccountsAccountPrivilegeInfo["AccountPrivilegeDetail"].asString();
+			if(!valueDatabasesDatabaseAccountsAccountPrivilegeInfo["Account"].isNull())
+				accountsObject.account = valueDatabasesDatabaseAccountsAccountPrivilegeInfo["Account"].asString();
+			if(!valueDatabasesDatabaseAccountsAccountPrivilegeInfo["AccountPrivilege"].isNull())
+				accountsObject.accountPrivilege = valueDatabasesDatabaseAccountsAccountPrivilegeInfo["AccountPrivilege"].asString();
+			if(!valueDatabasesDatabaseAccountsAccountPrivilegeInfo["AccountPrivilegeDetail"].isNull())
+				accountsObject.accountPrivilegeDetail = valueDatabasesDatabaseAccountsAccountPrivilegeInfo["AccountPrivilegeDetail"].asString();
 			databasesObject.accounts.push_back(accountsObject);
 		}
 		databases_.push_back(databasesObject);

rds/src/model/DescribeErrorLogsResult.cc

@@ -43,18 +43,18 @@ void DescribeErrorLogsResult::parse(const std::string &payload)
 	for (auto valueItemsErrorLog : allItemsNode)
 	{
 		ErrorLog itemsObject;
-		if(!valueItemsErrorLog["ErrorInfo"].isNull())
-			itemsObject.errorInfo = valueItemsErrorLog["ErrorInfo"].asString();
 		if(!valueItemsErrorLog["CreateTime"].isNull())
 			itemsObject.createTime = valueItemsErrorLog["CreateTime"].asString();
+		if(!valueItemsErrorLog["ErrorInfo"].isNull())
+			itemsObject.errorInfo = valueItemsErrorLog["ErrorInfo"].asString();
 		items_.push_back(itemsObject);
 	}
-	if(!value["TotalRecordCount"].isNull())
-		totalRecordCount_ = std::stoi(value["TotalRecordCount"].asString());
 	if(!value["PageNumber"].isNull())
 		pageNumber_ = std::stoi(value["PageNumber"].asString());
 	if(!value["PageRecordCount"].isNull())
 		pageRecordCount_ = std::stoi(value["PageRecordCount"].asString());
+	if(!value["TotalRecordCount"].isNull())
+		totalRecordCount_ = std::stoi(value["TotalRecordCount"].asString());
 
 }
 

rds/src/model/DescribeParameterGroupResult.cc

@@ -63,14 +63,14 @@ void DescribeParameterGroupResult::parse(const std::string &payload)
 			paramGroupObject.createTime = valueParamGroupParameterGroup["CreateTime"].asString();
 		if(!valueParamGroupParameterGroup["UpdateTime"].isNull())
 			paramGroupObject.updateTime = valueParamGroupParameterGroup["UpdateTime"].asString();
-		auto allParamDetailNode = allParamGroupNode["ParamDetail"]["ParameterDetail"];
-		for (auto allParamGroupNodeParamDetailParameterDetail : allParamDetailNode)
+		auto allParamDetailNode = valueParamGroupParameterGroup["ParamDetail"]["ParameterDetail"];
+		for (auto valueParamGroupParameterGroupParamDetailParameterDetail : allParamDetailNode)
 		{
 			ParameterGroup::ParameterDetail paramDetailObject;
-			if(!allParamGroupNodeParamDetailParameterDetail["ParamName"].isNull())
-				paramDetailObject.paramName = allParamGroupNodeParamDetailParameterDetail["ParamName"].asString();
-			if(!allParamGroupNodeParamDetailParameterDetail["ParamValue"].isNull())
-				paramDetailObject.paramValue = allParamGroupNodeParamDetailParameterDetail["ParamValue"].asString();
+			if(!valueParamGroupParameterGroupParamDetailParameterDetail["ParamName"].isNull())
+				paramDetailObject.paramName = valueParamGroupParameterGroupParamDetailParameterDetail["ParamName"].asString();
+			if(!valueParamGroupParameterGroupParamDetailParameterDetail["ParamValue"].isNull())
+				paramDetailObject.paramValue = valueParamGroupParameterGroupParamDetailParameterDetail["ParamValue"].asString();
 			paramGroupObject.paramDetail.push_back(paramDetailObject);
 		}
 		paramGroup_.push_back(paramGroupObject);

rds/src/model/DescribeReadDBInstanceDelayResult.cc

@@ -45,26 +45,26 @@ void DescribeReadDBInstanceDelayResult::parse(const std::string &payload)
 		ItemsItem itemsObject;
 		if(!valueItemsItemsItem["DBInstanceId"].isNull())
 			itemsObject.dBInstanceId = valueItemsItemsItem["DBInstanceId"].asString();
-		auto allReadonlyInstanceDelayNode = allItemsNode["ReadonlyInstanceDelay"]["ReadonlyInstanceDelayItem"];
-		for (auto allItemsNodeReadonlyInstanceDelayReadonlyInstanceDelayItem : allReadonlyInstanceDelayNode)
+		auto allReadonlyInstanceDelayNode = valueItemsItemsItem["ReadonlyInstanceDelay"]["ReadonlyInstanceDelayItem"];
+		for (auto valueItemsItemsItemReadonlyInstanceDelayReadonlyInstanceDelayItem : allReadonlyInstanceDelayNode)
 		{
 			ItemsItem::ReadonlyInstanceDelayItem readonlyInstanceDelayObject;
-			if(!allItemsNodeReadonlyInstanceDelayReadonlyInstanceDelayItem["ReplayLatency"].isNull())
-				readonlyInstanceDelayObject.replayLatency = allItemsNodeReadonlyInstanceDelayReadonlyInstanceDelayItem["ReplayLatency"].asString();
-			if(!allItemsNodeReadonlyInstanceDelayReadonlyInstanceDelayItem["FlushLag"].isNull())
-				readonlyInstanceDelayObject.flushLag = allItemsNodeReadonlyInstanceDelayReadonlyInstanceDelayItem["FlushLag"].asString();
-			if(!allItemsNodeReadonlyInstanceDelayReadonlyInstanceDelayItem["FlushLatency"].isNull())
-				readonlyInstanceDelayObject.flushLatency = allItemsNodeReadonlyInstanceDelayReadonlyInstanceDelayItem["FlushLatency"].asString();
-			if(!allItemsNodeReadonlyInstanceDelayReadonlyInstanceDelayItem["SendLatency"].isNull())
-				readonlyInstanceDelayObject.sendLatency = allItemsNodeReadonlyInstanceDelayReadonlyInstanceDelayItem["SendLatency"].asString();
-			if(!allItemsNodeReadonlyInstanceDelayReadonlyInstanceDelayItem["WriteLag"].isNull())
-				readonlyInstanceDelayObject.writeLag = allItemsNodeReadonlyInstanceDelayReadonlyInstanceDelayItem["WriteLag"].asString();
-			if(!allItemsNodeReadonlyInstanceDelayReadonlyInstanceDelayItem["ReplayLag"].isNull())
-				readonlyInstanceDelayObject.replayLag = allItemsNodeReadonlyInstanceDelayReadonlyInstanceDelayItem["ReplayLag"].asString();
-			if(!allItemsNodeReadonlyInstanceDelayReadonlyInstanceDelayItem["WriteLatency"].isNull())
-				readonlyInstanceDelayObject.writeLatency = allItemsNodeReadonlyInstanceDelayReadonlyInstanceDelayItem["WriteLatency"].asString();
-			if(!allItemsNodeReadonlyInstanceDelayReadonlyInstanceDelayItem["ReadDBInstanceName"].isNull())
-				readonlyInstanceDelayObject.readDBInstanceName = allItemsNodeReadonlyInstanceDelayReadonlyInstanceDelayItem["ReadDBInstanceName"].asString();
+			if(!valueItemsItemsItemReadonlyInstanceDelayReadonlyInstanceDelayItem["ReplayLatency"].isNull())
+				readonlyInstanceDelayObject.replayLatency = valueItemsItemsItemReadonlyInstanceDelayReadonlyInstanceDelayItem["ReplayLatency"].asString();
+			if(!valueItemsItemsItemReadonlyInstanceDelayReadonlyInstanceDelayItem["FlushLag"].isNull())
+				readonlyInstanceDelayObject.flushLag = valueItemsItemsItemReadonlyInstanceDelayReadonlyInstanceDelayItem["FlushLag"].asString();
+			if(!valueItemsItemsItemReadonlyInstanceDelayReadonlyInstanceDelayItem["FlushLatency"].isNull())
+				readonlyInstanceDelayObject.flushLatency = valueItemsItemsItemReadonlyInstanceDelayReadonlyInstanceDelayItem["FlushLatency"].asString();
+			if(!valueItemsItemsItemReadonlyInstanceDelayReadonlyInstanceDelayItem["SendLatency"].isNull())
+				readonlyInstanceDelayObject.sendLatency = valueItemsItemsItemReadonlyInstanceDelayReadonlyInstanceDelayItem["SendLatency"].asString();
+			if(!valueItemsItemsItemReadonlyInstanceDelayReadonlyInstanceDelayItem["WriteLag"].isNull())
+				readonlyInstanceDelayObject.writeLag = valueItemsItemsItemReadonlyInstanceDelayReadonlyInstanceDelayItem["WriteLag"].asString();
+			if(!valueItemsItemsItemReadonlyInstanceDelayReadonlyInstanceDelayItem["ReplayLag"].isNull())
+				readonlyInstanceDelayObject.replayLag = valueItemsItemsItemReadonlyInstanceDelayReadonlyInstanceDelayItem["ReplayLag"].asString();
+			if(!valueItemsItemsItemReadonlyInstanceDelayReadonlyInstanceDelayItem["WriteLatency"].isNull())
+				readonlyInstanceDelayObject.writeLatency = valueItemsItemsItemReadonlyInstanceDelayReadonlyInstanceDelayItem["WriteLatency"].asString();
+			if(!valueItemsItemsItemReadonlyInstanceDelayReadonlyInstanceDelayItem["ReadDBInstanceName"].isNull())
+				readonlyInstanceDelayObject.readDBInstanceName = valueItemsItemsItemReadonlyInstanceDelayReadonlyInstanceDelayItem["ReadDBInstanceName"].asString();
 			itemsObject.readonlyInstanceDelay.push_back(readonlyInstanceDelayObject);
 		}
 		auto allReadDBInstanceNames = value["ReadDBInstanceNames"]["ReadDBInstanceName"];

rds/src/model/DescribeSQLLogReportListResult.cc

@@ -45,26 +45,26 @@ void DescribeSQLLogReportListResult::parse(const std::string &payload)
 		Item itemsObject;
 		if(!valueItemsItem["ReportTime"].isNull())
 			itemsObject.reportTime = valueItemsItem["ReportTime"].asString();
-		auto allLatencyTopNItemsNode = allItemsNode["LatencyTopNItems"]["LatencyTopNItem"];
-		for (auto allItemsNodeLatencyTopNItemsLatencyTopNItem : allLatencyTopNItemsNode)
+		auto allLatencyTopNItemsNode = valueItemsItem["LatencyTopNItems"]["LatencyTopNItem"];
+		for (auto valueItemsItemLatencyTopNItemsLatencyTopNItem : allLatencyTopNItemsNode)
 		{
 			Item::LatencyTopNItem latencyTopNItemsObject;
-			if(!allItemsNodeLatencyTopNItemsLatencyTopNItem["SQLText"].isNull())
-				latencyTopNItemsObject.sQLText = allItemsNodeLatencyTopNItemsLatencyTopNItem["SQLText"].asString();
-			if(!allItemsNodeLatencyTopNItemsLatencyTopNItem["AvgLatency"].isNull())
-				latencyTopNItemsObject.avgLatency = std::stol(allItemsNodeLatencyTopNItemsLatencyTopNItem["AvgLatency"].asString());
-			if(!allItemsNodeLatencyTopNItemsLatencyTopNItem["SQLExecuteTimes"].isNull())
-				latencyTopNItemsObject.sQLExecuteTimes = std::stol(allItemsNodeLatencyTopNItemsLatencyTopNItem["SQLExecuteTimes"].asString());
+			if(!valueItemsItemLatencyTopNItemsLatencyTopNItem["SQLText"].isNull())
+				latencyTopNItemsObject.sQLText = valueItemsItemLatencyTopNItemsLatencyTopNItem["SQLText"].asString();
+			if(!valueItemsItemLatencyTopNItemsLatencyTopNItem["AvgLatency"].isNull())
+				latencyTopNItemsObject.avgLatency = std::stol(valueItemsItemLatencyTopNItemsLatencyTopNItem["AvgLatency"].asString());
+			if(!valueItemsItemLatencyTopNItemsLatencyTopNItem["SQLExecuteTimes"].isNull())
+				latencyTopNItemsObject.sQLExecuteTimes = std::stol(valueItemsItemLatencyTopNItemsLatencyTopNItem["SQLExecuteTimes"].asString());
 			itemsObject.latencyTopNItems.push_back(latencyTopNItemsObject);
 		}
-		auto allQPSTopNItemsNode = allItemsNode["QPSTopNItems"]["QPSTopNItem"];
-		for (auto allItemsNodeQPSTopNItemsQPSTopNItem : allQPSTopNItemsNode)
+		auto allQPSTopNItemsNode = valueItemsItem["QPSTopNItems"]["QPSTopNItem"];
+		for (auto valueItemsItemQPSTopNItemsQPSTopNItem : allQPSTopNItemsNode)
 		{
 			Item::QPSTopNItem qPSTopNItemsObject;
-			if(!allItemsNodeQPSTopNItemsQPSTopNItem["SQLText"].isNull())
-				qPSTopNItemsObject.sQLText = allItemsNodeQPSTopNItemsQPSTopNItem["SQLText"].asString();
-			if(!allItemsNodeQPSTopNItemsQPSTopNItem["SQLExecuteTimes"].isNull())
-				qPSTopNItemsObject.sQLExecuteTimes = std::stol(allItemsNodeQPSTopNItemsQPSTopNItem["SQLExecuteTimes"].asString());
+			if(!valueItemsItemQPSTopNItemsQPSTopNItem["SQLText"].isNull())
+				qPSTopNItemsObject.sQLText = valueItemsItemQPSTopNItemsQPSTopNItem["SQLText"].asString();
+			if(!valueItemsItemQPSTopNItemsQPSTopNItem["SQLExecuteTimes"].isNull())
+				qPSTopNItemsObject.sQLExecuteTimes = std::stol(valueItemsItemQPSTopNItemsQPSTopNItem["SQLExecuteTimes"].asString());
 			itemsObject.qPSTopNItems.push_back(qPSTopNItemsObject);
 		}
 		items_.push_back(itemsObject);

rds/src/model/DescribeSQLLogReportsResult.cc

@@ -45,26 +45,26 @@ void DescribeSQLLogReportsResult::parse(const std::string &payload)
 		Item itemsObject;
 		if(!valueItemsItem["ReportTime"].isNull())
 			itemsObject.reportTime = valueItemsItem["ReportTime"].asString();
-		auto allLatencyTopNItemsNode = allItemsNode["LatencyTopNItems"]["LatencyTopNItem"];
-		for (auto allItemsNodeLatencyTopNItemsLatencyTopNItem : allLatencyTopNItemsNode)
+		auto allLatencyTopNItemsNode = valueItemsItem["LatencyTopNItems"]["LatencyTopNItem"];
+		for (auto valueItemsItemLatencyTopNItemsLatencyTopNItem : allLatencyTopNItemsNode)
 		{
 			Item::LatencyTopNItem latencyTopNItemsObject;
-			if(!allItemsNodeLatencyTopNItemsLatencyTopNItem["SQLText"].isNull())
-				latencyTopNItemsObject.sQLText = allItemsNodeLatencyTopNItemsLatencyTopNItem["SQLText"].asString();
-			if(!allItemsNodeLatencyTopNItemsLatencyTopNItem["AvgLatency"].isNull())
-				latencyTopNItemsObject.avgLatency = std::stol(allItemsNodeLatencyTopNItemsLatencyTopNItem["AvgLatency"].asString());
-			if(!allItemsNodeLatencyTopNItemsLatencyTopNItem["SQLExecuteTimes"].isNull())
-				latencyTopNItemsObject.sQLExecuteTimes = std::stol(allItemsNodeLatencyTopNItemsLatencyTopNItem["SQLExecuteTimes"].asString());
+			if(!valueItemsItemLatencyTopNItemsLatencyTopNItem["SQLText"].isNull())
+				latencyTopNItemsObject.sQLText = valueItemsItemLatencyTopNItemsLatencyTopNItem["SQLText"].asString();
+			if(!valueItemsItemLatencyTopNItemsLatencyTopNItem["AvgLatency"].isNull())
+				latencyTopNItemsObject.avgLatency = std::stol(valueItemsItemLatencyTopNItemsLatencyTopNItem["AvgLatency"].asString());
+			if(!valueItemsItemLatencyTopNItemsLatencyTopNItem["SQLExecuteTimes"].isNull())
+				latencyTopNItemsObject.sQLExecuteTimes = std::stol(valueItemsItemLatencyTopNItemsLatencyTopNItem["SQLExecuteTimes"].asString());
 			itemsObject.latencyTopNItems.push_back(latencyTopNItemsObject);
 		}
-		auto allQPSTopNItemsNode = allItemsNode["QPSTopNItems"]["QPSTopNItem"];
-		for (auto allItemsNodeQPSTopNItemsQPSTopNItem : allQPSTopNItemsNode)
+		auto allQPSTopNItemsNode = valueItemsItem["QPSTopNItems"]["QPSTopNItem"];
+		for (auto valueItemsItemQPSTopNItemsQPSTopNItem : allQPSTopNItemsNode)
 		{
 			Item::QPSTopNItem qPSTopNItemsObject;
-			if(!allItemsNodeQPSTopNItemsQPSTopNItem["SQLText"].isNull())
-				qPSTopNItemsObject.sQLText = allItemsNodeQPSTopNItemsQPSTopNItem["SQLText"].asString();
-			if(!allItemsNodeQPSTopNItemsQPSTopNItem["SQLExecuteTimes"].isNull())
-				qPSTopNItemsObject.sQLExecuteTimes = std::stol(allItemsNodeQPSTopNItemsQPSTopNItem["SQLExecuteTimes"].asString());
+			if(!valueItemsItemQPSTopNItemsQPSTopNItem["SQLText"].isNull())
+				qPSTopNItemsObject.sQLText = valueItemsItemQPSTopNItemsQPSTopNItem["SQLText"].asString();
+			if(!valueItemsItemQPSTopNItemsQPSTopNItem["SQLExecuteTimes"].isNull())
+				qPSTopNItemsObject.sQLExecuteTimes = std::stol(valueItemsItemQPSTopNItemsQPSTopNItem["SQLExecuteTimes"].asString());
 			itemsObject.qPSTopNItems.push_back(qPSTopNItemsObject);
 		}
 		items_.push_back(itemsObject);

rds/src/model/DescribeSQLReportsResult.cc

@@ -45,26 +45,26 @@ void DescribeSQLReportsResult::parse(const std::string &payload)
 		Item itemsObject;
 		if(!valueItemsItem["ReportTime"].isNull())
 			itemsObject.reportTime = valueItemsItem["ReportTime"].asString();
-		auto allLatencyTopNItemsNode = allItemsNode["LatencyTopNItems"]["LatencyTopNItem"];
-		for (auto allItemsNodeLatencyTopNItemsLatencyTopNItem : allLatencyTopNItemsNode)
+		auto allLatencyTopNItemsNode = valueItemsItem["LatencyTopNItems"]["LatencyTopNItem"];
+		for (auto valueItemsItemLatencyTopNItemsLatencyTopNItem : allLatencyTopNItemsNode)
 		{
 			Item::LatencyTopNItem latencyTopNItemsObject;
-			if(!allItemsNodeLatencyTopNItemsLatencyTopNItem["SQLText"].isNull())
-				latencyTopNItemsObject.sQLText = allItemsNodeLatencyTopNItemsLatencyTopNItem["SQLText"].asString();
-			if(!allItemsNodeLatencyTopNItemsLatencyTopNItem["AvgLatency"].isNull())
-				latencyTopNItemsObject.avgLatency = std::stol(allItemsNodeLatencyTopNItemsLatencyTopNItem["AvgLatency"].asString());
-			if(!allItemsNodeLatencyTopNItemsLatencyTopNItem["SQLExecuteTimes"].isNull())
-				latencyTopNItemsObject.sQLExecuteTimes = std::stol(allItemsNodeLatencyTopNItemsLatencyTopNItem["SQLExecuteTimes"].asString());
+			if(!valueItemsItemLatencyTopNItemsLatencyTopNItem["SQLText"].isNull())
+				latencyTopNItemsObject.sQLText = valueItemsItemLatencyTopNItemsLatencyTopNItem["SQLText"].asString();
+			if(!valueItemsItemLatencyTopNItemsLatencyTopNItem["AvgLatency"].isNull())
+				latencyTopNItemsObject.avgLatency = std::stol(valueItemsItemLatencyTopNItemsLatencyTopNItem["AvgLatency"].asString());
+			if(!valueItemsItemLatencyTopNItemsLatencyTopNItem["SQLExecuteTimes"].isNull())
+				latencyTopNItemsObject.sQLExecuteTimes = std::stol(valueItemsItemLatencyTopNItemsLatencyTopNItem["SQLExecuteTimes"].asString());
 			itemsObject.latencyTopNItems.push_back(latencyTopNItemsObject);
 		}
-		auto allQPSTopNItemsNode = allItemsNode["QPSTopNItems"]["QPSTopNItem"];
-		for (auto allItemsNodeQPSTopNItemsQPSTopNItem : allQPSTopNItemsNode)
+		auto allQPSTopNItemsNode = valueItemsItem["QPSTopNItems"]["QPSTopNItem"];
+		for (auto valueItemsItemQPSTopNItemsQPSTopNItem : allQPSTopNItemsNode)
 		{
 			Item::QPSTopNItem qPSTopNItemsObject;
-			if(!allItemsNodeQPSTopNItemsQPSTopNItem["SQLText"].isNull())
-				qPSTopNItemsObject.sQLText = allItemsNodeQPSTopNItemsQPSTopNItem["SQLText"].asString();
-			if(!allItemsNodeQPSTopNItemsQPSTopNItem["SQLExecuteTimes"].isNull())
-				qPSTopNItemsObject.sQLExecuteTimes = std::stol(allItemsNodeQPSTopNItemsQPSTopNItem["SQLExecuteTimes"].asString());
+			if(!valueItemsItemQPSTopNItemsQPSTopNItem["SQLText"].isNull())
+				qPSTopNItemsObject.sQLText = valueItemsItemQPSTopNItemsQPSTopNItem["SQLText"].asString();
+			if(!valueItemsItemQPSTopNItemsQPSTopNItem["SQLExecuteTimes"].isNull())
+				qPSTopNItemsObject.sQLExecuteTimes = std::stol(valueItemsItemQPSTopNItemsQPSTopNItem["SQLExecuteTimes"].asString());
 			itemsObject.qPSTopNItems.push_back(qPSTopNItemsObject);
 		}
 		items_.push_back(itemsObject);

rds/src/model/DescribeSlowLogRecordsResult.cc

@@ -61,6 +61,24 @@ void DescribeSlowLogRecordsResult::parse(const std::string &payload)
 			itemsObject.executionStartTime = valueItemsSQLSlowRecord["ExecutionStartTime"].asString();
 		if(!valueItemsSQLSlowRecord["QueryTimeMS"].isNull())
 			itemsObject.queryTimeMS = std::stol(valueItemsSQLSlowRecord["QueryTimeMS"].asString());
+		if(!valueItemsSQLSlowRecord["CpuTime"].isNull())
+			itemsObject.cpuTime = std::stol(valueItemsSQLSlowRecord["CpuTime"].asString());
+		if(!valueItemsSQLSlowRecord["LogicalIORead"].isNull())
+			itemsObject.logicalIORead = std::stol(valueItemsSQLSlowRecord["LogicalIORead"].asString());
+		if(!valueItemsSQLSlowRecord["PhysicalIORead"].isNull())
+			itemsObject.physicalIORead = std::stol(valueItemsSQLSlowRecord["PhysicalIORead"].asString());
+		if(!valueItemsSQLSlowRecord["WriteIOCount"].isNull())
+			itemsObject.writeIOCount = std::stol(valueItemsSQLSlowRecord["WriteIOCount"].asString());
+		if(!valueItemsSQLSlowRecord["RowsAffectedCount"].isNull())
+			itemsObject.rowsAffectedCount = std::stol(valueItemsSQLSlowRecord["RowsAffectedCount"].asString());
+		if(!valueItemsSQLSlowRecord["LastRowsAffectedCount"].isNull())
+			itemsObject.lastRowsAffectedCount = std::stol(valueItemsSQLSlowRecord["LastRowsAffectedCount"].asString());
+		if(!valueItemsSQLSlowRecord["UserName"].isNull())
+			itemsObject.userName = valueItemsSQLSlowRecord["UserName"].asString();
+		if(!valueItemsSQLSlowRecord["ApplicationName"].isNull())
+			itemsObject.applicationName = valueItemsSQLSlowRecord["ApplicationName"].asString();
+		if(!valueItemsSQLSlowRecord["ClientHostName"].isNull())
+			itemsObject.clientHostName = valueItemsSQLSlowRecord["ClientHostName"].asString();
 		items_.push_back(itemsObject);
 	}
 	if(!value["DBInstanceId"].isNull())
@@ -73,6 +91,22 @@ void DescribeSlowLogRecordsResult::parse(const std::string &payload)
 		pageNumber_ = std::stoi(value["PageNumber"].asString());
 	if(!value["PageRecordCount"].isNull())
 		pageRecordCount_ = std::stoi(value["PageRecordCount"].asString());
+	if(!value["SQLHash"].isNull())
+		sQLHash_ = value["SQLHash"].asString();
+	if(!value["CPUTime"].isNull())
+		cPUTime_ = std::stol(value["CPUTime"].asString());
+	if(!value["LogicalIORead"].isNull())
+		logicalIORead_ = std::stol(value["LogicalIORead"].asString());
+	if(!value["PhysicalIORead"].isNull())
+		physicalIORead_ = std::stol(value["PhysicalIORead"].asString());
+	if(!value["WritesIOCount"].isNull())
+		writesIOCount_ = std::stol(value["WritesIOCount"].asString());
+	if(!value["RowsAffectedCount"].isNull())
+		rowsAffectedCount_ = std::stol(value["RowsAffectedCount"].asString());
+	if(!value["LastRowsAffectedCount"].isNull())
+		lastRowsAffectedCount_ = std::stol(value["LastRowsAffectedCount"].asString());
+	if(!value["UserName"].isNull())
+		userName_ = value["UserName"].asString();
 
 }
 
@@ -86,6 +120,46 @@ int DescribeSlowLogRecordsResult::getPageRecordCount()const
 	return pageRecordCount_;
 }
 
+std::string DescribeSlowLogRecordsResult::getUserName()const
+{
+	return userName_;
+}
+
+long DescribeSlowLogRecordsResult::getLastRowsAffectedCount()const
+{
+	return lastRowsAffectedCount_;
+}
+
+long DescribeSlowLogRecordsResult::getRowsAffectedCount()const
+{
+	return rowsAffectedCount_;
+}
+
+long DescribeSlowLogRecordsResult::getPhysicalIORead()const
+{
+	return physicalIORead_;
+}
+
+long DescribeSlowLogRecordsResult::getWritesIOCount()const
+{
+	return writesIOCount_;
+}
+
+long DescribeSlowLogRecordsResult::getLogicalIORead()const
+{
+	return logicalIORead_;
+}
+
+long DescribeSlowLogRecordsResult::getCPUTime()const
+{
+	return cPUTime_;
+}
+
+std::string DescribeSlowLogRecordsResult::getSQLHash()const
+{
+	return sQLHash_;
+}
+
 std::string DescribeSlowLogRecordsResult::getDBInstanceId()const
 {
 	return dBInstanceId_;

rds/src/model/DescribeSlowLogsResult.cc

@@ -85,6 +85,56 @@ void DescribeSlowLogsResult::parse(const std::string &payload)
 			itemsObject.maxExecutionTime = std::stol(valueItemsSQLSlowLog["MaxExecutionTime"].asString());
 		if(!valueItemsSQLSlowLog["AvgExecutionTime"].isNull())
 			itemsObject.avgExecutionTime = std::stol(valueItemsSQLSlowLog["AvgExecutionTime"].asString());
+		if(!valueItemsSQLSlowLog["TotalPhysicalReadCounts"].isNull())
+			itemsObject.totalPhysicalReadCounts1 = std::stol(valueItemsSQLSlowLog["TotalPhysicalReadCounts"].asString());
+		if(!valueItemsSQLSlowLog["AvgPhysicalReadCounts"].isNull())
+			itemsObject.avgPhysicalReadCounts = std::stol(valueItemsSQLSlowLog["AvgPhysicalReadCounts"].asString());
+		if(!valueItemsSQLSlowLog["MaxPhysicalReadCounts"].isNull())
+			itemsObject.maxPhysicalReadCounts = std::stol(valueItemsSQLSlowLog["MaxPhysicalReadCounts"].asString());
+		if(!valueItemsSQLSlowLog["MinPhysicalReadCounts"].isNull())
+			itemsObject.minPhysicalReadCounts = std::stol(valueItemsSQLSlowLog["MinPhysicalReadCounts"].asString());
+		if(!valueItemsSQLSlowLog["AvgLogicalReadCounts"].isNull())
+			itemsObject.avgLogicalReadCounts = std::stol(valueItemsSQLSlowLog["AvgLogicalReadCounts"].asString());
+		if(!valueItemsSQLSlowLog["MaxLogicalReadCounts"].isNull())
+			itemsObject.maxLogicalReadCounts = std::stol(valueItemsSQLSlowLog["MaxLogicalReadCounts"].asString());
+		if(!valueItemsSQLSlowLog["MinLogicalReadCounts"].isNull())
+			itemsObject.minLogicalReadCounts = std::stol(valueItemsSQLSlowLog["MinLogicalReadCounts"].asString());
+		if(!valueItemsSQLSlowLog["TotalIOWriteCounts"].isNull())
+			itemsObject.totalIOWriteCounts = std::stol(valueItemsSQLSlowLog["TotalIOWriteCounts"].asString());
+		if(!valueItemsSQLSlowLog["AvgIOWriteCounts"].isNull())
+			itemsObject.avgIOWriteCounts = std::stol(valueItemsSQLSlowLog["AvgIOWriteCounts"].asString());
+		if(!valueItemsSQLSlowLog["MaxIOWriteCounts"].isNull())
+			itemsObject.maxIOWriteCounts = std::stol(valueItemsSQLSlowLog["MaxIOWriteCounts"].asString());
+		if(!valueItemsSQLSlowLog["MinIOWriteCounts"].isNull())
+			itemsObject.minIOWriteCounts = std::stol(valueItemsSQLSlowLog["MinIOWriteCounts"].asString());
+		if(!valueItemsSQLSlowLog["TotalRowsAffectedCounts"].isNull())
+			itemsObject.totalRowsAffectedCounts = std::stol(valueItemsSQLSlowLog["TotalRowsAffectedCounts"].asString());
+		if(!valueItemsSQLSlowLog["AvgRowsAffectedCounts"].isNull())
+			itemsObject.avgRowsAffectedCounts = std::stol(valueItemsSQLSlowLog["AvgRowsAffectedCounts"].asString());
+		if(!valueItemsSQLSlowLog["MaxRowsAffectedCounts"].isNull())
+			itemsObject.maxRowsAffectedCounts = std::stol(valueItemsSQLSlowLog["MaxRowsAffectedCounts"].asString());
+		if(!valueItemsSQLSlowLog["MinRowsAffectedCounts"].isNull())
+			itemsObject.minRowsAffectedCounts = std::stol(valueItemsSQLSlowLog["MinRowsAffectedCounts"].asString());
+		if(!valueItemsSQLSlowLog["TotalLastRowsAffectedCounts"].isNull())
+			itemsObject.totalLastRowsAffectedCounts = std::stol(valueItemsSQLSlowLog["TotalLastRowsAffectedCounts"].asString());
+		if(!valueItemsSQLSlowLog["AvgLastRowsAffectedCounts"].isNull())
+			itemsObject.avgLastRowsAffectedCounts = std::stol(valueItemsSQLSlowLog["AvgLastRowsAffectedCounts"].asString());
+		if(!valueItemsSQLSlowLog["MaxLastRowsAffectedCounts"].isNull())
+			itemsObject.maxLastRowsAffectedCounts = std::stol(valueItemsSQLSlowLog["MaxLastRowsAffectedCounts"].asString());
+		if(!valueItemsSQLSlowLog["MinLastRowsAffectedCounts"].isNull())
+			itemsObject.minLastRowsAffectedCounts = std::stol(valueItemsSQLSlowLog["MinLastRowsAffectedCounts"].asString());
+		if(!valueItemsSQLSlowLog["SQLServerMinExecutionTime"].isNull())
+			itemsObject.sQLServerMinExecutionTime = std::stol(valueItemsSQLSlowLog["SQLServerMinExecutionTime"].asString());
+		if(!valueItemsSQLSlowLog["SQLServerAvgExecutionTime"].isNull())
+			itemsObject.sQLServerAvgExecutionTime = std::stol(valueItemsSQLSlowLog["SQLServerAvgExecutionTime"].asString());
+		if(!valueItemsSQLSlowLog["SQLServerTotalCpuTime"].isNull())
+			itemsObject.sQLServerTotalCpuTime = std::stol(valueItemsSQLSlowLog["SQLServerTotalCpuTime"].asString());
+		if(!valueItemsSQLSlowLog["SQLServerAvgCpuTime"].isNull())
+			itemsObject.sQLServerAvgCpuTime = std::stol(valueItemsSQLSlowLog["SQLServerAvgCpuTime"].asString());
+		if(!valueItemsSQLSlowLog["SQLServerMaxCpuTime"].isNull())
+			itemsObject.sQLServerMaxCpuTime = std::stol(valueItemsSQLSlowLog["SQLServerMaxCpuTime"].asString());
+		if(!valueItemsSQLSlowLog["SQLServerMinCpuTime"].isNull())
+			itemsObject.sQLServerMinCpuTime = std::stol(valueItemsSQLSlowLog["SQLServerMinCpuTime"].asString());
 		items_.push_back(itemsObject);
 	}
 	if(!value["DBInstanceId"].isNull())

rds/src/model/GetDBInstanceTopologyRequest.cc

@@ -0,0 +1,40 @@
+/*
+ * 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.
+ */
+
+#include <alibabacloud/rds/model/GetDBInstanceTopologyRequest.h>
+
+using AlibabaCloud::Rds::Model::GetDBInstanceTopologyRequest;
+
+GetDBInstanceTopologyRequest::GetDBInstanceTopologyRequest() :
+	RpcServiceRequest("rds", "2014-08-15", "GetDBInstanceTopology")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetDBInstanceTopologyRequest::~GetDBInstanceTopologyRequest()
+{}
+
+std::string GetDBInstanceTopologyRequest::getDBInstanceId()const
+{
+	return dBInstanceId_;
+}
+
+void GetDBInstanceTopologyRequest::setDBInstanceId(const std::string& dBInstanceId)
+{
+	dBInstanceId_ = dBInstanceId;
+	setParameter("DBInstanceId", dBInstanceId);
+}
+

rds/src/model/GetDBInstanceTopologyResult.cc

@@ -0,0 +1,92 @@
+/*
+ * 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.
+ */
+
+#include <alibabacloud/rds/model/GetDBInstanceTopologyResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Rds;
+using namespace AlibabaCloud::Rds::Model;
+
+GetDBInstanceTopologyResult::GetDBInstanceTopologyResult() :
+	ServiceResult()
+{}
+
+GetDBInstanceTopologyResult::GetDBInstanceTopologyResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetDBInstanceTopologyResult::~GetDBInstanceTopologyResult()
+{}
+
+void GetDBInstanceTopologyResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto dataNode = value["Data"];
+	if(!dataNode["DBInstanceName"].isNull())
+		data_.dBInstanceName = dataNode["DBInstanceName"].asString();
+	auto allConnectionsNode = dataNode["Connections"]["Connection"];
+	for (auto dataNodeConnectionsConnection : allConnectionsNode)
+	{
+		Data::Connection connectionObject;
+		if(!dataNodeConnectionsConnection["NetType"].isNull())
+			connectionObject.netType = dataNodeConnectionsConnection["NetType"].asString();
+		if(!dataNodeConnectionsConnection["ConnectionString"].isNull())
+			connectionObject.connectionString = dataNodeConnectionsConnection["ConnectionString"].asString();
+		if(!dataNodeConnectionsConnection["ZoneId"].isNull())
+			connectionObject.zoneId = dataNodeConnectionsConnection["ZoneId"].asString();
+		data_.connections.push_back(connectionObject);
+	}
+	auto allNodesNode = dataNode["Nodes"]["Node"];
+	for (auto dataNodeNodesNode : allNodesNode)
+	{
+		Data::Node nodeObject;
+		if(!dataNodeNodesNode["Role"].isNull())
+			nodeObject.role = dataNodeNodesNode["Role"].asString();
+		if(!dataNodeNodesNode["DedicatedHostId"].isNull())
+			nodeObject.dedicatedHostId = dataNodeNodesNode["DedicatedHostId"].asString();
+		if(!dataNodeNodesNode["ZoneId"].isNull())
+			nodeObject.zoneId = dataNodeNodesNode["ZoneId"].asString();
+		if(!dataNodeNodesNode["DedicatedHostGroupId"].isNull())
+			nodeObject.dedicatedHostGroupId = dataNodeNodesNode["DedicatedHostGroupId"].asString();
+		data_.nodes.push_back(nodeObject);
+	}
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string GetDBInstanceTopologyResult::getMessage()const
+{
+	return message_;
+}
+
+GetDBInstanceTopologyResult::Data GetDBInstanceTopologyResult::getData()const
+{
+	return data_;
+}
+
+std::string GetDBInstanceTopologyResult::getCode()const
+{
+	return code_;
+}
+

rds/src/model/GetDbProxyInstanceSslRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * 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.
+ */
+
+#include <alibabacloud/rds/model/GetDbProxyInstanceSslRequest.h>
+
+using AlibabaCloud::Rds::Model::GetDbProxyInstanceSslRequest;
+
+GetDbProxyInstanceSslRequest::GetDbProxyInstanceSslRequest() :
+	RpcServiceRequest("rds", "2014-08-15", "GetDbProxyInstanceSsl")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+GetDbProxyInstanceSslRequest::~GetDbProxyInstanceSslRequest()
+{}
+
+std::string GetDbProxyInstanceSslRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void GetDbProxyInstanceSslRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string GetDbProxyInstanceSslRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void GetDbProxyInstanceSslRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string GetDbProxyInstanceSslRequest::getDbInstanceId()const
+{
+	return dbInstanceId_;
+}
+
+void GetDbProxyInstanceSslRequest::setDbInstanceId(const std::string& dbInstanceId)
+{
+	dbInstanceId_ = dbInstanceId;
+	setParameter("DbInstanceId", dbInstanceId);
+}
+

rds/src/model/GetDbProxyInstanceSslResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/rds/model/GetDbProxyInstanceSslResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Rds;
+using namespace AlibabaCloud::Rds::Model;
+
+GetDbProxyInstanceSslResult::GetDbProxyInstanceSslResult() :
+	ServiceResult()
+{}
+
+GetDbProxyInstanceSslResult::GetDbProxyInstanceSslResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+GetDbProxyInstanceSslResult::~GetDbProxyInstanceSslResult()
+{}
+
+void GetDbProxyInstanceSslResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDbProxyCertListItemsNode = value["DbProxyCertListItems"]["DbProxyCertListItemsItem"];
+	for (auto valueDbProxyCertListItemsDbProxyCertListItemsItem : allDbProxyCertListItemsNode)
+	{
+		DbProxyCertListItemsItem dbProxyCertListItemsObject;
+		if(!valueDbProxyCertListItemsDbProxyCertListItemsItem["DbInstanceName"].isNull())
+			dbProxyCertListItemsObject.dbInstanceName = valueDbProxyCertListItemsDbProxyCertListItemsItem["DbInstanceName"].asString();
+		if(!valueDbProxyCertListItemsDbProxyCertListItemsItem["EndpointName"].isNull())
+			dbProxyCertListItemsObject.endpointName = valueDbProxyCertListItemsDbProxyCertListItemsItem["EndpointName"].asString();
+		if(!valueDbProxyCertListItemsDbProxyCertListItemsItem["EndpointType"].isNull())
+			dbProxyCertListItemsObject.endpointType = valueDbProxyCertListItemsDbProxyCertListItemsItem["EndpointType"].asString();
+		if(!valueDbProxyCertListItemsDbProxyCertListItemsItem["CertCommonName"].isNull())
+			dbProxyCertListItemsObject.certCommonName = valueDbProxyCertListItemsDbProxyCertListItemsItem["CertCommonName"].asString();
+		if(!valueDbProxyCertListItemsDbProxyCertListItemsItem["SslExpiredTime"].isNull())
+			dbProxyCertListItemsObject.sslExpiredTime = valueDbProxyCertListItemsDbProxyCertListItemsItem["SslExpiredTime"].asString();
+		dbProxyCertListItems_.push_back(dbProxyCertListItemsObject);
+	}
+
+}
+
+std::vector<GetDbProxyInstanceSslResult::DbProxyCertListItemsItem> GetDbProxyInstanceSslResult::getDbProxyCertListItems()const
+{
+	return dbProxyCertListItems_;
+}
+

rds/src/model/MigrateConnectionToOtherZoneRequest.cc

@@ -0,0 +1,62 @@
+/*
+ * 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.
+ */
+
+#include <alibabacloud/rds/model/MigrateConnectionToOtherZoneRequest.h>
+
+using AlibabaCloud::Rds::Model::MigrateConnectionToOtherZoneRequest;
+
+MigrateConnectionToOtherZoneRequest::MigrateConnectionToOtherZoneRequest() :
+	RpcServiceRequest("rds", "2014-08-15", "MigrateConnectionToOtherZone")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+MigrateConnectionToOtherZoneRequest::~MigrateConnectionToOtherZoneRequest()
+{}
+
+std::string MigrateConnectionToOtherZoneRequest::getConnectionString()const
+{
+	return connectionString_;
+}
+
+void MigrateConnectionToOtherZoneRequest::setConnectionString(const std::string& connectionString)
+{
+	connectionString_ = connectionString;
+	setParameter("ConnectionString", connectionString);
+}
+
+std::string MigrateConnectionToOtherZoneRequest::getZoneId()const
+{
+	return zoneId_;
+}
+
+void MigrateConnectionToOtherZoneRequest::setZoneId(const std::string& zoneId)
+{
+	zoneId_ = zoneId;
+	setParameter("ZoneId", zoneId);
+}
+
+std::string MigrateConnectionToOtherZoneRequest::getDBInstanceId()const
+{
+	return dBInstanceId_;
+}
+
+void MigrateConnectionToOtherZoneRequest::setDBInstanceId(const std::string& dBInstanceId)
+{
+	dBInstanceId_ = dBInstanceId;
+	setParameter("DBInstanceId", dBInstanceId);
+}
+

rds/src/model/MigrateConnectionToOtherZoneResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/rds/model/MigrateConnectionToOtherZoneResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Rds;
+using namespace AlibabaCloud::Rds::Model;
+
+MigrateConnectionToOtherZoneResult::MigrateConnectionToOtherZoneResult() :
+	ServiceResult()
+{}
+
+MigrateConnectionToOtherZoneResult::MigrateConnectionToOtherZoneResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+MigrateConnectionToOtherZoneResult::~MigrateConnectionToOtherZoneResult()
+{}
+
+void MigrateConnectionToOtherZoneResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["Code"].isNull())
+		code_ = value["Code"].asString();
+	if(!value["Message"].isNull())
+		message_ = value["Message"].asString();
+
+}
+
+std::string MigrateConnectionToOtherZoneResult::getMessage()const
+{
+	return message_;
+}
+
+std::string MigrateConnectionToOtherZoneResult::getCode()const
+{
+	return code_;
+}
+

rds/src/model/MigrateDBInstanceRequest.cc

@@ -104,6 +104,17 @@ void MigrateDBInstanceRequest::setStorage(int storage)
 	setParameter("Storage", std::to_string(storage));
 }
 
+std::string MigrateDBInstanceRequest::getZoneIdForFollower()const
+{
+	return zoneIdForFollower_;
+}
+
+void MigrateDBInstanceRequest::setZoneIdForFollower(const std::string& zoneIdForFollower)
+{
+	zoneIdForFollower_ = zoneIdForFollower;
+	setParameter("ZoneIdForFollower", zoneIdForFollower);
+}
+
 std::string MigrateDBInstanceRequest::getAccessKeyId()const
 {
 	return accessKeyId_;
@@ -192,6 +203,17 @@ void MigrateDBInstanceRequest::setResourceOwnerAccount(const std::string& resour
 	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
 }
 
+std::string MigrateDBInstanceRequest::getZoneIdForLog()const
+{
+	return zoneIdForLog_;
+}
+
+void MigrateDBInstanceRequest::setZoneIdForLog(const std::string& zoneIdForLog)
+{
+	zoneIdForLog_ = zoneIdForLog;
+	setParameter("ZoneIdForLog", zoneIdForLog);
+}
+
 long MigrateDBInstanceRequest::getOwnerId()const
 {
 	return ownerId_;

rds/src/model/ModifyDbProxyInstanceSslRequest.cc

@@ -0,0 +1,95 @@
+/*
+ * 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.
+ */
+
+#include <alibabacloud/rds/model/ModifyDbProxyInstanceSslRequest.h>
+
+using AlibabaCloud::Rds::Model::ModifyDbProxyInstanceSslRequest;
+
+ModifyDbProxyInstanceSslRequest::ModifyDbProxyInstanceSslRequest() :
+	RpcServiceRequest("rds", "2014-08-15", "ModifyDbProxyInstanceSsl")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ModifyDbProxyInstanceSslRequest::~ModifyDbProxyInstanceSslRequest()
+{}
+
+std::string ModifyDbProxyInstanceSslRequest::getDbProxySslEnabled()const
+{
+	return dbProxySslEnabled_;
+}
+
+void ModifyDbProxyInstanceSslRequest::setDbProxySslEnabled(const std::string& dbProxySslEnabled)
+{
+	dbProxySslEnabled_ = dbProxySslEnabled;
+	setParameter("DbProxySslEnabled", dbProxySslEnabled);
+}
+
+std::string ModifyDbProxyInstanceSslRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void ModifyDbProxyInstanceSslRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string ModifyDbProxyInstanceSslRequest::getDbProxyConnectString()const
+{
+	return dbProxyConnectString_;
+}
+
+void ModifyDbProxyInstanceSslRequest::setDbProxyConnectString(const std::string& dbProxyConnectString)
+{
+	dbProxyConnectString_ = dbProxyConnectString;
+	setParameter("DbProxyConnectString", dbProxyConnectString);
+}
+
+std::string ModifyDbProxyInstanceSslRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void ModifyDbProxyInstanceSslRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+std::string ModifyDbProxyInstanceSslRequest::getDbInstanceId()const
+{
+	return dbInstanceId_;
+}
+
+void ModifyDbProxyInstanceSslRequest::setDbInstanceId(const std::string& dbInstanceId)
+{
+	dbInstanceId_ = dbInstanceId;
+	setParameter("DbInstanceId", dbInstanceId);
+}
+
+std::string ModifyDbProxyInstanceSslRequest::getDbProxyEndpointId()const
+{
+	return dbProxyEndpointId_;
+}
+
+void ModifyDbProxyInstanceSslRequest::setDbProxyEndpointId(const std::string& dbProxyEndpointId)
+{
+	dbProxyEndpointId_ = dbProxyEndpointId;
+	setParameter("DbProxyEndpointId", dbProxyEndpointId);
+}
+

rds/src/model/ModifyDbProxyInstanceSslResult.cc

@@ -0,0 +1,44 @@
+/*
+ * 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.
+ */
+
+#include <alibabacloud/rds/model/ModifyDbProxyInstanceSslResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Rds;
+using namespace AlibabaCloud::Rds::Model;
+
+ModifyDbProxyInstanceSslResult::ModifyDbProxyInstanceSslResult() :
+	ServiceResult()
+{}
+
+ModifyDbProxyInstanceSslResult::ModifyDbProxyInstanceSslResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ModifyDbProxyInstanceSslResult::~ModifyDbProxyInstanceSslResult()
+{}
+
+void ModifyDbProxyInstanceSslResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

rds/src/model/ModifyLicenseInfoRequest.cc

@@ -0,0 +1,106 @@
+/*
+ * 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.
+ */
+
+#include <alibabacloud/rds/model/ModifyLicenseInfoRequest.h>
+
+using AlibabaCloud::Rds::Model::ModifyLicenseInfoRequest;
+
+ModifyLicenseInfoRequest::ModifyLicenseInfoRequest() :
+	RpcServiceRequest("rds", "2014-08-15", "ModifyLicenseInfo")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ModifyLicenseInfoRequest::~ModifyLicenseInfoRequest()
+{}
+
+long ModifyLicenseInfoRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void ModifyLicenseInfoRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string ModifyLicenseInfoRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void ModifyLicenseInfoRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string ModifyLicenseInfoRequest::getClientToken()const
+{
+	return clientToken_;
+}
+
+void ModifyLicenseInfoRequest::setClientToken(const std::string& clientToken)
+{
+	clientToken_ = clientToken;
+	setParameter("ClientToken", clientToken);
+}
+
+long ModifyLicenseInfoRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void ModifyLicenseInfoRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string ModifyLicenseInfoRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void ModifyLicenseInfoRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string ModifyLicenseInfoRequest::getLicense()const
+{
+	return license_;
+}
+
+void ModifyLicenseInfoRequest::setLicense(const std::string& license)
+{
+	license_ = license;
+	setParameter("License", license);
+}
+
+std::string ModifyLicenseInfoRequest::getDBInstanceId()const
+{
+	return dBInstanceId_;
+}
+
+void ModifyLicenseInfoRequest::setDBInstanceId(const std::string& dBInstanceId)
+{
+	dBInstanceId_ = dBInstanceId;
+	setParameter("DBInstanceId", dBInstanceId);
+}
+

rds/src/model/ModifyLicenseInfoResult.cc

@@ -0,0 +1,44 @@
+/*
+ * 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.
+ */
+
+#include <alibabacloud/rds/model/ModifyLicenseInfoResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Rds;
+using namespace AlibabaCloud::Rds::Model;
+
+ModifyLicenseInfoResult::ModifyLicenseInfoResult() :
+	ServiceResult()
+{}
+
+ModifyLicenseInfoResult::ModifyLicenseInfoResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+ModifyLicenseInfoResult::~ModifyLicenseInfoResult()
+{}
+
+void ModifyLicenseInfoResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+
+}
+

rds/src/model/RebuildDBInstanceRequest.cc

@@ -38,6 +38,17 @@ void RebuildDBInstanceRequest::setResourceOwnerId(long resourceOwnerId)
 	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
+std::string RebuildDBInstanceRequest::getRebuildNodeType()const
+{
+	return rebuildNodeType_;
+}
+
+void RebuildDBInstanceRequest::setRebuildNodeType(const std::string& rebuildNodeType)
+{
+	rebuildNodeType_ = rebuildNodeType;
+	setParameter("RebuildNodeType", rebuildNodeType);
+}
+
 std::string RebuildDBInstanceRequest::getAccessKeyId()const
 {
 	return accessKeyId_;

rds/src/model/UpgradeDBInstanceKernelVersionRequest.cc

@@ -38,6 +38,39 @@ void UpgradeDBInstanceKernelVersionRequest::setResourceOwnerId(long resourceOwne
 	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
+std::string UpgradeDBInstanceKernelVersionRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void UpgradeDBInstanceKernelVersionRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string UpgradeDBInstanceKernelVersionRequest::getDBInstanceId()const
+{
+	return dBInstanceId_;
+}
+
+void UpgradeDBInstanceKernelVersionRequest::setDBInstanceId(const std::string& dBInstanceId)
+{
+	dBInstanceId_ = dBInstanceId;
+	setParameter("DBInstanceId", dBInstanceId);
+}
+
+std::string UpgradeDBInstanceKernelVersionRequest::getSwitchTime()const
+{
+	return switchTime_;
+}
+
+void UpgradeDBInstanceKernelVersionRequest::setSwitchTime(const std::string& switchTime)
+{
+	switchTime_ = switchTime;
+	setParameter("SwitchTime", switchTime);
+}
+
 std::string UpgradeDBInstanceKernelVersionRequest::getResourceOwnerAccount()const
 {
 	return resourceOwnerAccount_;
@@ -60,15 +93,15 @@ void UpgradeDBInstanceKernelVersionRequest::setOwnerId(long ownerId)
 	setParameter("OwnerId", std::to_string(ownerId));
 }
 
-std::string UpgradeDBInstanceKernelVersionRequest::getAccessKeyId()const
+std::string UpgradeDBInstanceKernelVersionRequest::getTargetMinorVersion()const
 {
-	return accessKeyId_;
+	return targetMinorVersion_;
 }
 
-void UpgradeDBInstanceKernelVersionRequest::setAccessKeyId(const std::string& accessKeyId)
+void UpgradeDBInstanceKernelVersionRequest::setTargetMinorVersion(const std::string& targetMinorVersion)
 {
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+	targetMinorVersion_ = targetMinorVersion;
+	setParameter("TargetMinorVersion", targetMinorVersion);
 }
 
 std::string UpgradeDBInstanceKernelVersionRequest::getUpgradeTime()const
@@ -82,25 +115,3 @@ void UpgradeDBInstanceKernelVersionRequest::setUpgradeTime(const std::string& up
 	setParameter("UpgradeTime", upgradeTime);
 }
 
-std::string UpgradeDBInstanceKernelVersionRequest::getDBInstanceId()const
-{
-	return dBInstanceId_;
-}
-
-void UpgradeDBInstanceKernelVersionRequest::setDBInstanceId(const std::string& dBInstanceId)
-{
-	dBInstanceId_ = dBInstanceId;
-	setParameter("DBInstanceId", dBInstanceId);
-}
-
-std::string UpgradeDBInstanceKernelVersionRequest::getSwitchTime()const
-{
-	return switchTime_;
-}
-
-void UpgradeDBInstanceKernelVersionRequest::setSwitchTime(const std::string& switchTime)
-{
-	switchTime_ = switchTime;
-	setParameter("SwitchTime", switchTime);
-}
-