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

Support CreateDBLink for polardb oracle.

Browse Source
This commit is contained in:
sdk-team
2020-12-02 09:41:12 +00:00
parent 969a4a2631
commit 818bfd3cf1
34 changed files with 2707 additions and 9 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
CHANGELOG
View File

@@ -1,3 +1,8 @@
2020-12-02 Version: patch
- Support CreateDBLink for polardb oracle.
- Support DeleteDBLink for polardb oracle.
- Support DescribeDBLinks for polardb oracle.
2020-12-02 Version: patch
- Update version.

28
polardb/CMakeLists.txt
View File

@@ -33,6 +33,8 @@ set(polardb_public_header_model
include/alibabacloud/polardb/model/CreateDBClusterEndpointResult.h
include/alibabacloud/polardb/model/CreateDBEndpointAddressRequest.h
include/alibabacloud/polardb/model/CreateDBEndpointAddressResult.h
include/alibabacloud/polardb/model/CreateDBLinkRequest.h
include/alibabacloud/polardb/model/CreateDBLinkResult.h
include/alibabacloud/polardb/model/CreateDBNodesRequest.h
include/alibabacloud/polardb/model/CreateDBNodesResult.h
include/alibabacloud/polardb/model/CreateDatabaseRequest.h
@@ -47,6 +49,8 @@ set(polardb_public_header_model
include/alibabacloud/polardb/model/DeleteDBClusterEndpointResult.h
include/alibabacloud/polardb/model/DeleteDBEndpointAddressRequest.h
include/alibabacloud/polardb/model/DeleteDBEndpointAddressResult.h
include/alibabacloud/polardb/model/DeleteDBLinkRequest.h
include/alibabacloud/polardb/model/DeleteDBLinkResult.h
include/alibabacloud/polardb/model/DeleteDBNodesRequest.h
include/alibabacloud/polardb/model/DeleteDBNodesResult.h
include/alibabacloud/polardb/model/DeleteDatabaseRequest.h
@@ -91,6 +95,8 @@ set(polardb_public_header_model
include/alibabacloud/polardb/model/DescribeDBClustersResult.h
include/alibabacloud/polardb/model/DescribeDBClustersWithBackupsRequest.h
include/alibabacloud/polardb/model/DescribeDBClustersWithBackupsResult.h
include/alibabacloud/polardb/model/DescribeDBLinksRequest.h
include/alibabacloud/polardb/model/DescribeDBLinksResult.h
include/alibabacloud/polardb/model/DescribeDBNodePerformanceRequest.h
include/alibabacloud/polardb/model/DescribeDBNodePerformanceResult.h
include/alibabacloud/polardb/model/DescribeDatabasesRequest.h
@@ -99,8 +105,12 @@ set(polardb_public_header_model
include/alibabacloud/polardb/model/DescribeDetachedBackupsResult.h
include/alibabacloud/polardb/model/DescribeGlobalDatabaseNetworksRequest.h
include/alibabacloud/polardb/model/DescribeGlobalDatabaseNetworksResult.h
include/alibabacloud/polardb/model/DescribeLocalAvailableRecoveryTimeRequest.h
include/alibabacloud/polardb/model/DescribeLocalAvailableRecoveryTimeResult.h
include/alibabacloud/polardb/model/DescribeLogBackupPolicyRequest.h
include/alibabacloud/polardb/model/DescribeLogBackupPolicyResult.h
include/alibabacloud/polardb/model/DescribeMetaListRequest.h
include/alibabacloud/polardb/model/DescribeMetaListResult.h
include/alibabacloud/polardb/model/DescribePendingMaintenanceActionRequest.h
include/alibabacloud/polardb/model/DescribePendingMaintenanceActionResult.h
include/alibabacloud/polardb/model/DescribePendingMaintenanceActionsRequest.h
@@ -111,6 +121,8 @@ set(polardb_public_header_model
include/alibabacloud/polardb/model/DescribeSlowLogRecordsResult.h
include/alibabacloud/polardb/model/DescribeSlowLogsRequest.h
include/alibabacloud/polardb/model/DescribeSlowLogsResult.h
include/alibabacloud/polardb/model/DescribeTasksRequest.h
include/alibabacloud/polardb/model/DescribeTasksResult.h
include/alibabacloud/polardb/model/FailoverDBClusterRequest.h
include/alibabacloud/polardb/model/FailoverDBClusterResult.h
include/alibabacloud/polardb/model/GrantAccountPrivilegeRequest.h
@@ -161,6 +173,8 @@ set(polardb_public_header_model
include/alibabacloud/polardb/model/ResetAccountResult.h
include/alibabacloud/polardb/model/RestartDBNodeRequest.h
include/alibabacloud/polardb/model/RestartDBNodeResult.h
include/alibabacloud/polardb/model/RestoreTableRequest.h
include/alibabacloud/polardb/model/RestoreTableResult.h
include/alibabacloud/polardb/model/RevokeAccountPrivilegeRequest.h
include/alibabacloud/polardb/model/RevokeAccountPrivilegeResult.h
include/alibabacloud/polardb/model/TagResourcesRequest.h
@@ -182,6 +196,8 @@ set(polardb_src
src/model/CreateDBClusterEndpointResult.cc
src/model/CreateDBEndpointAddressRequest.cc
src/model/CreateDBEndpointAddressResult.cc
src/model/CreateDBLinkRequest.cc
src/model/CreateDBLinkResult.cc
src/model/CreateDBNodesRequest.cc
src/model/CreateDBNodesResult.cc
src/model/CreateDatabaseRequest.cc
@@ -196,6 +212,8 @@ set(polardb_src
src/model/DeleteDBClusterEndpointResult.cc
src/model/DeleteDBEndpointAddressRequest.cc
src/model/DeleteDBEndpointAddressResult.cc
src/model/DeleteDBLinkRequest.cc
src/model/DeleteDBLinkResult.cc
src/model/DeleteDBNodesRequest.cc
src/model/DeleteDBNodesResult.cc
src/model/DeleteDatabaseRequest.cc
@@ -240,6 +258,8 @@ set(polardb_src
src/model/DescribeDBClustersResult.cc
src/model/DescribeDBClustersWithBackupsRequest.cc
src/model/DescribeDBClustersWithBackupsResult.cc
src/model/DescribeDBLinksRequest.cc
src/model/DescribeDBLinksResult.cc
src/model/DescribeDBNodePerformanceRequest.cc
src/model/DescribeDBNodePerformanceResult.cc
src/model/DescribeDatabasesRequest.cc
@@ -248,8 +268,12 @@ set(polardb_src
src/model/DescribeDetachedBackupsResult.cc
src/model/DescribeGlobalDatabaseNetworksRequest.cc
src/model/DescribeGlobalDatabaseNetworksResult.cc
src/model/DescribeLocalAvailableRecoveryTimeRequest.cc
src/model/DescribeLocalAvailableRecoveryTimeResult.cc
src/model/DescribeLogBackupPolicyRequest.cc
src/model/DescribeLogBackupPolicyResult.cc
src/model/DescribeMetaListRequest.cc
src/model/DescribeMetaListResult.cc
src/model/DescribePendingMaintenanceActionRequest.cc
src/model/DescribePendingMaintenanceActionResult.cc
src/model/DescribePendingMaintenanceActionsRequest.cc
@@ -260,6 +284,8 @@ set(polardb_src
src/model/DescribeSlowLogRecordsResult.cc
src/model/DescribeSlowLogsRequest.cc
src/model/DescribeSlowLogsResult.cc
src/model/DescribeTasksRequest.cc
src/model/DescribeTasksResult.cc
src/model/FailoverDBClusterRequest.cc
src/model/FailoverDBClusterResult.cc
src/model/GrantAccountPrivilegeRequest.cc
@@ -310,6 +336,8 @@ set(polardb_src
src/model/ResetAccountResult.cc
src/model/RestartDBNodeRequest.cc
src/model/RestartDBNodeResult.cc
src/model/RestoreTableRequest.cc
src/model/RestoreTableResult.cc
src/model/RevokeAccountPrivilegeRequest.cc
src/model/RevokeAccountPrivilegeResult.cc
src/model/TagResourcesRequest.cc

56
polardb/include/alibabacloud/polardb/PolardbClient.h
View File

@@ -34,6 +34,8 @@
#include "model/CreateDBClusterEndpointResult.h"
#include "model/CreateDBEndpointAddressRequest.h"
#include "model/CreateDBEndpointAddressResult.h"
#include "model/CreateDBLinkRequest.h"
#include "model/CreateDBLinkResult.h"
#include "model/CreateDBNodesRequest.h"
#include "model/CreateDBNodesResult.h"
#include "model/CreateDatabaseRequest.h"
@@ -48,6 +50,8 @@
#include "model/DeleteDBClusterEndpointResult.h"
#include "model/DeleteDBEndpointAddressRequest.h"
#include "model/DeleteDBEndpointAddressResult.h"
#include "model/DeleteDBLinkRequest.h"
#include "model/DeleteDBLinkResult.h"
#include "model/DeleteDBNodesRequest.h"
#include "model/DeleteDBNodesResult.h"
#include "model/DeleteDatabaseRequest.h"
@@ -92,6 +96,8 @@
#include "model/DescribeDBClustersResult.h"
#include "model/DescribeDBClustersWithBackupsRequest.h"
#include "model/DescribeDBClustersWithBackupsResult.h"
#include "model/DescribeDBLinksRequest.h"
#include "model/DescribeDBLinksResult.h"
#include "model/DescribeDBNodePerformanceRequest.h"
#include "model/DescribeDBNodePerformanceResult.h"
#include "model/DescribeDatabasesRequest.h"
@@ -100,8 +106,12 @@
#include "model/DescribeDetachedBackupsResult.h"
#include "model/DescribeGlobalDatabaseNetworksRequest.h"
#include "model/DescribeGlobalDatabaseNetworksResult.h"
#include "model/DescribeLocalAvailableRecoveryTimeRequest.h"
#include "model/DescribeLocalAvailableRecoveryTimeResult.h"
#include "model/DescribeLogBackupPolicyRequest.h"
#include "model/DescribeLogBackupPolicyResult.h"
#include "model/DescribeMetaListRequest.h"
#include "model/DescribeMetaListResult.h"
#include "model/DescribePendingMaintenanceActionRequest.h"
#include "model/DescribePendingMaintenanceActionResult.h"
#include "model/DescribePendingMaintenanceActionsRequest.h"
@@ -112,6 +122,8 @@
#include "model/DescribeSlowLogRecordsResult.h"
#include "model/DescribeSlowLogsRequest.h"
#include "model/DescribeSlowLogsResult.h"
#include "model/DescribeTasksRequest.h"
#include "model/DescribeTasksResult.h"
#include "model/FailoverDBClusterRequest.h"
#include "model/FailoverDBClusterResult.h"
#include "model/GrantAccountPrivilegeRequest.h"
@@ -162,6 +174,8 @@
#include "model/ResetAccountResult.h"
#include "model/RestartDBNodeRequest.h"
#include "model/RestartDBNodeResult.h"
#include "model/RestoreTableRequest.h"
#include "model/RestoreTableResult.h"
#include "model/RevokeAccountPrivilegeRequest.h"
#include "model/RevokeAccountPrivilegeResult.h"
#include "model/TagResourcesRequest.h"
@@ -195,6 +209,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::CreateDBEndpointAddressResult> CreateDBEndpointAddressOutcome;
typedef std::future<CreateDBEndpointAddressOutcome> CreateDBEndpointAddressOutcomeCallable;
typedef std::function<void(const PolardbClient*, const Model::CreateDBEndpointAddressRequest&, const CreateDBEndpointAddressOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDBEndpointAddressAsyncHandler;
typedef Outcome<Error, Model::CreateDBLinkResult> CreateDBLinkOutcome;
typedef std::future<CreateDBLinkOutcome> CreateDBLinkOutcomeCallable;
typedef std::function<void(const PolardbClient*, const Model::CreateDBLinkRequest&, const CreateDBLinkOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDBLinkAsyncHandler;
typedef Outcome<Error, Model::CreateDBNodesResult> CreateDBNodesOutcome;
typedef std::future<CreateDBNodesOutcome> CreateDBNodesOutcomeCallable;
typedef std::function<void(const PolardbClient*, const Model::CreateDBNodesRequest&, const CreateDBNodesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateDBNodesAsyncHandler;
@@ -216,6 +233,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DeleteDBEndpointAddressResult> DeleteDBEndpointAddressOutcome;
typedef std::future<DeleteDBEndpointAddressOutcome> DeleteDBEndpointAddressOutcomeCallable;
typedef std::function<void(const PolardbClient*, const Model::DeleteDBEndpointAddressRequest&, const DeleteDBEndpointAddressOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDBEndpointAddressAsyncHandler;
typedef Outcome<Error, Model::DeleteDBLinkResult> DeleteDBLinkOutcome;
typedef std::future<DeleteDBLinkOutcome> DeleteDBLinkOutcomeCallable;
typedef std::function<void(const PolardbClient*, const Model::DeleteDBLinkRequest&, const DeleteDBLinkOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDBLinkAsyncHandler;
typedef Outcome<Error, Model::DeleteDBNodesResult> DeleteDBNodesOutcome;
typedef std::future<DeleteDBNodesOutcome> DeleteDBNodesOutcomeCallable;
typedef std::function<void(const PolardbClient*, const Model::DeleteDBNodesRequest&, const DeleteDBNodesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DeleteDBNodesAsyncHandler;
@@ -282,6 +302,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DescribeDBClustersWithBackupsResult> DescribeDBClustersWithBackupsOutcome;
typedef std::future<DescribeDBClustersWithBackupsOutcome> DescribeDBClustersWithBackupsOutcomeCallable;
typedef std::function<void(const PolardbClient*, const Model::DescribeDBClustersWithBackupsRequest&, const DescribeDBClustersWithBackupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBClustersWithBackupsAsyncHandler;
typedef Outcome<Error, Model::DescribeDBLinksResult> DescribeDBLinksOutcome;
typedef std::future<DescribeDBLinksOutcome> DescribeDBLinksOutcomeCallable;
typedef std::function<void(const PolardbClient*, const Model::DescribeDBLinksRequest&, const DescribeDBLinksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBLinksAsyncHandler;
typedef Outcome<Error, Model::DescribeDBNodePerformanceResult> DescribeDBNodePerformanceOutcome;
typedef std::future<DescribeDBNodePerformanceOutcome> DescribeDBNodePerformanceOutcomeCallable;
typedef std::function<void(const PolardbClient*, const Model::DescribeDBNodePerformanceRequest&, const DescribeDBNodePerformanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBNodePerformanceAsyncHandler;
@@ -294,9 +317,15 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DescribeGlobalDatabaseNetworksResult> DescribeGlobalDatabaseNetworksOutcome;
typedef std::future<DescribeGlobalDatabaseNetworksOutcome> DescribeGlobalDatabaseNetworksOutcomeCallable;
typedef std::function<void(const PolardbClient*, const Model::DescribeGlobalDatabaseNetworksRequest&, const DescribeGlobalDatabaseNetworksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeGlobalDatabaseNetworksAsyncHandler;
typedef Outcome<Error, Model::DescribeLocalAvailableRecoveryTimeResult> DescribeLocalAvailableRecoveryTimeOutcome;
typedef std::future<DescribeLocalAvailableRecoveryTimeOutcome> DescribeLocalAvailableRecoveryTimeOutcomeCallable;
typedef std::function<void(const PolardbClient*, const Model::DescribeLocalAvailableRecoveryTimeRequest&, const DescribeLocalAvailableRecoveryTimeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLocalAvailableRecoveryTimeAsyncHandler;
typedef Outcome<Error, Model::DescribeLogBackupPolicyResult> DescribeLogBackupPolicyOutcome;
typedef std::future<DescribeLogBackupPolicyOutcome> DescribeLogBackupPolicyOutcomeCallable;
typedef std::function<void(const PolardbClient*, const Model::DescribeLogBackupPolicyRequest&, const DescribeLogBackupPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLogBackupPolicyAsyncHandler;
typedef Outcome<Error, Model::DescribeMetaListResult> DescribeMetaListOutcome;
typedef std::future<DescribeMetaListOutcome> DescribeMetaListOutcomeCallable;
typedef std::function<void(const PolardbClient*, const Model::DescribeMetaListRequest&, const DescribeMetaListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeMetaListAsyncHandler;
typedef Outcome<Error, Model::DescribePendingMaintenanceActionResult> DescribePendingMaintenanceActionOutcome;
typedef std::future<DescribePendingMaintenanceActionOutcome> DescribePendingMaintenanceActionOutcomeCallable;
typedef std::function<void(const PolardbClient*, const Model::DescribePendingMaintenanceActionRequest&, const DescribePendingMaintenanceActionOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribePendingMaintenanceActionAsyncHandler;
@@ -312,6 +341,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DescribeSlowLogsResult> DescribeSlowLogsOutcome;
typedef std::future<DescribeSlowLogsOutcome> DescribeSlowLogsOutcomeCallable;
typedef std::function<void(const PolardbClient*, const Model::DescribeSlowLogsRequest&, const DescribeSlowLogsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSlowLogsAsyncHandler;
typedef Outcome<Error, Model::DescribeTasksResult> DescribeTasksOutcome;
typedef std::future<DescribeTasksOutcome> DescribeTasksOutcomeCallable;
typedef std::function<void(const PolardbClient*, const Model::DescribeTasksRequest&, const DescribeTasksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeTasksAsyncHandler;
typedef Outcome<Error, Model::FailoverDBClusterResult> FailoverDBClusterOutcome;
typedef std::future<FailoverDBClusterOutcome> FailoverDBClusterOutcomeCallable;
typedef std::function<void(const PolardbClient*, const Model::FailoverDBClusterRequest&, const FailoverDBClusterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> FailoverDBClusterAsyncHandler;
@@ -387,6 +419,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::RestartDBNodeResult> RestartDBNodeOutcome;
typedef std::future<RestartDBNodeOutcome> RestartDBNodeOutcomeCallable;
typedef std::function<void(const PolardbClient*, const Model::RestartDBNodeRequest&, const RestartDBNodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RestartDBNodeAsyncHandler;
typedef Outcome<Error, Model::RestoreTableResult> RestoreTableOutcome;
typedef std::future<RestoreTableOutcome> RestoreTableOutcomeCallable;
typedef std::function<void(const PolardbClient*, const Model::RestoreTableRequest&, const RestoreTableOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RestoreTableAsyncHandler;
typedef Outcome<Error, Model::RevokeAccountPrivilegeResult> RevokeAccountPrivilegeOutcome;
typedef std::future<RevokeAccountPrivilegeOutcome> RevokeAccountPrivilegeOutcomeCallable;
typedef std::function<void(const PolardbClient*, const Model::RevokeAccountPrivilegeRequest&, const RevokeAccountPrivilegeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RevokeAccountPrivilegeAsyncHandler;
@@ -419,6 +454,9 @@ namespace AlibabaCloud
CreateDBEndpointAddressOutcome createDBEndpointAddress(const Model::CreateDBEndpointAddressRequest &request)const;
void createDBEndpointAddressAsync(const Model::CreateDBEndpointAddressRequest& request, const CreateDBEndpointAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateDBEndpointAddressOutcomeCallable createDBEndpointAddressCallable(const Model::CreateDBEndpointAddressRequest& request) const;
CreateDBLinkOutcome createDBLink(const Model::CreateDBLinkRequest &request)const;
void createDBLinkAsync(const Model::CreateDBLinkRequest& request, const CreateDBLinkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateDBLinkOutcomeCallable createDBLinkCallable(const Model::CreateDBLinkRequest& request) const;
CreateDBNodesOutcome createDBNodes(const Model::CreateDBNodesRequest &request)const;
void createDBNodesAsync(const Model::CreateDBNodesRequest& request, const CreateDBNodesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CreateDBNodesOutcomeCallable createDBNodesCallable(const Model::CreateDBNodesRequest& request) const;
@@ -440,6 +478,9 @@ namespace AlibabaCloud
DeleteDBEndpointAddressOutcome deleteDBEndpointAddress(const Model::DeleteDBEndpointAddressRequest &request)const;
void deleteDBEndpointAddressAsync(const Model::DeleteDBEndpointAddressRequest& request, const DeleteDBEndpointAddressAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteDBEndpointAddressOutcomeCallable deleteDBEndpointAddressCallable(const Model::DeleteDBEndpointAddressRequest& request) const;
DeleteDBLinkOutcome deleteDBLink(const Model::DeleteDBLinkRequest &request)const;
void deleteDBLinkAsync(const Model::DeleteDBLinkRequest& request, const DeleteDBLinkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteDBLinkOutcomeCallable deleteDBLinkCallable(const Model::DeleteDBLinkRequest& request) const;
DeleteDBNodesOutcome deleteDBNodes(const Model::DeleteDBNodesRequest &request)const;
void deleteDBNodesAsync(const Model::DeleteDBNodesRequest& request, const DeleteDBNodesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DeleteDBNodesOutcomeCallable deleteDBNodesCallable(const Model::DeleteDBNodesRequest& request) const;
@@ -506,6 +547,9 @@ namespace AlibabaCloud
DescribeDBClustersWithBackupsOutcome describeDBClustersWithBackups(const Model::DescribeDBClustersWithBackupsRequest &request)const;
void describeDBClustersWithBackupsAsync(const Model::DescribeDBClustersWithBackupsRequest& request, const DescribeDBClustersWithBackupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDBClustersWithBackupsOutcomeCallable describeDBClustersWithBackupsCallable(const Model::DescribeDBClustersWithBackupsRequest& request) const;
DescribeDBLinksOutcome describeDBLinks(const Model::DescribeDBLinksRequest &request)const;
void describeDBLinksAsync(const Model::DescribeDBLinksRequest& request, const DescribeDBLinksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDBLinksOutcomeCallable describeDBLinksCallable(const Model::DescribeDBLinksRequest& request) const;
DescribeDBNodePerformanceOutcome describeDBNodePerformance(const Model::DescribeDBNodePerformanceRequest &request)const;
void describeDBNodePerformanceAsync(const Model::DescribeDBNodePerformanceRequest& request, const DescribeDBNodePerformanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDBNodePerformanceOutcomeCallable describeDBNodePerformanceCallable(const Model::DescribeDBNodePerformanceRequest& request) const;
@@ -518,9 +562,15 @@ namespace AlibabaCloud
DescribeGlobalDatabaseNetworksOutcome describeGlobalDatabaseNetworks(const Model::DescribeGlobalDatabaseNetworksRequest &request)const;
void describeGlobalDatabaseNetworksAsync(const Model::DescribeGlobalDatabaseNetworksRequest& request, const DescribeGlobalDatabaseNetworksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeGlobalDatabaseNetworksOutcomeCallable describeGlobalDatabaseNetworksCallable(const Model::DescribeGlobalDatabaseNetworksRequest& request) const;
DescribeLocalAvailableRecoveryTimeOutcome describeLocalAvailableRecoveryTime(const Model::DescribeLocalAvailableRecoveryTimeRequest &request)const;
void describeLocalAvailableRecoveryTimeAsync(const Model::DescribeLocalAvailableRecoveryTimeRequest& request, const DescribeLocalAvailableRecoveryTimeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLocalAvailableRecoveryTimeOutcomeCallable describeLocalAvailableRecoveryTimeCallable(const Model::DescribeLocalAvailableRecoveryTimeRequest& request) const;
DescribeLogBackupPolicyOutcome describeLogBackupPolicy(const Model::DescribeLogBackupPolicyRequest &request)const;
void describeLogBackupPolicyAsync(const Model::DescribeLogBackupPolicyRequest& request, const DescribeLogBackupPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeLogBackupPolicyOutcomeCallable describeLogBackupPolicyCallable(const Model::DescribeLogBackupPolicyRequest& request) const;
DescribeMetaListOutcome describeMetaList(const Model::DescribeMetaListRequest &request)const;
void describeMetaListAsync(const Model::DescribeMetaListRequest& request, const DescribeMetaListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeMetaListOutcomeCallable describeMetaListCallable(const Model::DescribeMetaListRequest& request) const;
DescribePendingMaintenanceActionOutcome describePendingMaintenanceAction(const Model::DescribePendingMaintenanceActionRequest &request)const;
void describePendingMaintenanceActionAsync(const Model::DescribePendingMaintenanceActionRequest& request, const DescribePendingMaintenanceActionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribePendingMaintenanceActionOutcomeCallable describePendingMaintenanceActionCallable(const Model::DescribePendingMaintenanceActionRequest& request) const;
@@ -536,6 +586,9 @@ namespace AlibabaCloud
DescribeSlowLogsOutcome describeSlowLogs(const Model::DescribeSlowLogsRequest &request)const;
void describeSlowLogsAsync(const Model::DescribeSlowLogsRequest& request, const DescribeSlowLogsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeSlowLogsOutcomeCallable describeSlowLogsCallable(const Model::DescribeSlowLogsRequest& request) const;
DescribeTasksOutcome describeTasks(const Model::DescribeTasksRequest &request)const;
void describeTasksAsync(const Model::DescribeTasksRequest& request, const DescribeTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeTasksOutcomeCallable describeTasksCallable(const Model::DescribeTasksRequest& request) const;
FailoverDBClusterOutcome failoverDBCluster(const Model::FailoverDBClusterRequest &request)const;
void failoverDBClusterAsync(const Model::FailoverDBClusterRequest& request, const FailoverDBClusterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
FailoverDBClusterOutcomeCallable failoverDBClusterCallable(const Model::FailoverDBClusterRequest& request) const;
@@ -611,6 +664,9 @@ namespace AlibabaCloud
RestartDBNodeOutcome restartDBNode(const Model::RestartDBNodeRequest &request)const;
void restartDBNodeAsync(const Model::RestartDBNodeRequest& request, const RestartDBNodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RestartDBNodeOutcomeCallable restartDBNodeCallable(const Model::RestartDBNodeRequest& request) const;
RestoreTableOutcome restoreTable(const Model::RestoreTableRequest &request)const;
void restoreTableAsync(const Model::RestoreTableRequest& request, const RestoreTableAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RestoreTableOutcomeCallable restoreTableCallable(const Model::RestoreTableRequest& request) const;
RevokeAccountPrivilegeOutcome revokeAccountPrivilege(const Model::RevokeAccountPrivilegeRequest &request)const;
void revokeAccountPrivilegeAsync(const Model::RevokeAccountPrivilegeRequest& request, const RevokeAccountPrivilegeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RevokeAccountPrivilegeOutcomeCallable revokeAccountPrivilegeCallable(const Model::RevokeAccountPrivilegeRequest& request) const;

81
polardb/include/alibabacloud/polardb/model/CreateDBLinkRequest.h Normal file
View File

@@ -0,0 +1,81 @@
/*
* 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_POLARDB_MODEL_CREATEDBLINKREQUEST_H_
#define ALIBABACLOUD_POLARDB_MODEL_CREATEDBLINKREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardb/PolardbExport.h>
namespace AlibabaCloud
{
namespace Polardb
{
namespace Model
{
class ALIBABACLOUD_POLARDB_EXPORT CreateDBLinkRequest : public RpcServiceRequest
{
public:
CreateDBLinkRequest();
~CreateDBLinkRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getSourceDBName()const;
void setSourceDBName(const std::string& sourceDBName);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTargetDBName()const;
void setTargetDBName(const std::string& targetDBName);
std::string getDBLinkName()const;
void setDBLinkName(const std::string& dBLinkName);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getTargetDBInstanceName()const;
void setTargetDBInstanceName(const std::string& targetDBInstanceName);
std::string getDBClusterId()const;
void setDBClusterId(const std::string& dBClusterId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
std::string getTargetDBPasswd()const;
void setTargetDBPasswd(const std::string& targetDBPasswd);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getTargetDBAccount()const;
void setTargetDBAccount(const std::string& targetDBAccount);
private:
long resourceOwnerId_;
std::string sourceDBName_;
std::string accessKeyId_;
std::string targetDBName_;
std::string dBLinkName_;
std::string resourceOwnerAccount_;
std::string targetDBInstanceName_;
std::string dBClusterId_;
std::string ownerAccount_;
std::string targetDBPasswd_;
long ownerId_;
std::string targetDBAccount_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDB_MODEL_CREATEDBLINKREQUEST_H_

49
polardb/include/alibabacloud/polardb/model/CreateDBLinkResult.h Normal file
View File

@@ -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_POLARDB_MODEL_CREATEDBLINKRESULT_H_
#define ALIBABACLOUD_POLARDB_MODEL_CREATEDBLINKRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/polardb/PolardbExport.h>
namespace AlibabaCloud
{
namespace Polardb
{
namespace Model
{
class ALIBABACLOUD_POLARDB_EXPORT CreateDBLinkResult : public ServiceResult
{
public:
CreateDBLinkResult();
explicit CreateDBLinkResult(const std::string &payload);
~CreateDBLinkResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_POLARDB_MODEL_CREATEDBLINKRESULT_H_

66
polardb/include/alibabacloud/polardb/model/DeleteDBLinkRequest.h Normal file
View File

@@ -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_POLARDB_MODEL_DELETEDBLINKREQUEST_H_
#define ALIBABACLOUD_POLARDB_MODEL_DELETEDBLINKREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardb/PolardbExport.h>
namespace AlibabaCloud
{
namespace Polardb
{
namespace Model
{
class ALIBABACLOUD_POLARDB_EXPORT DeleteDBLinkRequest : public RpcServiceRequest
{
public:
DeleteDBLinkRequest();
~DeleteDBLinkRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getDBLinkName()const;
void setDBLinkName(const std::string& dBLinkName);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getDBClusterId()const;
void setDBClusterId(const std::string& dBClusterId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string dBLinkName_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDB_MODEL_DELETEDBLINKREQUEST_H_

49
polardb/include/alibabacloud/polardb/model/DeleteDBLinkResult.h Normal file
View File

@@ -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_POLARDB_MODEL_DELETEDBLINKRESULT_H_
#define ALIBABACLOUD_POLARDB_MODEL_DELETEDBLINKRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/polardb/PolardbExport.h>
namespace AlibabaCloud
{
namespace Polardb
{
namespace Model
{
class ALIBABACLOUD_POLARDB_EXPORT DeleteDBLinkResult : public ServiceResult
{
public:
DeleteDBLinkResult();
explicit DeleteDBLinkResult(const std::string &payload);
~DeleteDBLinkResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_POLARDB_MODEL_DELETEDBLINKRESULT_H_

4
polardb/include/alibabacloud/polardb/model/DescribeDBClusterVersionResult.h
View File

@@ -42,8 +42,8 @@ namespace AlibabaCloud
std::string getDBVersion()const;
std::string getDBRevisionVersion()const;
std::string getDBVersionStatus()const;
std::string getDBClusterId()const;
std::string getDBMinorVersion()const;
std::string getDBInstanceName()const;
protected:
void parse(const std::string &payload);
@@ -53,8 +53,8 @@ namespace AlibabaCloud
std::string dBVersion_;
std::string dBRevisionVersion_;
std::string dBVersionStatus_;
std::string dBClusterId_;
std::string dBMinorVersion_;
std::string dBInstanceName_;
};
}

66
polardb/include/alibabacloud/polardb/model/DescribeDBLinksRequest.h Normal file
View File

@@ -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_POLARDB_MODEL_DESCRIBEDBLINKSREQUEST_H_
#define ALIBABACLOUD_POLARDB_MODEL_DESCRIBEDBLINKSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardb/PolardbExport.h>
namespace AlibabaCloud
{
namespace Polardb
{
namespace Model
{
class ALIBABACLOUD_POLARDB_EXPORT DescribeDBLinksRequest : public RpcServiceRequest
{
public:
DescribeDBLinksRequest();
~DescribeDBLinksRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getDBLinkName()const;
void setDBLinkName(const std::string& dBLinkName);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getDBClusterId()const;
void setDBClusterId(const std::string& dBClusterId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string dBLinkName_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDB_MODEL_DESCRIBEDBLINKSREQUEST_H_

62
polardb/include/alibabacloud/polardb/model/DescribeDBLinksResult.h Normal file
View File

@@ -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.
*/
#ifndef ALIBABACLOUD_POLARDB_MODEL_DESCRIBEDBLINKSRESULT_H_
#define ALIBABACLOUD_POLARDB_MODEL_DESCRIBEDBLINKSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/polardb/PolardbExport.h>
namespace AlibabaCloud
{
namespace Polardb
{
namespace Model
{
class ALIBABACLOUD_POLARDB_EXPORT DescribeDBLinksResult : public ServiceResult
{
public:
struct DBLinkInfosItem
{
std::string sourceDBName;
std::string targetDBName;
std::string targetAccount;
std::string targetDBInstanceName;
std::string dBInstanceName;
std::string dBLinkName;
};
DescribeDBLinksResult();
explicit DescribeDBLinksResult(const std::string &payload);
~DescribeDBLinksResult();
std::vector<DBLinkInfosItem> getDBLinkInfos()const;
std::string getDBInstanceName()const;
protected:
void parse(const std::string &payload);
private:
std::vector<DBLinkInfosItem> dBLinkInfos_;
std::string dBInstanceName_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDB_MODEL_DESCRIBEDBLINKSRESULT_H_

66
polardb/include/alibabacloud/polardb/model/DescribeLocalAvailableRecoveryTimeRequest.h Normal file
View File

@@ -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_POLARDB_MODEL_DESCRIBELOCALAVAILABLERECOVERYTIMEREQUEST_H_
#define ALIBABACLOUD_POLARDB_MODEL_DESCRIBELOCALAVAILABLERECOVERYTIMEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardb/PolardbExport.h>
namespace AlibabaCloud
{
namespace Polardb
{
namespace Model
{
class ALIBABACLOUD_POLARDB_EXPORT DescribeLocalAvailableRecoveryTimeRequest : public RpcServiceRequest
{
public:
DescribeLocalAvailableRecoveryTimeRequest();
~DescribeLocalAvailableRecoveryTimeRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getDBClusterId()const;
void setDBClusterId(const std::string& dBClusterId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string securityToken_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDB_MODEL_DESCRIBELOCALAVAILABLERECOVERYTIMEREQUEST_H_

55
polardb/include/alibabacloud/polardb/model/DescribeLocalAvailableRecoveryTimeResult.h Normal file
View File

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

81
polardb/include/alibabacloud/polardb/model/DescribeMetaListRequest.h Normal file
View File

@@ -0,0 +1,81 @@
/*
* 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_POLARDB_MODEL_DESCRIBEMETALISTREQUEST_H_
#define ALIBABACLOUD_POLARDB_MODEL_DESCRIBEMETALISTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardb/PolardbExport.h>
namespace AlibabaCloud
{
namespace Polardb
{
namespace Model
{
class ALIBABACLOUD_POLARDB_EXPORT DescribeMetaListRequest : public RpcServiceRequest
{
public:
DescribeMetaListRequest();
~DescribeMetaListRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
int getPageNumber()const;
void setPageNumber(int pageNumber);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
int getPageSize()const;
void setPageSize(int pageSize);
std::string getRestoreTime()const;
void setRestoreTime(const std::string& restoreTime);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getDBClusterId()const;
void setDBClusterId(const std::string& dBClusterId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
std::string getBackupId()const;
void setBackupId(const std::string& backupId);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getGetDbName()const;
void setGetDbName(const std::string& getDbName);
private:
long resourceOwnerId_;
int pageNumber_;
std::string accessKeyId_;
std::string securityToken_;
int pageSize_;
std::string restoreTime_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
std::string backupId_;
long ownerId_;
std::string getDbName_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDB_MODEL_DESCRIBEMETALISTREQUEST_H_

64
polardb/include/alibabacloud/polardb/model/DescribeMetaListResult.h Normal file
View File

@@ -0,0 +1,64 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDB_MODEL_DESCRIBEMETALISTRESULT_H_
#define ALIBABACLOUD_POLARDB_MODEL_DESCRIBEMETALISTRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/polardb/PolardbExport.h>
namespace AlibabaCloud
{
namespace Polardb
{
namespace Model
{
class ALIBABACLOUD_POLARDB_EXPORT DescribeMetaListResult : public ServiceResult
{
public:
struct MetaItem
{
std::string database;
std::vector<std::string> tables;
};
DescribeMetaListResult();
explicit DescribeMetaListResult(const std::string &payload);
~DescribeMetaListResult();
std::string getTotalRecordCount()const;
std::string getTotalPageCount()const;
std::string getPageSize()const;
std::string getPageNumber()const;
std::vector<MetaItem> getItems()const;
protected:
void parse(const std::string &payload);
private:
std::string totalRecordCount_;
std::string totalPageCount_;
std::string pageSize_;
std::string pageNumber_;
std::vector<MetaItem> items_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDB_MODEL_DESCRIBEMETALISTRESULT_H_

81
polardb/include/alibabacloud/polardb/model/DescribeTasksRequest.h Normal file
View File

@@ -0,0 +1,81 @@
/*
* 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_POLARDB_MODEL_DESCRIBETASKSREQUEST_H_
#define ALIBABACLOUD_POLARDB_MODEL_DESCRIBETASKSREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardb/PolardbExport.h>
namespace AlibabaCloud
{
namespace Polardb
{
namespace Model
{
class ALIBABACLOUD_POLARDB_EXPORT DescribeTasksRequest : public RpcServiceRequest
{
public:
DescribeTasksRequest();
~DescribeTasksRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getDBNodeId()const;
void setDBNodeId(const std::string& dBNodeId);
std::string getStartTime()const;
void setStartTime(const std::string& startTime);
int getPageNumber()const;
void setPageNumber(int pageNumber);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
int getPageSize()const;
void setPageSize(int pageSize);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getDBClusterId()const;
void setDBClusterId(const std::string& dBClusterId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
std::string getEndTime()const;
void setEndTime(const std::string& endTime);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getStatus()const;
void setStatus(const std::string& status);
private:
long resourceOwnerId_;
std::string dBNodeId_;
std::string startTime_;
int pageNumber_;
std::string accessKeyId_;
int pageSize_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
std::string endTime_;
long ownerId_;
std::string status_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDB_MODEL_DESCRIBETASKSREQUEST_H_

82
polardb/include/alibabacloud/polardb/model/DescribeTasksResult.h Normal file
View File

@@ -0,0 +1,82 @@
/*
* 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_POLARDB_MODEL_DESCRIBETASKSRESULT_H_
#define ALIBABACLOUD_POLARDB_MODEL_DESCRIBETASKSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/polardb/PolardbExport.h>
namespace AlibabaCloud
{
namespace Polardb
{
namespace Model
{
class ALIBABACLOUD_POLARDB_EXPORT DescribeTasksResult : public ServiceResult
{
public:
struct Task
{
std::string expectedFinishTime;
int progress;
std::string taskId;
int remain;
std::string taskAction;
std::string beginTime;
std::string taskErrorMessage;
std::string stepProgressInfo;
std::string finishTime;
std::string stepsInfo;
std::string currentStepName;
std::string progressInfo;
std::string dBName;
std::string taskErrorCode;
};
DescribeTasksResult();
explicit DescribeTasksResult(const std::string &payload);
~DescribeTasksResult();
int getTotalRecordCount()const;
std::vector<Task> getTasks()const;
int getPageRecordCount()const;
std::string getEndTime()const;
int getPageNumber()const;
std::string getDBInstanceId()const;
std::string getStartTime()const;
std::string getDBInstanceName()const;
protected:
void parse(const std::string &payload);
private:
int totalRecordCount_;
std::vector<Task> tasks_;
int pageRecordCount_;
std::string endTime_;
int pageNumber_;
std::string dBInstanceId_;
std::string startTime_;
std::string dBInstanceName_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDB_MODEL_DESCRIBETASKSRESULT_H_

75
polardb/include/alibabacloud/polardb/model/RestoreTableRequest.h Normal file
View File

@@ -0,0 +1,75 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDB_MODEL_RESTORETABLEREQUEST_H_
#define ALIBABACLOUD_POLARDB_MODEL_RESTORETABLEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/polardb/PolardbExport.h>
namespace AlibabaCloud
{
namespace Polardb
{
namespace Model
{
class ALIBABACLOUD_POLARDB_EXPORT RestoreTableRequest : public RpcServiceRequest
{
public:
RestoreTableRequest();
~RestoreTableRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getTableMeta()const;
void setTableMeta(const std::string& tableMeta);
std::string getRestoreTime()const;
void setRestoreTime(const std::string& restoreTime);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getDBClusterId()const;
void setDBClusterId(const std::string& dBClusterId);
std::string getOwnerAccount()const;
void setOwnerAccount(const std::string& ownerAccount);
std::string getBackupId()const;
void setBackupId(const std::string& backupId);
long getOwnerId()const;
void setOwnerId(long ownerId);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string securityToken_;
std::string tableMeta_;
std::string restoreTime_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
std::string backupId_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDB_MODEL_RESTORETABLEREQUEST_H_

49
polardb/include/alibabacloud/polardb/model/RestoreTableResult.h Normal file
View File

@@ -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_POLARDB_MODEL_RESTORETABLERESULT_H_
#define ALIBABACLOUD_POLARDB_MODEL_RESTORETABLERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/polardb/PolardbExport.h>
namespace AlibabaCloud
{
namespace Polardb
{
namespace Model
{
class ALIBABACLOUD_POLARDB_EXPORT RestoreTableResult : public ServiceResult
{
public:
RestoreTableResult();
explicit RestoreTableResult(const std::string &payload);
~RestoreTableResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_POLARDB_MODEL_RESTORETABLERESULT_H_

252
polardb/src/PolardbClient.cc
View File

@@ -267,6 +267,42 @@ PolardbClient::CreateDBEndpointAddressOutcomeCallable PolardbClient::createDBEnd
return task->get_future();
}
PolardbClient::CreateDBLinkOutcome PolardbClient::createDBLink(const CreateDBLinkRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CreateDBLinkOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CreateDBLinkOutcome(CreateDBLinkResult(outcome.result()));
else
return CreateDBLinkOutcome(outcome.error());
}
void PolardbClient::createDBLinkAsync(const CreateDBLinkRequest& request, const CreateDBLinkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, createDBLink(request), context);
};
asyncExecute(new Runnable(fn));
}
PolardbClient::CreateDBLinkOutcomeCallable PolardbClient::createDBLinkCallable(const CreateDBLinkRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CreateDBLinkOutcome()>>(
[this, request]()
{
return this->createDBLink(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
PolardbClient::CreateDBNodesOutcome PolardbClient::createDBNodes(const CreateDBNodesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -519,6 +555,42 @@ PolardbClient::DeleteDBEndpointAddressOutcomeCallable PolardbClient::deleteDBEnd
return task->get_future();
}
PolardbClient::DeleteDBLinkOutcome PolardbClient::deleteDBLink(const DeleteDBLinkRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DeleteDBLinkOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DeleteDBLinkOutcome(DeleteDBLinkResult(outcome.result()));
else
return DeleteDBLinkOutcome(outcome.error());
}
void PolardbClient::deleteDBLinkAsync(const DeleteDBLinkRequest& request, const DeleteDBLinkAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, deleteDBLink(request), context);
};
asyncExecute(new Runnable(fn));
}
PolardbClient::DeleteDBLinkOutcomeCallable PolardbClient::deleteDBLinkCallable(const DeleteDBLinkRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DeleteDBLinkOutcome()>>(
[this, request]()
{
return this->deleteDBLink(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
PolardbClient::DeleteDBNodesOutcome PolardbClient::deleteDBNodes(const DeleteDBNodesRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1311,6 +1383,42 @@ PolardbClient::DescribeDBClustersWithBackupsOutcomeCallable PolardbClient::descr
return task->get_future();
}
PolardbClient::DescribeDBLinksOutcome PolardbClient::describeDBLinks(const DescribeDBLinksRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeDBLinksOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeDBLinksOutcome(DescribeDBLinksResult(outcome.result()));
else
return DescribeDBLinksOutcome(outcome.error());
}
void PolardbClient::describeDBLinksAsync(const DescribeDBLinksRequest& request, const DescribeDBLinksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeDBLinks(request), context);
};
asyncExecute(new Runnable(fn));
}
PolardbClient::DescribeDBLinksOutcomeCallable PolardbClient::describeDBLinksCallable(const DescribeDBLinksRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeDBLinksOutcome()>>(
[this, request]()
{
return this->describeDBLinks(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
PolardbClient::DescribeDBNodePerformanceOutcome PolardbClient::describeDBNodePerformance(const DescribeDBNodePerformanceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1455,6 +1563,42 @@ PolardbClient::DescribeGlobalDatabaseNetworksOutcomeCallable PolardbClient::desc
return task->get_future();
}
PolardbClient::DescribeLocalAvailableRecoveryTimeOutcome PolardbClient::describeLocalAvailableRecoveryTime(const DescribeLocalAvailableRecoveryTimeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeLocalAvailableRecoveryTimeOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeLocalAvailableRecoveryTimeOutcome(DescribeLocalAvailableRecoveryTimeResult(outcome.result()));
else
return DescribeLocalAvailableRecoveryTimeOutcome(outcome.error());
}
void PolardbClient::describeLocalAvailableRecoveryTimeAsync(const DescribeLocalAvailableRecoveryTimeRequest& request, const DescribeLocalAvailableRecoveryTimeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeLocalAvailableRecoveryTime(request), context);
};
asyncExecute(new Runnable(fn));
}
PolardbClient::DescribeLocalAvailableRecoveryTimeOutcomeCallable PolardbClient::describeLocalAvailableRecoveryTimeCallable(const DescribeLocalAvailableRecoveryTimeRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeLocalAvailableRecoveryTimeOutcome()>>(
[this, request]()
{
return this->describeLocalAvailableRecoveryTime(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
PolardbClient::DescribeLogBackupPolicyOutcome PolardbClient::describeLogBackupPolicy(const DescribeLogBackupPolicyRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1491,6 +1635,42 @@ PolardbClient::DescribeLogBackupPolicyOutcomeCallable PolardbClient::describeLog
return task->get_future();
}
PolardbClient::DescribeMetaListOutcome PolardbClient::describeMetaList(const DescribeMetaListRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeMetaListOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeMetaListOutcome(DescribeMetaListResult(outcome.result()));
else
return DescribeMetaListOutcome(outcome.error());
}
void PolardbClient::describeMetaListAsync(const DescribeMetaListRequest& request, const DescribeMetaListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeMetaList(request), context);
};
asyncExecute(new Runnable(fn));
}
PolardbClient::DescribeMetaListOutcomeCallable PolardbClient::describeMetaListCallable(const DescribeMetaListRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeMetaListOutcome()>>(
[this, request]()
{
return this->describeMetaList(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
PolardbClient::DescribePendingMaintenanceActionOutcome PolardbClient::describePendingMaintenanceAction(const DescribePendingMaintenanceActionRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1671,6 +1851,42 @@ PolardbClient::DescribeSlowLogsOutcomeCallable PolardbClient::describeSlowLogsCa
return task->get_future();
}
PolardbClient::DescribeTasksOutcome PolardbClient::describeTasks(const DescribeTasksRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeTasksOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeTasksOutcome(DescribeTasksResult(outcome.result()));
else
return DescribeTasksOutcome(outcome.error());
}
void PolardbClient::describeTasksAsync(const DescribeTasksRequest& request, const DescribeTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeTasks(request), context);
};
asyncExecute(new Runnable(fn));
}
PolardbClient::DescribeTasksOutcomeCallable PolardbClient::describeTasksCallable(const DescribeTasksRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeTasksOutcome()>>(
[this, request]()
{
return this->describeTasks(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
PolardbClient::FailoverDBClusterOutcome PolardbClient::failoverDBCluster(const FailoverDBClusterRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2571,6 +2787,42 @@ PolardbClient::RestartDBNodeOutcomeCallable PolardbClient::restartDBNodeCallable
return task->get_future();
}
PolardbClient::RestoreTableOutcome PolardbClient::restoreTable(const RestoreTableRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RestoreTableOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RestoreTableOutcome(RestoreTableResult(outcome.result()));
else
return RestoreTableOutcome(outcome.error());
}
void PolardbClient::restoreTableAsync(const RestoreTableRequest& request, const RestoreTableAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, restoreTable(request), context);
};
asyncExecute(new Runnable(fn));
}
PolardbClient::RestoreTableOutcomeCallable PolardbClient::restoreTableCallable(const RestoreTableRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RestoreTableOutcome()>>(
[this, request]()
{
return this->restoreTable(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
PolardbClient::RevokeAccountPrivilegeOutcome PolardbClient::revokeAccountPrivilege(const RevokeAccountPrivilegeRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

161
polardb/src/model/CreateDBLinkRequest.cc Normal file
View File

@@ -0,0 +1,161 @@
/*
* 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/polardb/model/CreateDBLinkRequest.h>
using AlibabaCloud::Polardb::Model::CreateDBLinkRequest;
CreateDBLinkRequest::CreateDBLinkRequest() :
RpcServiceRequest("polardb", "2017-08-01", "CreateDBLink")
{
setMethod(HttpRequest::Method::Post);
}
CreateDBLinkRequest::~CreateDBLinkRequest()
{}
long CreateDBLinkRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void CreateDBLinkRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CreateDBLinkRequest::getSourceDBName()const
{
return sourceDBName_;
}
void CreateDBLinkRequest::setSourceDBName(const std::string& sourceDBName)
{
sourceDBName_ = sourceDBName;
setParameter("SourceDBName", sourceDBName);
}
std::string CreateDBLinkRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void CreateDBLinkRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string CreateDBLinkRequest::getTargetDBName()const
{
return targetDBName_;
}
void CreateDBLinkRequest::setTargetDBName(const std::string& targetDBName)
{
targetDBName_ = targetDBName;
setParameter("TargetDBName", targetDBName);
}
std::string CreateDBLinkRequest::getDBLinkName()const
{
return dBLinkName_;
}
void CreateDBLinkRequest::setDBLinkName(const std::string& dBLinkName)
{
dBLinkName_ = dBLinkName;
setParameter("DBLinkName", dBLinkName);
}
std::string CreateDBLinkRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void CreateDBLinkRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string CreateDBLinkRequest::getTargetDBInstanceName()const
{
return targetDBInstanceName_;
}
void CreateDBLinkRequest::setTargetDBInstanceName(const std::string& targetDBInstanceName)
{
targetDBInstanceName_ = targetDBInstanceName;
setParameter("TargetDBInstanceName", targetDBInstanceName);
}
std::string CreateDBLinkRequest::getDBClusterId()const
{
return dBClusterId_;
}
void CreateDBLinkRequest::setDBClusterId(const std::string& dBClusterId)
{
dBClusterId_ = dBClusterId;
setParameter("DBClusterId", dBClusterId);
}
std::string CreateDBLinkRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void CreateDBLinkRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string CreateDBLinkRequest::getTargetDBPasswd()const
{
return targetDBPasswd_;
}
void CreateDBLinkRequest::setTargetDBPasswd(const std::string& targetDBPasswd)
{
targetDBPasswd_ = targetDBPasswd;
setParameter("TargetDBPasswd", targetDBPasswd);
}
long CreateDBLinkRequest::getOwnerId()const
{
return ownerId_;
}
void CreateDBLinkRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateDBLinkRequest::getTargetDBAccount()const
{
return targetDBAccount_;
}
void CreateDBLinkRequest::setTargetDBAccount(const std::string& targetDBAccount)
{
targetDBAccount_ = targetDBAccount;
setParameter("TargetDBAccount", targetDBAccount);
}

44
polardb/src/model/CreateDBLinkResult.cc Normal file
View File

@@ -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/polardb/model/CreateDBLinkResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Polardb;
using namespace AlibabaCloud::Polardb::Model;
CreateDBLinkResult::CreateDBLinkResult() :
ServiceResult()
{}
CreateDBLinkResult::CreateDBLinkResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
CreateDBLinkResult::~CreateDBLinkResult()
{}
void CreateDBLinkResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

106
polardb/src/model/DeleteDBLinkRequest.cc Normal file
View File

@@ -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/polardb/model/DeleteDBLinkRequest.h>
using AlibabaCloud::Polardb::Model::DeleteDBLinkRequest;
DeleteDBLinkRequest::DeleteDBLinkRequest() :
RpcServiceRequest("polardb", "2017-08-01", "DeleteDBLink")
{
setMethod(HttpRequest::Method::Post);
}
DeleteDBLinkRequest::~DeleteDBLinkRequest()
{}
long DeleteDBLinkRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DeleteDBLinkRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DeleteDBLinkRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DeleteDBLinkRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DeleteDBLinkRequest::getDBLinkName()const
{
return dBLinkName_;
}
void DeleteDBLinkRequest::setDBLinkName(const std::string& dBLinkName)
{
dBLinkName_ = dBLinkName;
setParameter("DBLinkName", dBLinkName);
}
std::string DeleteDBLinkRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DeleteDBLinkRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DeleteDBLinkRequest::getDBClusterId()const
{
return dBClusterId_;
}
void DeleteDBLinkRequest::setDBClusterId(const std::string& dBClusterId)
{
dBClusterId_ = dBClusterId;
setParameter("DBClusterId", dBClusterId);
}
std::string DeleteDBLinkRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DeleteDBLinkRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long DeleteDBLinkRequest::getOwnerId()const
{
return ownerId_;
}
void DeleteDBLinkRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}

44
polardb/src/model/DeleteDBLinkResult.cc Normal file
View File

@@ -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/polardb/model/DeleteDBLinkResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Polardb;
using namespace AlibabaCloud::Polardb::Model;
DeleteDBLinkResult::DeleteDBLinkResult() :
ServiceResult()
{}
DeleteDBLinkResult::DeleteDBLinkResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DeleteDBLinkResult::~DeleteDBLinkResult()
{}
void DeleteDBLinkResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}

14
polardb/src/model/DescribeDBClusterVersionResult.cc
View File

@@ -39,8 +39,8 @@ void DescribeDBClusterVersionResult::parse(const std::string &payload)
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["DBInstanceName"].isNull())
dBInstanceName_ = value["DBInstanceName"].asString();
if(!value["DBClusterId"].isNull())
dBClusterId_ = value["DBClusterId"].asString();
if(!value["DBVersion"].isNull())
dBVersion_ = value["DBVersion"].asString();
if(!value["DBMinorVersion"].isNull())
@@ -81,13 +81,13 @@ std::string DescribeDBClusterVersionResult::getDBVersionStatus()const
return dBVersionStatus_;
}
std::string DescribeDBClusterVersionResult::getDBClusterId()const
{
return dBClusterId_;
}
std::string DescribeDBClusterVersionResult::getDBMinorVersion()const
{
return dBMinorVersion_;
}
std::string DescribeDBClusterVersionResult::getDBInstanceName()const
{
return dBInstanceName_;
}

106
polardb/src/model/DescribeDBLinksRequest.cc Normal file
View File

@@ -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/polardb/model/DescribeDBLinksRequest.h>
using AlibabaCloud::Polardb::Model::DescribeDBLinksRequest;
DescribeDBLinksRequest::DescribeDBLinksRequest() :
RpcServiceRequest("polardb", "2017-08-01", "DescribeDBLinks")
{
setMethod(HttpRequest::Method::Post);
}
DescribeDBLinksRequest::~DescribeDBLinksRequest()
{}
long DescribeDBLinksRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeDBLinksRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeDBLinksRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeDBLinksRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DescribeDBLinksRequest::getDBLinkName()const
{
return dBLinkName_;
}
void DescribeDBLinksRequest::setDBLinkName(const std::string& dBLinkName)
{
dBLinkName_ = dBLinkName;
setParameter("DBLinkName", dBLinkName);
}
std::string DescribeDBLinksRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeDBLinksRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeDBLinksRequest::getDBClusterId()const
{
return dBClusterId_;
}
void DescribeDBLinksRequest::setDBClusterId(const std::string& dBClusterId)
{
dBClusterId_ = dBClusterId;
setParameter("DBClusterId", dBClusterId);
}
std::string DescribeDBLinksRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeDBLinksRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long DescribeDBLinksRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeDBLinksRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}

74
polardb/src/model/DescribeDBLinksResult.cc Normal file
View File

@@ -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.
*/
#include <alibabacloud/polardb/model/DescribeDBLinksResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Polardb;
using namespace AlibabaCloud::Polardb::Model;
DescribeDBLinksResult::DescribeDBLinksResult() :
ServiceResult()
{}
DescribeDBLinksResult::DescribeDBLinksResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeDBLinksResult::~DescribeDBLinksResult()
{}
void DescribeDBLinksResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allDBLinkInfosNode = value["DBLinkInfos"]["DBLinkInfosItem"];
for (auto valueDBLinkInfosDBLinkInfosItem : allDBLinkInfosNode)
{
DBLinkInfosItem dBLinkInfosObject;
if(!valueDBLinkInfosDBLinkInfosItem["TargetDBInstanceName"].isNull())
dBLinkInfosObject.targetDBInstanceName = valueDBLinkInfosDBLinkInfosItem["TargetDBInstanceName"].asString();
if(!valueDBLinkInfosDBLinkInfosItem["DBInstanceName"].isNull())
dBLinkInfosObject.dBInstanceName = valueDBLinkInfosDBLinkInfosItem["DBInstanceName"].asString();
if(!valueDBLinkInfosDBLinkInfosItem["TargetDBName"].isNull())
dBLinkInfosObject.targetDBName = valueDBLinkInfosDBLinkInfosItem["TargetDBName"].asString();
if(!valueDBLinkInfosDBLinkInfosItem["TargetAccount"].isNull())
dBLinkInfosObject.targetAccount = valueDBLinkInfosDBLinkInfosItem["TargetAccount"].asString();
if(!valueDBLinkInfosDBLinkInfosItem["DBLinkName"].isNull())
dBLinkInfosObject.dBLinkName = valueDBLinkInfosDBLinkInfosItem["DBLinkName"].asString();
if(!valueDBLinkInfosDBLinkInfosItem["SourceDBName"].isNull())
dBLinkInfosObject.sourceDBName = valueDBLinkInfosDBLinkInfosItem["SourceDBName"].asString();
dBLinkInfos_.push_back(dBLinkInfosObject);
}
if(!value["DBInstanceName"].isNull())
dBInstanceName_ = value["DBInstanceName"].asString();
}
std::vector<DescribeDBLinksResult::DBLinkInfosItem> DescribeDBLinksResult::getDBLinkInfos()const
{
return dBLinkInfos_;
}
std::string DescribeDBLinksResult::getDBInstanceName()const
{
return dBInstanceName_;
}

106
polardb/src/model/DescribeLocalAvailableRecoveryTimeRequest.cc Normal file
View File

@@ -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/polardb/model/DescribeLocalAvailableRecoveryTimeRequest.h>
using AlibabaCloud::Polardb::Model::DescribeLocalAvailableRecoveryTimeRequest;
DescribeLocalAvailableRecoveryTimeRequest::DescribeLocalAvailableRecoveryTimeRequest() :
RpcServiceRequest("polardb", "2017-08-01", "DescribeLocalAvailableRecoveryTime")
{
setMethod(HttpRequest::Method::Post);
}
DescribeLocalAvailableRecoveryTimeRequest::~DescribeLocalAvailableRecoveryTimeRequest()
{}
long DescribeLocalAvailableRecoveryTimeRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeLocalAvailableRecoveryTimeRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeLocalAvailableRecoveryTimeRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeLocalAvailableRecoveryTimeRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DescribeLocalAvailableRecoveryTimeRequest::getSecurityToken()const
{
return securityToken_;
}
void DescribeLocalAvailableRecoveryTimeRequest::setSecurityToken(const std::string& securityToken)
{
securityToken_ = securityToken;
setParameter("SecurityToken", securityToken);
}
std::string DescribeLocalAvailableRecoveryTimeRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeLocalAvailableRecoveryTimeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeLocalAvailableRecoveryTimeRequest::getDBClusterId()const
{
return dBClusterId_;
}
void DescribeLocalAvailableRecoveryTimeRequest::setDBClusterId(const std::string& dBClusterId)
{
dBClusterId_ = dBClusterId;
setParameter("DBClusterId", dBClusterId);
}
std::string DescribeLocalAvailableRecoveryTimeRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeLocalAvailableRecoveryTimeRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long DescribeLocalAvailableRecoveryTimeRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeLocalAvailableRecoveryTimeRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}

65
polardb/src/model/DescribeLocalAvailableRecoveryTimeResult.cc Normal file
View File

@@ -0,0 +1,65 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/polardb/model/DescribeLocalAvailableRecoveryTimeResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Polardb;
using namespace AlibabaCloud::Polardb::Model;
DescribeLocalAvailableRecoveryTimeResult::DescribeLocalAvailableRecoveryTimeResult() :
ServiceResult()
{}
DescribeLocalAvailableRecoveryTimeResult::DescribeLocalAvailableRecoveryTimeResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeLocalAvailableRecoveryTimeResult::~DescribeLocalAvailableRecoveryTimeResult()
{}
void DescribeLocalAvailableRecoveryTimeResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
if(!value["RecoveryEndTime"].isNull())
recoveryEndTime_ = value["RecoveryEndTime"].asString();
if(!value["RecoveryBeginTime"].isNull())
recoveryBeginTime_ = value["RecoveryBeginTime"].asString();
if(!value["DBClusterId"].isNull())
dBClusterId_ = value["DBClusterId"].asString();
}
std::string DescribeLocalAvailableRecoveryTimeResult::getRecoveryEndTime()const
{
return recoveryEndTime_;
}
std::string DescribeLocalAvailableRecoveryTimeResult::getRecoveryBeginTime()const
{
return recoveryBeginTime_;
}
std::string DescribeLocalAvailableRecoveryTimeResult::getDBClusterId()const
{
return dBClusterId_;
}

161
polardb/src/model/DescribeMetaListRequest.cc Normal file
View File

@@ -0,0 +1,161 @@
/*
* 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/polardb/model/DescribeMetaListRequest.h>
using AlibabaCloud::Polardb::Model::DescribeMetaListRequest;
DescribeMetaListRequest::DescribeMetaListRequest() :
RpcServiceRequest("polardb", "2017-08-01", "DescribeMetaList")
{
setMethod(HttpRequest::Method::Post);
}
DescribeMetaListRequest::~DescribeMetaListRequest()
{}
long DescribeMetaListRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeMetaListRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
int DescribeMetaListRequest::getPageNumber()const
{
return pageNumber_;
}
void DescribeMetaListRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setParameter("PageNumber", std::to_string(pageNumber));
}
std::string DescribeMetaListRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeMetaListRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DescribeMetaListRequest::getSecurityToken()const
{
return securityToken_;
}
void DescribeMetaListRequest::setSecurityToken(const std::string& securityToken)
{
securityToken_ = securityToken;
setParameter("SecurityToken", securityToken);
}
int DescribeMetaListRequest::getPageSize()const
{
return pageSize_;
}
void DescribeMetaListRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setParameter("PageSize", std::to_string(pageSize));
}
std::string DescribeMetaListRequest::getRestoreTime()const
{
return restoreTime_;
}
void DescribeMetaListRequest::setRestoreTime(const std::string& restoreTime)
{
restoreTime_ = restoreTime;
setParameter("RestoreTime", restoreTime);
}
std::string DescribeMetaListRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeMetaListRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeMetaListRequest::getDBClusterId()const
{
return dBClusterId_;
}
void DescribeMetaListRequest::setDBClusterId(const std::string& dBClusterId)
{
dBClusterId_ = dBClusterId;
setParameter("DBClusterId", dBClusterId);
}
std::string DescribeMetaListRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeMetaListRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DescribeMetaListRequest::getBackupId()const
{
return backupId_;
}
void DescribeMetaListRequest::setBackupId(const std::string& backupId)
{
backupId_ = backupId;
setParameter("BackupId", backupId);
}
long DescribeMetaListRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeMetaListRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeMetaListRequest::getGetDbName()const
{
return getDbName_;
}
void DescribeMetaListRequest::setGetDbName(const std::string& getDbName)
{
getDbName_ = getDbName;
setParameter("GetDbName", getDbName);
}

88
polardb/src/model/DescribeMetaListResult.cc Normal file
View File

@@ -0,0 +1,88 @@
/*
* 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/polardb/model/DescribeMetaListResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Polardb;
using namespace AlibabaCloud::Polardb::Model;
DescribeMetaListResult::DescribeMetaListResult() :
ServiceResult()
{}
DescribeMetaListResult::DescribeMetaListResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeMetaListResult::~DescribeMetaListResult()
{}
void DescribeMetaListResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allItemsNode = value["Items"]["MetaItem"];
for (auto valueItemsMetaItem : allItemsNode)
{
MetaItem itemsObject;
if(!valueItemsMetaItem["Database"].isNull())
itemsObject.database = valueItemsMetaItem["Database"].asString();
auto allTables = value["Tables"]["Table"];
for (auto value : allTables)
itemsObject.tables.push_back(value.asString());
items_.push_back(itemsObject);
}
if(!value["TotalRecordCount"].isNull())
totalRecordCount_ = value["TotalRecordCount"].asString();
if(!value["TotalPageCount"].isNull())
totalPageCount_ = value["TotalPageCount"].asString();
if(!value["PageSize"].isNull())
pageSize_ = value["PageSize"].asString();
if(!value["PageNumber"].isNull())
pageNumber_ = value["PageNumber"].asString();
}
std::string DescribeMetaListResult::getTotalRecordCount()const
{
return totalRecordCount_;
}
std::string DescribeMetaListResult::getTotalPageCount()const
{
return totalPageCount_;
}
std::string DescribeMetaListResult::getPageSize()const
{
return pageSize_;
}
std::string DescribeMetaListResult::getPageNumber()const
{
return pageNumber_;
}
std::vector<DescribeMetaListResult::MetaItem> DescribeMetaListResult::getItems()const
{
return items_;
}

161
polardb/src/model/DescribeTasksRequest.cc Normal file
View File

@@ -0,0 +1,161 @@
/*
* 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/polardb/model/DescribeTasksRequest.h>
using AlibabaCloud::Polardb::Model::DescribeTasksRequest;
DescribeTasksRequest::DescribeTasksRequest() :
RpcServiceRequest("polardb", "2017-08-01", "DescribeTasks")
{
setMethod(HttpRequest::Method::Post);
}
DescribeTasksRequest::~DescribeTasksRequest()
{}
long DescribeTasksRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeTasksRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeTasksRequest::getDBNodeId()const
{
return dBNodeId_;
}
void DescribeTasksRequest::setDBNodeId(const std::string& dBNodeId)
{
dBNodeId_ = dBNodeId;
setParameter("DBNodeId", dBNodeId);
}
std::string DescribeTasksRequest::getStartTime()const
{
return startTime_;
}
void DescribeTasksRequest::setStartTime(const std::string& startTime)
{
startTime_ = startTime;
setParameter("StartTime", startTime);
}
int DescribeTasksRequest::getPageNumber()const
{
return pageNumber_;
}
void DescribeTasksRequest::setPageNumber(int pageNumber)
{
pageNumber_ = pageNumber;
setParameter("PageNumber", std::to_string(pageNumber));
}
std::string DescribeTasksRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeTasksRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
int DescribeTasksRequest::getPageSize()const
{
return pageSize_;
}
void DescribeTasksRequest::setPageSize(int pageSize)
{
pageSize_ = pageSize;
setParameter("PageSize", std::to_string(pageSize));
}
std::string DescribeTasksRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeTasksRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeTasksRequest::getDBClusterId()const
{
return dBClusterId_;
}
void DescribeTasksRequest::setDBClusterId(const std::string& dBClusterId)
{
dBClusterId_ = dBClusterId;
setParameter("DBClusterId", dBClusterId);
}
std::string DescribeTasksRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeTasksRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string DescribeTasksRequest::getEndTime()const
{
return endTime_;
}
void DescribeTasksRequest::setEndTime(const std::string& endTime)
{
endTime_ = endTime;
setParameter("EndTime", endTime);
}
long DescribeTasksRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeTasksRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeTasksRequest::getStatus()const
{
return status_;
}
void DescribeTasksRequest::setStatus(const std::string& status)
{
status_ = status;
setParameter("Status", status);
}

132
polardb/src/model/DescribeTasksResult.cc Normal file
View File

@@ -0,0 +1,132 @@
/*
* 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/polardb/model/DescribeTasksResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Polardb;
using namespace AlibabaCloud::Polardb::Model;
DescribeTasksResult::DescribeTasksResult() :
ServiceResult()
{}
DescribeTasksResult::DescribeTasksResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeTasksResult::~DescribeTasksResult()
{}
void DescribeTasksResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allTasksNode = value["Tasks"]["Task"];
for (auto valueTasksTask : allTasksNode)
{
Task tasksObject;
if(!valueTasksTask["TaskId"].isNull())
tasksObject.taskId = valueTasksTask["TaskId"].asString();
if(!valueTasksTask["BeginTime"].isNull())
tasksObject.beginTime = valueTasksTask["BeginTime"].asString();
if(!valueTasksTask["FinishTime"].isNull())
tasksObject.finishTime = valueTasksTask["FinishTime"].asString();
if(!valueTasksTask["ExpectedFinishTime"].isNull())
tasksObject.expectedFinishTime = valueTasksTask["ExpectedFinishTime"].asString();
if(!valueTasksTask["TaskAction"].isNull())
tasksObject.taskAction = valueTasksTask["TaskAction"].asString();
if(!valueTasksTask["Progress"].isNull())
tasksObject.progress = std::stoi(valueTasksTask["Progress"].asString());
if(!valueTasksTask["DBName"].isNull())
tasksObject.dBName = valueTasksTask["DBName"].asString();
if(!valueTasksTask["ProgressInfo"].isNull())
tasksObject.progressInfo = valueTasksTask["ProgressInfo"].asString();
if(!valueTasksTask["TaskErrorCode"].isNull())
tasksObject.taskErrorCode = valueTasksTask["TaskErrorCode"].asString();
if(!valueTasksTask["TaskErrorMessage"].isNull())
tasksObject.taskErrorMessage = valueTasksTask["TaskErrorMessage"].asString();
if(!valueTasksTask["StepsInfo"].isNull())
tasksObject.stepsInfo = valueTasksTask["StepsInfo"].asString();
if(!valueTasksTask["Remain"].isNull())
tasksObject.remain = std::stoi(valueTasksTask["Remain"].asString());
if(!valueTasksTask["StepProgressInfo"].isNull())
tasksObject.stepProgressInfo = valueTasksTask["StepProgressInfo"].asString();
if(!valueTasksTask["CurrentStepName"].isNull())
tasksObject.currentStepName = valueTasksTask["CurrentStepName"].asString();
tasks_.push_back(tasksObject);
}
if(!value["StartTime"].isNull())
startTime_ = value["StartTime"].asString();
if(!value["EndTime"].isNull())
endTime_ = value["EndTime"].asString();
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["DBInstanceName"].isNull())
dBInstanceName_ = value["DBInstanceName"].asString();
if(!value["DBInstanceId"].isNull())
dBInstanceId_ = value["DBInstanceId"].asString();
}
int DescribeTasksResult::getTotalRecordCount()const
{
return totalRecordCount_;
}
std::vector<DescribeTasksResult::Task> DescribeTasksResult::getTasks()const
{
return tasks_;
}
int DescribeTasksResult::getPageRecordCount()const
{
return pageRecordCount_;
}
std::string DescribeTasksResult::getEndTime()const
{
return endTime_;
}
int DescribeTasksResult::getPageNumber()const
{
return pageNumber_;
}
std::string DescribeTasksResult::getDBInstanceId()const
{
return dBInstanceId_;
}
std::string DescribeTasksResult::getStartTime()const
{
return startTime_;
}
std::string DescribeTasksResult::getDBInstanceName()const
{
return dBInstanceName_;
}

139
polardb/src/model/RestoreTableRequest.cc Normal file
View File

@@ -0,0 +1,139 @@
/*
* 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/polardb/model/RestoreTableRequest.h>
using AlibabaCloud::Polardb::Model::RestoreTableRequest;
RestoreTableRequest::RestoreTableRequest() :
RpcServiceRequest("polardb", "2017-08-01", "RestoreTable")
{
setMethod(HttpRequest::Method::Post);
}
RestoreTableRequest::~RestoreTableRequest()
{}
long RestoreTableRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void RestoreTableRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string RestoreTableRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void RestoreTableRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string RestoreTableRequest::getSecurityToken()const
{
return securityToken_;
}
void RestoreTableRequest::setSecurityToken(const std::string& securityToken)
{
securityToken_ = securityToken;
setParameter("SecurityToken", securityToken);
}
std::string RestoreTableRequest::getTableMeta()const
{
return tableMeta_;
}
void RestoreTableRequest::setTableMeta(const std::string& tableMeta)
{
tableMeta_ = tableMeta;
setParameter("TableMeta", tableMeta);
}
std::string RestoreTableRequest::getRestoreTime()const
{
return restoreTime_;
}
void RestoreTableRequest::setRestoreTime(const std::string& restoreTime)
{
restoreTime_ = restoreTime;
setParameter("RestoreTime", restoreTime);
}
std::string RestoreTableRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void RestoreTableRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string RestoreTableRequest::getDBClusterId()const
{
return dBClusterId_;
}
void RestoreTableRequest::setDBClusterId(const std::string& dBClusterId)
{
dBClusterId_ = dBClusterId;
setParameter("DBClusterId", dBClusterId);
}
std::string RestoreTableRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void RestoreTableRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
std::string RestoreTableRequest::getBackupId()const
{
return backupId_;
}
void RestoreTableRequest::setBackupId(const std::string& backupId)
{
backupId_ = backupId;
setParameter("BackupId", backupId);
}
long RestoreTableRequest::getOwnerId()const
{
return ownerId_;
}
void RestoreTableRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}

44
polardb/src/model/RestoreTableResult.cc Normal file
View File

@@ -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/polardb/model/RestoreTableResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Polardb;
using namespace AlibabaCloud::Polardb::Model;
RestoreTableResult::RestoreTableResult() :
ServiceResult()
{}
RestoreTableResult::RestoreTableResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
RestoreTableResult::~RestoreTableResult()
{}
void RestoreTableResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
}