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

Support DescribeScheduleTasks.

Browse Source
This commit is contained in:
sdk-team
2021-01-11 02:54:26 +00:00
parent 405237dd06
commit 5bf58dc5b5
44 changed files with 2228 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
CHANGELOG
View File

@@ -1,3 +1,8 @@
2021-01-11 Version: patch
- Support DescribeScheduleTasks.
- Support CancelScheduleTasks.
- Upgrade UpgradeDBClusterMinorVersion.
2021-01-08 Version: patch
- Added batch drop list domain.

24
polardb/CMakeLists.txt
View File

@@ -21,6 +21,12 @@ set(polardb_public_header
include/alibabacloud/polardb/PolardbExport.h )
set(polardb_public_header_model
include/alibabacloud/polardb/model/CancelScheduleTasksRequest.h
include/alibabacloud/polardb/model/CancelScheduleTasksResult.h
include/alibabacloud/polardb/model/CheckAccountNameRequest.h
include/alibabacloud/polardb/model/CheckAccountNameResult.h
include/alibabacloud/polardb/model/CheckDBNameRequest.h
include/alibabacloud/polardb/model/CheckDBNameResult.h
include/alibabacloud/polardb/model/CloseDBClusterMigrationRequest.h
include/alibabacloud/polardb/model/CloseDBClusterMigrationResult.h
include/alibabacloud/polardb/model/CreateAccountRequest.h
@@ -67,6 +73,8 @@ set(polardb_public_header_model
include/alibabacloud/polardb/model/DescribeBackupTasksResult.h
include/alibabacloud/polardb/model/DescribeBackupsRequest.h
include/alibabacloud/polardb/model/DescribeBackupsResult.h
include/alibabacloud/polardb/model/DescribeCharacterSetNameRequest.h
include/alibabacloud/polardb/model/DescribeCharacterSetNameResult.h
include/alibabacloud/polardb/model/DescribeDBClusterAccessWhitelistRequest.h
include/alibabacloud/polardb/model/DescribeDBClusterAccessWhitelistResult.h
include/alibabacloud/polardb/model/DescribeDBClusterAttributeRequest.h
@@ -95,6 +103,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/DescribeDBInitializeVariableRequest.h
include/alibabacloud/polardb/model/DescribeDBInitializeVariableResult.h
include/alibabacloud/polardb/model/DescribeDBLinksRequest.h
include/alibabacloud/polardb/model/DescribeDBLinksResult.h
include/alibabacloud/polardb/model/DescribeDBNodePerformanceRequest.h
@@ -115,6 +125,8 @@ set(polardb_public_header_model
include/alibabacloud/polardb/model/DescribePendingMaintenanceActionsResult.h
include/alibabacloud/polardb/model/DescribeRegionsRequest.h
include/alibabacloud/polardb/model/DescribeRegionsResult.h
include/alibabacloud/polardb/model/DescribeScheduleTasksRequest.h
include/alibabacloud/polardb/model/DescribeScheduleTasksResult.h
include/alibabacloud/polardb/model/DescribeSlowLogRecordsRequest.h
include/alibabacloud/polardb/model/DescribeSlowLogRecordsResult.h
include/alibabacloud/polardb/model/DescribeTasksRequest.h
@@ -182,6 +194,12 @@ set(polardb_public_header_model
set(polardb_src
src/PolardbClient.cc
src/model/CancelScheduleTasksRequest.cc
src/model/CancelScheduleTasksResult.cc
src/model/CheckAccountNameRequest.cc
src/model/CheckAccountNameResult.cc
src/model/CheckDBNameRequest.cc
src/model/CheckDBNameResult.cc
src/model/CloseDBClusterMigrationRequest.cc
src/model/CloseDBClusterMigrationResult.cc
src/model/CreateAccountRequest.cc
@@ -228,6 +246,8 @@ set(polardb_src
src/model/DescribeBackupTasksResult.cc
src/model/DescribeBackupsRequest.cc
src/model/DescribeBackupsResult.cc
src/model/DescribeCharacterSetNameRequest.cc
src/model/DescribeCharacterSetNameResult.cc
src/model/DescribeDBClusterAccessWhitelistRequest.cc
src/model/DescribeDBClusterAccessWhitelistResult.cc
src/model/DescribeDBClusterAttributeRequest.cc
@@ -256,6 +276,8 @@ set(polardb_src
src/model/DescribeDBClustersResult.cc
src/model/DescribeDBClustersWithBackupsRequest.cc
src/model/DescribeDBClustersWithBackupsResult.cc
src/model/DescribeDBInitializeVariableRequest.cc
src/model/DescribeDBInitializeVariableResult.cc
src/model/DescribeDBLinksRequest.cc
src/model/DescribeDBLinksResult.cc
src/model/DescribeDBNodePerformanceRequest.cc
@@ -276,6 +298,8 @@ set(polardb_src
src/model/DescribePendingMaintenanceActionsResult.cc
src/model/DescribeRegionsRequest.cc
src/model/DescribeRegionsResult.cc
src/model/DescribeScheduleTasksRequest.cc
src/model/DescribeScheduleTasksResult.cc
src/model/DescribeSlowLogRecordsRequest.cc
src/model/DescribeSlowLogRecordsResult.cc
src/model/DescribeTasksRequest.cc

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

@@ -22,6 +22,12 @@
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "PolardbExport.h"
#include "model/CancelScheduleTasksRequest.h"
#include "model/CancelScheduleTasksResult.h"
#include "model/CheckAccountNameRequest.h"
#include "model/CheckAccountNameResult.h"
#include "model/CheckDBNameRequest.h"
#include "model/CheckDBNameResult.h"
#include "model/CloseDBClusterMigrationRequest.h"
#include "model/CloseDBClusterMigrationResult.h"
#include "model/CreateAccountRequest.h"
@@ -68,6 +74,8 @@
#include "model/DescribeBackupTasksResult.h"
#include "model/DescribeBackupsRequest.h"
#include "model/DescribeBackupsResult.h"
#include "model/DescribeCharacterSetNameRequest.h"
#include "model/DescribeCharacterSetNameResult.h"
#include "model/DescribeDBClusterAccessWhitelistRequest.h"
#include "model/DescribeDBClusterAccessWhitelistResult.h"
#include "model/DescribeDBClusterAttributeRequest.h"
@@ -96,6 +104,8 @@
#include "model/DescribeDBClustersResult.h"
#include "model/DescribeDBClustersWithBackupsRequest.h"
#include "model/DescribeDBClustersWithBackupsResult.h"
#include "model/DescribeDBInitializeVariableRequest.h"
#include "model/DescribeDBInitializeVariableResult.h"
#include "model/DescribeDBLinksRequest.h"
#include "model/DescribeDBLinksResult.h"
#include "model/DescribeDBNodePerformanceRequest.h"
@@ -116,6 +126,8 @@
#include "model/DescribePendingMaintenanceActionsResult.h"
#include "model/DescribeRegionsRequest.h"
#include "model/DescribeRegionsResult.h"
#include "model/DescribeScheduleTasksRequest.h"
#include "model/DescribeScheduleTasksResult.h"
#include "model/DescribeSlowLogRecordsRequest.h"
#include "model/DescribeSlowLogRecordsResult.h"
#include "model/DescribeTasksRequest.h"
@@ -189,6 +201,15 @@ namespace AlibabaCloud
class ALIBABACLOUD_POLARDB_EXPORT PolardbClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::CancelScheduleTasksResult> CancelScheduleTasksOutcome;
typedef std::future<CancelScheduleTasksOutcome> CancelScheduleTasksOutcomeCallable;
typedef std::function<void(const PolardbClient*, const Model::CancelScheduleTasksRequest&, const CancelScheduleTasksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CancelScheduleTasksAsyncHandler;
typedef Outcome<Error, Model::CheckAccountNameResult> CheckAccountNameOutcome;
typedef std::future<CheckAccountNameOutcome> CheckAccountNameOutcomeCallable;
typedef std::function<void(const PolardbClient*, const Model::CheckAccountNameRequest&, const CheckAccountNameOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckAccountNameAsyncHandler;
typedef Outcome<Error, Model::CheckDBNameResult> CheckDBNameOutcome;
typedef std::future<CheckDBNameOutcome> CheckDBNameOutcomeCallable;
typedef std::function<void(const PolardbClient*, const Model::CheckDBNameRequest&, const CheckDBNameOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CheckDBNameAsyncHandler;
typedef Outcome<Error, Model::CloseDBClusterMigrationResult> CloseDBClusterMigrationOutcome;
typedef std::future<CloseDBClusterMigrationOutcome> CloseDBClusterMigrationOutcomeCallable;
typedef std::function<void(const PolardbClient*, const Model::CloseDBClusterMigrationRequest&, const CloseDBClusterMigrationOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CloseDBClusterMigrationAsyncHandler;
@@ -258,6 +279,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DescribeBackupsResult> DescribeBackupsOutcome;
typedef std::future<DescribeBackupsOutcome> DescribeBackupsOutcomeCallable;
typedef std::function<void(const PolardbClient*, const Model::DescribeBackupsRequest&, const DescribeBackupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeBackupsAsyncHandler;
typedef Outcome<Error, Model::DescribeCharacterSetNameResult> DescribeCharacterSetNameOutcome;
typedef std::future<DescribeCharacterSetNameOutcome> DescribeCharacterSetNameOutcomeCallable;
typedef std::function<void(const PolardbClient*, const Model::DescribeCharacterSetNameRequest&, const DescribeCharacterSetNameOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeCharacterSetNameAsyncHandler;
typedef Outcome<Error, Model::DescribeDBClusterAccessWhitelistResult> DescribeDBClusterAccessWhitelistOutcome;
typedef std::future<DescribeDBClusterAccessWhitelistOutcome> DescribeDBClusterAccessWhitelistOutcomeCallable;
typedef std::function<void(const PolardbClient*, const Model::DescribeDBClusterAccessWhitelistRequest&, const DescribeDBClusterAccessWhitelistOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBClusterAccessWhitelistAsyncHandler;
@@ -300,6 +324,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::DescribeDBInitializeVariableResult> DescribeDBInitializeVariableOutcome;
typedef std::future<DescribeDBInitializeVariableOutcome> DescribeDBInitializeVariableOutcomeCallable;
typedef std::function<void(const PolardbClient*, const Model::DescribeDBInitializeVariableRequest&, const DescribeDBInitializeVariableOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBInitializeVariableAsyncHandler;
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;
@@ -330,6 +357,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DescribeRegionsResult> DescribeRegionsOutcome;
typedef std::future<DescribeRegionsOutcome> DescribeRegionsOutcomeCallable;
typedef std::function<void(const PolardbClient*, const Model::DescribeRegionsRequest&, const DescribeRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRegionsAsyncHandler;
typedef Outcome<Error, Model::DescribeScheduleTasksResult> DescribeScheduleTasksOutcome;
typedef std::future<DescribeScheduleTasksOutcome> DescribeScheduleTasksOutcomeCallable;
typedef std::function<void(const PolardbClient*, const Model::DescribeScheduleTasksRequest&, const DescribeScheduleTasksOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeScheduleTasksAsyncHandler;
typedef Outcome<Error, Model::DescribeSlowLogRecordsResult> DescribeSlowLogRecordsOutcome;
typedef std::future<DescribeSlowLogRecordsOutcome> DescribeSlowLogRecordsOutcomeCallable;
typedef std::function<void(const PolardbClient*, const Model::DescribeSlowLogRecordsRequest&, const DescribeSlowLogRecordsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSlowLogRecordsAsyncHandler;
@@ -431,6 +461,15 @@ namespace AlibabaCloud
PolardbClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
PolardbClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~PolardbClient();
CancelScheduleTasksOutcome cancelScheduleTasks(const Model::CancelScheduleTasksRequest &request)const;
void cancelScheduleTasksAsync(const Model::CancelScheduleTasksRequest& request, const CancelScheduleTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CancelScheduleTasksOutcomeCallable cancelScheduleTasksCallable(const Model::CancelScheduleTasksRequest& request) const;
CheckAccountNameOutcome checkAccountName(const Model::CheckAccountNameRequest &request)const;
void checkAccountNameAsync(const Model::CheckAccountNameRequest& request, const CheckAccountNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CheckAccountNameOutcomeCallable checkAccountNameCallable(const Model::CheckAccountNameRequest& request) const;
CheckDBNameOutcome checkDBName(const Model::CheckDBNameRequest &request)const;
void checkDBNameAsync(const Model::CheckDBNameRequest& request, const CheckDBNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CheckDBNameOutcomeCallable checkDBNameCallable(const Model::CheckDBNameRequest& request) const;
CloseDBClusterMigrationOutcome closeDBClusterMigration(const Model::CloseDBClusterMigrationRequest &request)const;
void closeDBClusterMigrationAsync(const Model::CloseDBClusterMigrationRequest& request, const CloseDBClusterMigrationAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
CloseDBClusterMigrationOutcomeCallable closeDBClusterMigrationCallable(const Model::CloseDBClusterMigrationRequest& request) const;
@@ -500,6 +539,9 @@ namespace AlibabaCloud
DescribeBackupsOutcome describeBackups(const Model::DescribeBackupsRequest &request)const;
void describeBackupsAsync(const Model::DescribeBackupsRequest& request, const DescribeBackupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeBackupsOutcomeCallable describeBackupsCallable(const Model::DescribeBackupsRequest& request) const;
DescribeCharacterSetNameOutcome describeCharacterSetName(const Model::DescribeCharacterSetNameRequest &request)const;
void describeCharacterSetNameAsync(const Model::DescribeCharacterSetNameRequest& request, const DescribeCharacterSetNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeCharacterSetNameOutcomeCallable describeCharacterSetNameCallable(const Model::DescribeCharacterSetNameRequest& request) const;
DescribeDBClusterAccessWhitelistOutcome describeDBClusterAccessWhitelist(const Model::DescribeDBClusterAccessWhitelistRequest &request)const;
void describeDBClusterAccessWhitelistAsync(const Model::DescribeDBClusterAccessWhitelistRequest& request, const DescribeDBClusterAccessWhitelistAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDBClusterAccessWhitelistOutcomeCallable describeDBClusterAccessWhitelistCallable(const Model::DescribeDBClusterAccessWhitelistRequest& request) const;
@@ -542,6 +584,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;
DescribeDBInitializeVariableOutcome describeDBInitializeVariable(const Model::DescribeDBInitializeVariableRequest &request)const;
void describeDBInitializeVariableAsync(const Model::DescribeDBInitializeVariableRequest& request, const DescribeDBInitializeVariableAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeDBInitializeVariableOutcomeCallable describeDBInitializeVariableCallable(const Model::DescribeDBInitializeVariableRequest& 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;
@@ -572,6 +617,9 @@ namespace AlibabaCloud
DescribeRegionsOutcome describeRegions(const Model::DescribeRegionsRequest &request)const;
void describeRegionsAsync(const Model::DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeRegionsOutcomeCallable describeRegionsCallable(const Model::DescribeRegionsRequest& request) const;
DescribeScheduleTasksOutcome describeScheduleTasks(const Model::DescribeScheduleTasksRequest &request)const;
void describeScheduleTasksAsync(const Model::DescribeScheduleTasksRequest& request, const DescribeScheduleTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeScheduleTasksOutcomeCallable describeScheduleTasksCallable(const Model::DescribeScheduleTasksRequest& request) const;
DescribeSlowLogRecordsOutcome describeSlowLogRecords(const Model::DescribeSlowLogRecordsRequest &request)const;
void describeSlowLogRecordsAsync(const Model::DescribeSlowLogRecordsRequest& request, const DescribeSlowLogRecordsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
DescribeSlowLogRecordsOutcomeCallable describeSlowLogRecordsCallable(const Model::DescribeSlowLogRecordsRequest& request) const;

66
polardb/include/alibabacloud/polardb/model/CancelScheduleTasksRequest.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_CANCELSCHEDULETASKSREQUEST_H_
#define ALIBABACLOUD_POLARDB_MODEL_CANCELSCHEDULETASKSREQUEST_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 CancelScheduleTasksRequest : public RpcServiceRequest
{
public:
CancelScheduleTasksRequest();
~CancelScheduleTasksRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTaskId()const;
void setTaskId(const std::string& taskId);
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 taskId_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDB_MODEL_CANCELSCHEDULETASKSREQUEST_H_

51
polardb/include/alibabacloud/polardb/model/CancelScheduleTasksResult.h Normal file
View File

@@ -0,0 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDB_MODEL_CANCELSCHEDULETASKSRESULT_H_
#define ALIBABACLOUD_POLARDB_MODEL_CANCELSCHEDULETASKSRESULT_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 CancelScheduleTasksResult : public ServiceResult
{
public:
CancelScheduleTasksResult();
explicit CancelScheduleTasksResult(const std::string &payload);
~CancelScheduleTasksResult();
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDB_MODEL_CANCELSCHEDULETASKSRESULT_H_

66
polardb/include/alibabacloud/polardb/model/CheckAccountNameRequest.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_CHECKACCOUNTNAMEREQUEST_H_
#define ALIBABACLOUD_POLARDB_MODEL_CHECKACCOUNTNAMEREQUEST_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 CheckAccountNameRequest : public RpcServiceRequest
{
public:
CheckAccountNameRequest();
~CheckAccountNameRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getAccountName()const;
void setAccountName(const std::string& accountName);
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 accountName_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDB_MODEL_CHECKACCOUNTNAMEREQUEST_H_

49
polardb/include/alibabacloud/polardb/model/CheckAccountNameResult.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_CHECKACCOUNTNAMERESULT_H_
#define ALIBABACLOUD_POLARDB_MODEL_CHECKACCOUNTNAMERESULT_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 CheckAccountNameResult : public ServiceResult
{
public:
CheckAccountNameResult();
explicit CheckAccountNameResult(const std::string &payload);
~CheckAccountNameResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_POLARDB_MODEL_CHECKACCOUNTNAMERESULT_H_

66
polardb/include/alibabacloud/polardb/model/CheckDBNameRequest.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_CHECKDBNAMEREQUEST_H_
#define ALIBABACLOUD_POLARDB_MODEL_CHECKDBNAMEREQUEST_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 CheckDBNameRequest : public RpcServiceRequest
{
public:
CheckDBNameRequest();
~CheckDBNameRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string 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);
std::string getDBName()const;
void setDBName(const std::string& dBName);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
std::string dBName_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDB_MODEL_CHECKDBNAMEREQUEST_H_

49
polardb/include/alibabacloud/polardb/model/CheckDBNameResult.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_CHECKDBNAMERESULT_H_
#define ALIBABACLOUD_POLARDB_MODEL_CHECKDBNAMERESULT_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 CheckDBNameResult : public ServiceResult
{
public:
CheckDBNameResult();
explicit CheckDBNameResult(const std::string &payload);
~CheckDBNameResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_POLARDB_MODEL_CHECKDBNAMERESULT_H_

3
polardb/include/alibabacloud/polardb/model/CreateAccountRequest.h
View File

@@ -37,6 +37,8 @@ namespace AlibabaCloud
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getAccountType()const;
void setAccountType(const std::string& accountType);
std::string getAccountDescription()const;
@@ -62,6 +64,7 @@ namespace AlibabaCloud
private:
long resourceOwnerId_;
std::string clientToken_;
std::string accountType_;
std::string accountDescription_;
std::string accessKeyId_;

3
polardb/include/alibabacloud/polardb/model/CreateBackupRequest.h
View File

@@ -37,6 +37,8 @@ namespace AlibabaCloud
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getResourceOwnerAccount()const;
@@ -50,6 +52,7 @@ namespace AlibabaCloud
private:
long resourceOwnerId_;
std::string clientToken_;
std::string accessKeyId_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;

3
polardb/include/alibabacloud/polardb/model/CreateDBLinkRequest.h
View File

@@ -39,6 +39,8 @@ namespace AlibabaCloud
void setResourceOwnerId(long resourceOwnerId);
std::string getSourceDBName()const;
void setSourceDBName(const std::string& sourceDBName);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getTargetDBName()const;
@@ -71,6 +73,7 @@ namespace AlibabaCloud
private:
long resourceOwnerId_;
std::string sourceDBName_;
std::string clientToken_;
std::string accessKeyId_;
std::string targetDBName_;
std::string targetIp_;

6
polardb/include/alibabacloud/polardb/model/CreateDBNodesRequest.h
View File

@@ -47,6 +47,8 @@ namespace AlibabaCloud
void setClientToken(const std::string& clientToken);
std::string getEndpointBindList()const;
void setEndpointBindList(const std::string& endpointBindList);
std::string getPlannedEndTime()const;
void setPlannedEndTime(const std::string& plannedEndTime);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getResourceOwnerAccount()const;
@@ -57,6 +59,8 @@ namespace AlibabaCloud
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getPlannedStartTime()const;
void setPlannedStartTime(const std::string& plannedStartTime);
std::vector<DBNode> getDBNode()const;
void setDBNode(const std::vector<DBNode>& dBNode);
@@ -64,11 +68,13 @@ namespace AlibabaCloud
long resourceOwnerId_;
std::string clientToken_;
std::string endpointBindList_;
std::string plannedEndTime_;
std::string accessKeyId_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
std::string plannedStartTime_;
std::vector<DBNode> dBNode_;
};

66
polardb/include/alibabacloud/polardb/model/DescribeCharacterSetNameRequest.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_DESCRIBECHARACTERSETNAMEREQUEST_H_
#define ALIBABACLOUD_POLARDB_MODEL_DESCRIBECHARACTERSETNAMEREQUEST_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 DescribeCharacterSetNameRequest : public RpcServiceRequest
{
public:
DescribeCharacterSetNameRequest();
~DescribeCharacterSetNameRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string 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 regionId_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDB_MODEL_DESCRIBECHARACTERSETNAMEREQUEST_H_

53
polardb/include/alibabacloud/polardb/model/DescribeCharacterSetNameResult.h Normal file
View File

@@ -0,0 +1,53 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDB_MODEL_DESCRIBECHARACTERSETNAMERESULT_H_
#define ALIBABACLOUD_POLARDB_MODEL_DESCRIBECHARACTERSETNAMERESULT_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 DescribeCharacterSetNameResult : public ServiceResult
{
public:
DescribeCharacterSetNameResult();
explicit DescribeCharacterSetNameResult(const std::string &payload);
~DescribeCharacterSetNameResult();
std::vector<std::string> getCharacterSetNameItems()const;
std::string getEngine()const;
protected:
void parse(const std::string &payload);
private:
std::vector<std::string> characterSetNameItems_;
std::string engine_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDB_MODEL_DESCRIBECHARACTERSETNAMERESULT_H_

63
polardb/include/alibabacloud/polardb/model/DescribeDBInitializeVariableRequest.h Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_POLARDB_MODEL_DESCRIBEDBINITIALIZEVARIABLEREQUEST_H_
#define ALIBABACLOUD_POLARDB_MODEL_DESCRIBEDBINITIALIZEVARIABLEREQUEST_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 DescribeDBInitializeVariableRequest : public RpcServiceRequest
{
public:
DescribeDBInitializeVariableRequest();
~DescribeDBInitializeVariableRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string 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 resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDB_MODEL_DESCRIBEDBINITIALIZEVARIABLEREQUEST_H_

61
polardb/include/alibabacloud/polardb/model/DescribeDBInitializeVariableResult.h Normal file
View File

@@ -0,0 +1,61 @@
/*
* 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_DESCRIBEDBINITIALIZEVARIABLERESULT_H_
#define ALIBABACLOUD_POLARDB_MODEL_DESCRIBEDBINITIALIZEVARIABLERESULT_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 DescribeDBInitializeVariableResult : public ServiceResult
{
public:
struct Variable
{
std::string charset;
std::string collate;
std::string ctype;
};
DescribeDBInitializeVariableResult();
explicit DescribeDBInitializeVariableResult(const std::string &payload);
~DescribeDBInitializeVariableResult();
std::vector<Variable> getVariables()const;
std::string getDBVersion()const;
std::string getDBType()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Variable> variables_;
std::string dBVersion_;
std::string dBType_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDB_MODEL_DESCRIBEDBINITIALIZEVARIABLERESULT_H_

3
polardb/include/alibabacloud/polardb/model/DescribePendingMaintenanceActionsRequest.h
View File

@@ -43,6 +43,8 @@ namespace AlibabaCloud
void setIsHistory(int isHistory);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string getOwnerAccount()const;
@@ -55,6 +57,7 @@ namespace AlibabaCloud
std::string accessKeyId_;
int isHistory_;
std::string securityToken_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;
long ownerId_;

69
polardb/include/alibabacloud/polardb/model/DescribeScheduleTasksRequest.h Normal file
View File

@@ -0,0 +1,69 @@
/*
* 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_DESCRIBESCHEDULETASKSREQUEST_H_
#define ALIBABACLOUD_POLARDB_MODEL_DESCRIBESCHEDULETASKSREQUEST_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 DescribeScheduleTasksRequest : public RpcServiceRequest
{
public:
DescribeScheduleTasksRequest();
~DescribeScheduleTasksRequest();
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getResourceOwnerAccount()const;
void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
std::string 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);
std::string getStatus()const;
void setStatus(const std::string& status);
private:
long resourceOwnerId_;
std::string accessKeyId_;
std::string regionId_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
std::string status_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDB_MODEL_DESCRIBESCHEDULETASKSREQUEST_H_

80
polardb/include/alibabacloud/polardb/model/DescribeScheduleTasksResult.h Normal file
View File

@@ -0,0 +1,80 @@
/*
* 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_DESCRIBESCHEDULETASKSRESULT_H_
#define ALIBABACLOUD_POLARDB_MODEL_DESCRIBESCHEDULETASKSRESULT_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 DescribeScheduleTasksResult : public ServiceResult
{
public:
struct Items
{
int maxRetryTime;
std::string status;
std::string action;
std::string args;
long plannedTime;
std::string taskId;
std::string productCode;
long gmtModified;
std::string dBClusterId;
long plannedStartTime;
std::string mutex;
std::string orderId;
std::string response;
long gmtCreate;
int type;
std::string region;
int retryTime;
long plannedEndTime;
};
DescribeScheduleTasksResult();
explicit DescribeScheduleTasksResult(const std::string &payload);
~DescribeScheduleTasksResult();
std::string getMessage()const;
int getHttpStatusCode()const;
std::vector<Items> getData()const;
std::string getCode()const;
bool getSuccess()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
int httpStatusCode_;
std::vector<Items> data_;
std::string code_;
bool success_;
};
}
}
}
#endif // !ALIBABACLOUD_POLARDB_MODEL_DESCRIBESCHEDULETASKSRESULT_H_

6
polardb/include/alibabacloud/polardb/model/ModifyDBNodeClassRequest.h
View File

@@ -39,6 +39,8 @@ namespace AlibabaCloud
void setResourceOwnerId(long resourceOwnerId);
std::string getClientToken()const;
void setClientToken(const std::string& clientToken);
std::string getPlannedEndTime()const;
void setPlannedEndTime(const std::string& plannedEndTime);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getDBNodeTargetClass()const;
@@ -51,18 +53,22 @@ namespace AlibabaCloud
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getPlannedStartTime()const;
void setPlannedStartTime(const std::string& plannedStartTime);
std::string getModifyType()const;
void setModifyType(const std::string& modifyType);
private:
long resourceOwnerId_;
std::string clientToken_;
std::string plannedEndTime_;
std::string accessKeyId_;
std::string dBNodeTargetClass_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
std::string plannedStartTime_;
std::string modifyType_;
};

3
polardb/include/alibabacloud/polardb/model/ModifyPendingMaintenanceActionRequest.h
View File

@@ -41,6 +41,8 @@ namespace AlibabaCloud
void setAccessKeyId(const std::string& accessKeyId);
std::string getSecurityToken()const;
void setSecurityToken(const std::string& securityToken);
std::string getRegionId()const;
void setRegionId(const std::string& regionId);
std::string getSwitchTime()const;
void setSwitchTime(const std::string& switchTime);
std::string getResourceOwnerAccount()const;
@@ -56,6 +58,7 @@ namespace AlibabaCloud
long resourceOwnerId_;
std::string accessKeyId_;
std::string securityToken_;
std::string regionId_;
std::string switchTime_;
std::string resourceOwnerAccount_;
std::string ownerAccount_;

9
polardb/include/alibabacloud/polardb/model/UpgradeDBClusterMinorVersionRequest.h
View File

@@ -37,6 +37,8 @@ namespace AlibabaCloud
long getResourceOwnerId()const;
void setResourceOwnerId(long resourceOwnerId);
std::string getPlannedEndTime()const;
void setPlannedEndTime(const std::string& plannedEndTime);
std::string getAccessKeyId()const;
void setAccessKeyId(const std::string& accessKeyId);
std::string getSwitchTimeMode()const;
@@ -49,15 +51,22 @@ namespace AlibabaCloud
void setOwnerAccount(const std::string& ownerAccount);
long getOwnerId()const;
void setOwnerId(long ownerId);
std::string getPlannedStartTime()const;
void setPlannedStartTime(const std::string& plannedStartTime);
bool getFromTimeService()const;
void setFromTimeService(bool fromTimeService);
private:
long resourceOwnerId_;
std::string plannedEndTime_;
std::string accessKeyId_;
std::string switchTimeMode_;
std::string resourceOwnerAccount_;
std::string dBClusterId_;
std::string ownerAccount_;
long ownerId_;
std::string plannedStartTime_;
bool fromTimeService_;
};
}

216
polardb/src/PolardbClient.cc
View File

@@ -51,6 +51,114 @@ PolardbClient::PolardbClient(const std::string & accessKeyId, const std::string
PolardbClient::~PolardbClient()
{}
PolardbClient::CancelScheduleTasksOutcome PolardbClient::cancelScheduleTasks(const CancelScheduleTasksRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CancelScheduleTasksOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CancelScheduleTasksOutcome(CancelScheduleTasksResult(outcome.result()));
else
return CancelScheduleTasksOutcome(outcome.error());
}
void PolardbClient::cancelScheduleTasksAsync(const CancelScheduleTasksRequest& request, const CancelScheduleTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, cancelScheduleTasks(request), context);
};
asyncExecute(new Runnable(fn));
}
PolardbClient::CancelScheduleTasksOutcomeCallable PolardbClient::cancelScheduleTasksCallable(const CancelScheduleTasksRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CancelScheduleTasksOutcome()>>(
[this, request]()
{
return this->cancelScheduleTasks(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
PolardbClient::CheckAccountNameOutcome PolardbClient::checkAccountName(const CheckAccountNameRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CheckAccountNameOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CheckAccountNameOutcome(CheckAccountNameResult(outcome.result()));
else
return CheckAccountNameOutcome(outcome.error());
}
void PolardbClient::checkAccountNameAsync(const CheckAccountNameRequest& request, const CheckAccountNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, checkAccountName(request), context);
};
asyncExecute(new Runnable(fn));
}
PolardbClient::CheckAccountNameOutcomeCallable PolardbClient::checkAccountNameCallable(const CheckAccountNameRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CheckAccountNameOutcome()>>(
[this, request]()
{
return this->checkAccountName(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
PolardbClient::CheckDBNameOutcome PolardbClient::checkDBName(const CheckDBNameRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return CheckDBNameOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return CheckDBNameOutcome(CheckDBNameResult(outcome.result()));
else
return CheckDBNameOutcome(outcome.error());
}
void PolardbClient::checkDBNameAsync(const CheckDBNameRequest& request, const CheckDBNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, checkDBName(request), context);
};
asyncExecute(new Runnable(fn));
}
PolardbClient::CheckDBNameOutcomeCallable PolardbClient::checkDBNameCallable(const CheckDBNameRequest &request) const
{
auto task = std::make_shared<std::packaged_task<CheckDBNameOutcome()>>(
[this, request]()
{
return this->checkDBName(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
PolardbClient::CloseDBClusterMigrationOutcome PolardbClient::closeDBClusterMigration(const CloseDBClusterMigrationRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -879,6 +987,42 @@ PolardbClient::DescribeBackupsOutcomeCallable PolardbClient::describeBackupsCall
return task->get_future();
}
PolardbClient::DescribeCharacterSetNameOutcome PolardbClient::describeCharacterSetName(const DescribeCharacterSetNameRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeCharacterSetNameOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeCharacterSetNameOutcome(DescribeCharacterSetNameResult(outcome.result()));
else
return DescribeCharacterSetNameOutcome(outcome.error());
}
void PolardbClient::describeCharacterSetNameAsync(const DescribeCharacterSetNameRequest& request, const DescribeCharacterSetNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeCharacterSetName(request), context);
};
asyncExecute(new Runnable(fn));
}
PolardbClient::DescribeCharacterSetNameOutcomeCallable PolardbClient::describeCharacterSetNameCallable(const DescribeCharacterSetNameRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeCharacterSetNameOutcome()>>(
[this, request]()
{
return this->describeCharacterSetName(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
PolardbClient::DescribeDBClusterAccessWhitelistOutcome PolardbClient::describeDBClusterAccessWhitelist(const DescribeDBClusterAccessWhitelistRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1383,6 +1527,42 @@ PolardbClient::DescribeDBClustersWithBackupsOutcomeCallable PolardbClient::descr
return task->get_future();
}
PolardbClient::DescribeDBInitializeVariableOutcome PolardbClient::describeDBInitializeVariable(const DescribeDBInitializeVariableRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeDBInitializeVariableOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeDBInitializeVariableOutcome(DescribeDBInitializeVariableResult(outcome.result()));
else
return DescribeDBInitializeVariableOutcome(outcome.error());
}
void PolardbClient::describeDBInitializeVariableAsync(const DescribeDBInitializeVariableRequest& request, const DescribeDBInitializeVariableAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeDBInitializeVariable(request), context);
};
asyncExecute(new Runnable(fn));
}
PolardbClient::DescribeDBInitializeVariableOutcomeCallable PolardbClient::describeDBInitializeVariableCallable(const DescribeDBInitializeVariableRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeDBInitializeVariableOutcome()>>(
[this, request]()
{
return this->describeDBInitializeVariable(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
PolardbClient::DescribeDBLinksOutcome PolardbClient::describeDBLinks(const DescribeDBLinksRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1743,6 +1923,42 @@ PolardbClient::DescribeRegionsOutcomeCallable PolardbClient::describeRegionsCall
return task->get_future();
}
PolardbClient::DescribeScheduleTasksOutcome PolardbClient::describeScheduleTasks(const DescribeScheduleTasksRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return DescribeScheduleTasksOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return DescribeScheduleTasksOutcome(DescribeScheduleTasksResult(outcome.result()));
else
return DescribeScheduleTasksOutcome(outcome.error());
}
void PolardbClient::describeScheduleTasksAsync(const DescribeScheduleTasksRequest& request, const DescribeScheduleTasksAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, describeScheduleTasks(request), context);
};
asyncExecute(new Runnable(fn));
}
PolardbClient::DescribeScheduleTasksOutcomeCallable PolardbClient::describeScheduleTasksCallable(const DescribeScheduleTasksRequest &request) const
{
auto task = std::make_shared<std::packaged_task<DescribeScheduleTasksOutcome()>>(
[this, request]()
{
return this->describeScheduleTasks(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
PolardbClient::DescribeSlowLogRecordsOutcome PolardbClient::describeSlowLogRecords(const DescribeSlowLogRecordsRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

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

51
polardb/src/model/CancelScheduleTasksResult.cc Normal file
View File

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

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

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

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

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

11
polardb/src/model/CreateAccountRequest.cc
View File

@@ -38,6 +38,17 @@ void CreateAccountRequest::setResourceOwnerId(long resourceOwnerId)
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CreateAccountRequest::getClientToken()const
{
return clientToken_;
}
void CreateAccountRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string CreateAccountRequest::getAccountType()const
{
return accountType_;

11
polardb/src/model/CreateBackupRequest.cc
View File

@@ -38,6 +38,17 @@ void CreateBackupRequest::setResourceOwnerId(long resourceOwnerId)
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string CreateBackupRequest::getClientToken()const
{
return clientToken_;
}
void CreateBackupRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string CreateBackupRequest::getAccessKeyId()const
{
return accessKeyId_;

11
polardb/src/model/CreateDBLinkRequest.cc
View File

@@ -49,6 +49,17 @@ void CreateDBLinkRequest::setSourceDBName(const std::string& sourceDBName)
setParameter("SourceDBName", sourceDBName);
}
std::string CreateDBLinkRequest::getClientToken()const
{
return clientToken_;
}
void CreateDBLinkRequest::setClientToken(const std::string& clientToken)
{
clientToken_ = clientToken;
setParameter("ClientToken", clientToken);
}
std::string CreateDBLinkRequest::getAccessKeyId()const
{
return accessKeyId_;

22
polardb/src/model/CreateDBNodesRequest.cc
View File

@@ -60,6 +60,17 @@ void CreateDBNodesRequest::setEndpointBindList(const std::string& endpointBindLi
setParameter("EndpointBindList", endpointBindList);
}
std::string CreateDBNodesRequest::getPlannedEndTime()const
{
return plannedEndTime_;
}
void CreateDBNodesRequest::setPlannedEndTime(const std::string& plannedEndTime)
{
plannedEndTime_ = plannedEndTime;
setParameter("PlannedEndTime", plannedEndTime);
}
std::string CreateDBNodesRequest::getAccessKeyId()const
{
return accessKeyId_;
@@ -115,6 +126,17 @@ void CreateDBNodesRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string CreateDBNodesRequest::getPlannedStartTime()const
{
return plannedStartTime_;
}
void CreateDBNodesRequest::setPlannedStartTime(const std::string& plannedStartTime)
{
plannedStartTime_ = plannedStartTime;
setParameter("PlannedStartTime", plannedStartTime);
}
std::vector<CreateDBNodesRequest::DBNode> CreateDBNodesRequest::getDBNode()const
{
return dBNode_;

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

59
polardb/src/model/DescribeCharacterSetNameResult.cc Normal file
View File

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

95
polardb/src/model/DescribeDBInitializeVariableRequest.cc Normal file
View File

@@ -0,0 +1,95 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/polardb/model/DescribeDBInitializeVariableRequest.h>
using AlibabaCloud::Polardb::Model::DescribeDBInitializeVariableRequest;
DescribeDBInitializeVariableRequest::DescribeDBInitializeVariableRequest() :
RpcServiceRequest("polardb", "2017-08-01", "DescribeDBInitializeVariable")
{
setMethod(HttpRequest::Method::Post);
}
DescribeDBInitializeVariableRequest::~DescribeDBInitializeVariableRequest()
{}
long DescribeDBInitializeVariableRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeDBInitializeVariableRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeDBInitializeVariableRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeDBInitializeVariableRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DescribeDBInitializeVariableRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeDBInitializeVariableRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeDBInitializeVariableRequest::getDBClusterId()const
{
return dBClusterId_;
}
void DescribeDBInitializeVariableRequest::setDBClusterId(const std::string& dBClusterId)
{
dBClusterId_ = dBClusterId;
setParameter("DBClusterId", dBClusterId);
}
std::string DescribeDBInitializeVariableRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeDBInitializeVariableRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long DescribeDBInitializeVariableRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeDBInitializeVariableRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}

75
polardb/src/model/DescribeDBInitializeVariableResult.cc 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.
*/
#include <alibabacloud/polardb/model/DescribeDBInitializeVariableResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Polardb;
using namespace AlibabaCloud::Polardb::Model;
DescribeDBInitializeVariableResult::DescribeDBInitializeVariableResult() :
ServiceResult()
{}
DescribeDBInitializeVariableResult::DescribeDBInitializeVariableResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeDBInitializeVariableResult::~DescribeDBInitializeVariableResult()
{}
void DescribeDBInitializeVariableResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allVariablesNode = value["Variables"]["Variable"];
for (auto valueVariablesVariable : allVariablesNode)
{
Variable variablesObject;
if(!valueVariablesVariable["Charset"].isNull())
variablesObject.charset = valueVariablesVariable["Charset"].asString();
if(!valueVariablesVariable["Collate"].isNull())
variablesObject.collate = valueVariablesVariable["Collate"].asString();
if(!valueVariablesVariable["Ctype"].isNull())
variablesObject.ctype = valueVariablesVariable["Ctype"].asString();
variables_.push_back(variablesObject);
}
if(!value["DBType"].isNull())
dBType_ = value["DBType"].asString();
if(!value["DBVersion"].isNull())
dBVersion_ = value["DBVersion"].asString();
}
std::vector<DescribeDBInitializeVariableResult::Variable> DescribeDBInitializeVariableResult::getVariables()const
{
return variables_;
}
std::string DescribeDBInitializeVariableResult::getDBVersion()const
{
return dBVersion_;
}
std::string DescribeDBInitializeVariableResult::getDBType()const
{
return dBType_;
}

11
polardb/src/model/DescribePendingMaintenanceActionsRequest.cc
View File

@@ -71,6 +71,17 @@ void DescribePendingMaintenanceActionsRequest::setSecurityToken(const std::strin
setParameter("SecurityToken", securityToken);
}
std::string DescribePendingMaintenanceActionsRequest::getRegionId()const
{
return regionId_;
}
void DescribePendingMaintenanceActionsRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string DescribePendingMaintenanceActionsRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;

117
polardb/src/model/DescribeScheduleTasksRequest.cc Normal file
View File

@@ -0,0 +1,117 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/polardb/model/DescribeScheduleTasksRequest.h>
using AlibabaCloud::Polardb::Model::DescribeScheduleTasksRequest;
DescribeScheduleTasksRequest::DescribeScheduleTasksRequest() :
RpcServiceRequest("polardb", "2017-08-01", "DescribeScheduleTasks")
{
setMethod(HttpRequest::Method::Post);
}
DescribeScheduleTasksRequest::~DescribeScheduleTasksRequest()
{}
long DescribeScheduleTasksRequest::getResourceOwnerId()const
{
return resourceOwnerId_;
}
void DescribeScheduleTasksRequest::setResourceOwnerId(long resourceOwnerId)
{
resourceOwnerId_ = resourceOwnerId;
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string DescribeScheduleTasksRequest::getAccessKeyId()const
{
return accessKeyId_;
}
void DescribeScheduleTasksRequest::setAccessKeyId(const std::string& accessKeyId)
{
accessKeyId_ = accessKeyId;
setParameter("AccessKeyId", accessKeyId);
}
std::string DescribeScheduleTasksRequest::getRegionId()const
{
return regionId_;
}
void DescribeScheduleTasksRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string DescribeScheduleTasksRequest::getResourceOwnerAccount()const
{
return resourceOwnerAccount_;
}
void DescribeScheduleTasksRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
{
resourceOwnerAccount_ = resourceOwnerAccount;
setParameter("ResourceOwnerAccount", resourceOwnerAccount);
}
std::string DescribeScheduleTasksRequest::getDBClusterId()const
{
return dBClusterId_;
}
void DescribeScheduleTasksRequest::setDBClusterId(const std::string& dBClusterId)
{
dBClusterId_ = dBClusterId;
setParameter("DBClusterId", dBClusterId);
}
std::string DescribeScheduleTasksRequest::getOwnerAccount()const
{
return ownerAccount_;
}
void DescribeScheduleTasksRequest::setOwnerAccount(const std::string& ownerAccount)
{
ownerAccount_ = ownerAccount;
setParameter("OwnerAccount", ownerAccount);
}
long DescribeScheduleTasksRequest::getOwnerId()const
{
return ownerId_;
}
void DescribeScheduleTasksRequest::setOwnerId(long ownerId)
{
ownerId_ = ownerId;
setParameter("OwnerId", std::to_string(ownerId));
}
std::string DescribeScheduleTasksRequest::getStatus()const
{
return status_;
}
void DescribeScheduleTasksRequest::setStatus(const std::string& status)
{
status_ = status;
setParameter("Status", status);
}

119
polardb/src/model/DescribeScheduleTasksResult.cc Normal file
View File

@@ -0,0 +1,119 @@
/*
* 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/DescribeScheduleTasksResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Polardb;
using namespace AlibabaCloud::Polardb::Model;
DescribeScheduleTasksResult::DescribeScheduleTasksResult() :
ServiceResult()
{}
DescribeScheduleTasksResult::DescribeScheduleTasksResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
DescribeScheduleTasksResult::~DescribeScheduleTasksResult()
{}
void DescribeScheduleTasksResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto allDataNode = value["Data"]["items"];
for (auto valueDataitems : allDataNode)
{
Items dataObject;
if(!valueDataitems["Action"].isNull())
dataObject.action = valueDataitems["Action"].asString();
if(!valueDataitems["Args"].isNull())
dataObject.args = valueDataitems["Args"].asString();
if(!valueDataitems["GmtCreate"].isNull())
dataObject.gmtCreate = std::stol(valueDataitems["GmtCreate"].asString());
if(!valueDataitems["GmtModified"].isNull())
dataObject.gmtModified = std::stol(valueDataitems["GmtModified"].asString());
if(!valueDataitems["DBClusterId"].isNull())
dataObject.dBClusterId = valueDataitems["DBClusterId"].asString();
if(!valueDataitems["MaxRetryTime"].isNull())
dataObject.maxRetryTime = std::stoi(valueDataitems["MaxRetryTime"].asString());
if(!valueDataitems["Mutex"].isNull())
dataObject.mutex = valueDataitems["Mutex"].asString();
if(!valueDataitems["OrderId"].isNull())
dataObject.orderId = valueDataitems["OrderId"].asString();
if(!valueDataitems["PlannedEndTime"].isNull())
dataObject.plannedEndTime = std::stol(valueDataitems["PlannedEndTime"].asString());
if(!valueDataitems["PlannedStartTime"].isNull())
dataObject.plannedStartTime = std::stol(valueDataitems["PlannedStartTime"].asString());
if(!valueDataitems["PlannedTime"].isNull())
dataObject.plannedTime = std::stol(valueDataitems["PlannedTime"].asString());
if(!valueDataitems["ProductCode"].isNull())
dataObject.productCode = valueDataitems["ProductCode"].asString();
if(!valueDataitems["Region"].isNull())
dataObject.region = valueDataitems["Region"].asString();
if(!valueDataitems["Response"].isNull())
dataObject.response = valueDataitems["Response"].asString();
if(!valueDataitems["RetryTime"].isNull())
dataObject.retryTime = std::stoi(valueDataitems["RetryTime"].asString());
if(!valueDataitems["Status"].isNull())
dataObject.status = valueDataitems["Status"].asString();
if(!valueDataitems["TaskId"].isNull())
dataObject.taskId = valueDataitems["TaskId"].asString();
if(!valueDataitems["Type"].isNull())
dataObject.type = std::stoi(valueDataitems["Type"].asString());
data_.push_back(dataObject);
}
if(!value["Code"].isNull())
code_ = value["Code"].asString();
if(!value["HttpStatusCode"].isNull())
httpStatusCode_ = std::stoi(value["HttpStatusCode"].asString());
if(!value["Message"].isNull())
message_ = value["Message"].asString();
if(!value["Success"].isNull())
success_ = value["Success"].asString() == "true";
}
std::string DescribeScheduleTasksResult::getMessage()const
{
return message_;
}
int DescribeScheduleTasksResult::getHttpStatusCode()const
{
return httpStatusCode_;
}
std::vector<DescribeScheduleTasksResult::Items> DescribeScheduleTasksResult::getData()const
{
return data_;
}
std::string DescribeScheduleTasksResult::getCode()const
{
return code_;
}
bool DescribeScheduleTasksResult::getSuccess()const
{
return success_;
}

22
polardb/src/model/ModifyDBNodeClassRequest.cc
View File

@@ -49,6 +49,17 @@ void ModifyDBNodeClassRequest::setClientToken(const std::string& clientToken)
setParameter("ClientToken", clientToken);
}
std::string ModifyDBNodeClassRequest::getPlannedEndTime()const
{
return plannedEndTime_;
}
void ModifyDBNodeClassRequest::setPlannedEndTime(const std::string& plannedEndTime)
{
plannedEndTime_ = plannedEndTime;
setParameter("PlannedEndTime", plannedEndTime);
}
std::string ModifyDBNodeClassRequest::getAccessKeyId()const
{
return accessKeyId_;
@@ -115,6 +126,17 @@ void ModifyDBNodeClassRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string ModifyDBNodeClassRequest::getPlannedStartTime()const
{
return plannedStartTime_;
}
void ModifyDBNodeClassRequest::setPlannedStartTime(const std::string& plannedStartTime)
{
plannedStartTime_ = plannedStartTime;
setParameter("PlannedStartTime", plannedStartTime);
}
std::string ModifyDBNodeClassRequest::getModifyType()const
{
return modifyType_;

11
polardb/src/model/ModifyPendingMaintenanceActionRequest.cc
View File

@@ -60,6 +60,17 @@ void ModifyPendingMaintenanceActionRequest::setSecurityToken(const std::string&
setParameter("SecurityToken", securityToken);
}
std::string ModifyPendingMaintenanceActionRequest::getRegionId()const
{
return regionId_;
}
void ModifyPendingMaintenanceActionRequest::setRegionId(const std::string& regionId)
{
regionId_ = regionId;
setParameter("RegionId", regionId);
}
std::string ModifyPendingMaintenanceActionRequest::getSwitchTime()const
{
return switchTime_;

33
polardb/src/model/UpgradeDBClusterMinorVersionRequest.cc
View File

@@ -38,6 +38,17 @@ void UpgradeDBClusterMinorVersionRequest::setResourceOwnerId(long resourceOwnerI
setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
}
std::string UpgradeDBClusterMinorVersionRequest::getPlannedEndTime()const
{
return plannedEndTime_;
}
void UpgradeDBClusterMinorVersionRequest::setPlannedEndTime(const std::string& plannedEndTime)
{
plannedEndTime_ = plannedEndTime;
setParameter("PlannedEndTime", plannedEndTime);
}
std::string UpgradeDBClusterMinorVersionRequest::getAccessKeyId()const
{
return accessKeyId_;
@@ -104,3 +115,25 @@ void UpgradeDBClusterMinorVersionRequest::setOwnerId(long ownerId)
setParameter("OwnerId", std::to_string(ownerId));
}
std::string UpgradeDBClusterMinorVersionRequest::getPlannedStartTime()const
{
return plannedStartTime_;
}
void UpgradeDBClusterMinorVersionRequest::setPlannedStartTime(const std::string& plannedStartTime)
{
plannedStartTime_ = plannedStartTime;
setParameter("PlannedStartTime", plannedStartTime);
}
bool UpgradeDBClusterMinorVersionRequest::getFromTimeService()const
{
return fromTimeService_;
}
void UpgradeDBClusterMinorVersionRequest::setFromTimeService(bool fromTimeService)
{
fromTimeService_ = fromTimeService;
setParameter("FromTimeService", fromTimeService ? "true" : "false");
}