diff --git a/CHANGELOG b/CHANGELOG index 39e9da173..a14d3364f 100644 --- a/CHANGELOG +++ b/CHANGELOG @@ -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. diff --git a/polardb/CMakeLists.txt b/polardb/CMakeLists.txt index 12295325a..8e3d6845c 100644 --- a/polardb/CMakeLists.txt +++ b/polardb/CMakeLists.txt @@ -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 diff --git a/polardb/include/alibabacloud/polardb/PolardbClient.h b/polardb/include/alibabacloud/polardb/PolardbClient.h index f5a378161..b7260d70b 100644 --- a/polardb/include/alibabacloud/polardb/PolardbClient.h +++ b/polardb/include/alibabacloud/polardb/PolardbClient.h @@ -22,6 +22,12 @@ #include #include #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 CancelScheduleTasksOutcome; + typedef std::future CancelScheduleTasksOutcomeCallable; + typedef std::function&)> CancelScheduleTasksAsyncHandler; + typedef Outcome CheckAccountNameOutcome; + typedef std::future CheckAccountNameOutcomeCallable; + typedef std::function&)> CheckAccountNameAsyncHandler; + typedef Outcome CheckDBNameOutcome; + typedef std::future CheckDBNameOutcomeCallable; + typedef std::function&)> CheckDBNameAsyncHandler; typedef Outcome CloseDBClusterMigrationOutcome; typedef std::future CloseDBClusterMigrationOutcomeCallable; typedef std::function&)> CloseDBClusterMigrationAsyncHandler; @@ -258,6 +279,9 @@ namespace AlibabaCloud typedef Outcome DescribeBackupsOutcome; typedef std::future DescribeBackupsOutcomeCallable; typedef std::function&)> DescribeBackupsAsyncHandler; + typedef Outcome DescribeCharacterSetNameOutcome; + typedef std::future DescribeCharacterSetNameOutcomeCallable; + typedef std::function&)> DescribeCharacterSetNameAsyncHandler; typedef Outcome DescribeDBClusterAccessWhitelistOutcome; typedef std::future DescribeDBClusterAccessWhitelistOutcomeCallable; typedef std::function&)> DescribeDBClusterAccessWhitelistAsyncHandler; @@ -300,6 +324,9 @@ namespace AlibabaCloud typedef Outcome DescribeDBClustersWithBackupsOutcome; typedef std::future DescribeDBClustersWithBackupsOutcomeCallable; typedef std::function&)> DescribeDBClustersWithBackupsAsyncHandler; + typedef Outcome DescribeDBInitializeVariableOutcome; + typedef std::future DescribeDBInitializeVariableOutcomeCallable; + typedef std::function&)> DescribeDBInitializeVariableAsyncHandler; typedef Outcome DescribeDBLinksOutcome; typedef std::future DescribeDBLinksOutcomeCallable; typedef std::function&)> DescribeDBLinksAsyncHandler; @@ -330,6 +357,9 @@ namespace AlibabaCloud typedef Outcome DescribeRegionsOutcome; typedef std::future DescribeRegionsOutcomeCallable; typedef std::function&)> DescribeRegionsAsyncHandler; + typedef Outcome DescribeScheduleTasksOutcome; + typedef std::future DescribeScheduleTasksOutcomeCallable; + typedef std::function&)> DescribeScheduleTasksAsyncHandler; typedef Outcome DescribeSlowLogRecordsOutcome; typedef std::future DescribeSlowLogRecordsOutcomeCallable; typedef std::function&)> DescribeSlowLogRecordsAsyncHandler; @@ -431,6 +461,15 @@ namespace AlibabaCloud PolardbClient(const std::shared_ptr &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& 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& 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& 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& 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& 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& 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& 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& 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& 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& 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& 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& 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& context = nullptr) const; DescribeSlowLogRecordsOutcomeCallable describeSlowLogRecordsCallable(const Model::DescribeSlowLogRecordsRequest& request) const; diff --git a/polardb/include/alibabacloud/polardb/model/CancelScheduleTasksRequest.h b/polardb/include/alibabacloud/polardb/model/CancelScheduleTasksRequest.h new file mode 100644 index 000000000..da2572224 --- /dev/null +++ b/polardb/include/alibabacloud/polardb/model/CancelScheduleTasksRequest.h @@ -0,0 +1,66 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_POLARDB_MODEL_CANCELSCHEDULETASKSREQUEST_H_ +#define ALIBABACLOUD_POLARDB_MODEL_CANCELSCHEDULETASKSREQUEST_H_ + +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/polardb/include/alibabacloud/polardb/model/CancelScheduleTasksResult.h b/polardb/include/alibabacloud/polardb/model/CancelScheduleTasksResult.h new file mode 100644 index 000000000..faaae2fe3 --- /dev/null +++ b/polardb/include/alibabacloud/polardb/model/CancelScheduleTasksResult.h @@ -0,0 +1,51 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_POLARDB_MODEL_CANCELSCHEDULETASKSRESULT_H_ +#define ALIBABACLOUD_POLARDB_MODEL_CANCELSCHEDULETASKSRESULT_H_ + +#include +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/polardb/include/alibabacloud/polardb/model/CheckAccountNameRequest.h b/polardb/include/alibabacloud/polardb/model/CheckAccountNameRequest.h new file mode 100644 index 000000000..0bf9b4105 --- /dev/null +++ b/polardb/include/alibabacloud/polardb/model/CheckAccountNameRequest.h @@ -0,0 +1,66 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_POLARDB_MODEL_CHECKACCOUNTNAMEREQUEST_H_ +#define ALIBABACLOUD_POLARDB_MODEL_CHECKACCOUNTNAMEREQUEST_H_ + +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/polardb/include/alibabacloud/polardb/model/CheckAccountNameResult.h b/polardb/include/alibabacloud/polardb/model/CheckAccountNameResult.h new file mode 100644 index 000000000..ea897a9ed --- /dev/null +++ b/polardb/include/alibabacloud/polardb/model/CheckAccountNameResult.h @@ -0,0 +1,49 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_POLARDB_MODEL_CHECKACCOUNTNAMERESULT_H_ +#define ALIBABACLOUD_POLARDB_MODEL_CHECKACCOUNTNAMERESULT_H_ + +#include +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/polardb/include/alibabacloud/polardb/model/CheckDBNameRequest.h b/polardb/include/alibabacloud/polardb/model/CheckDBNameRequest.h new file mode 100644 index 000000000..b206b157b --- /dev/null +++ b/polardb/include/alibabacloud/polardb/model/CheckDBNameRequest.h @@ -0,0 +1,66 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_POLARDB_MODEL_CHECKDBNAMEREQUEST_H_ +#define ALIBABACLOUD_POLARDB_MODEL_CHECKDBNAMEREQUEST_H_ + +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/polardb/include/alibabacloud/polardb/model/CheckDBNameResult.h b/polardb/include/alibabacloud/polardb/model/CheckDBNameResult.h new file mode 100644 index 000000000..e458a85ce --- /dev/null +++ b/polardb/include/alibabacloud/polardb/model/CheckDBNameResult.h @@ -0,0 +1,49 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_POLARDB_MODEL_CHECKDBNAMERESULT_H_ +#define ALIBABACLOUD_POLARDB_MODEL_CHECKDBNAMERESULT_H_ + +#include +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/polardb/include/alibabacloud/polardb/model/CreateAccountRequest.h b/polardb/include/alibabacloud/polardb/model/CreateAccountRequest.h index 7d0f2539b..8a64b03a7 100644 --- a/polardb/include/alibabacloud/polardb/model/CreateAccountRequest.h +++ b/polardb/include/alibabacloud/polardb/model/CreateAccountRequest.h @@ -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_; diff --git a/polardb/include/alibabacloud/polardb/model/CreateBackupRequest.h b/polardb/include/alibabacloud/polardb/model/CreateBackupRequest.h index 8b8f365fe..42f59318c 100644 --- a/polardb/include/alibabacloud/polardb/model/CreateBackupRequest.h +++ b/polardb/include/alibabacloud/polardb/model/CreateBackupRequest.h @@ -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_; diff --git a/polardb/include/alibabacloud/polardb/model/CreateDBLinkRequest.h b/polardb/include/alibabacloud/polardb/model/CreateDBLinkRequest.h index 0b3395fd8..2a78261b4 100644 --- a/polardb/include/alibabacloud/polardb/model/CreateDBLinkRequest.h +++ b/polardb/include/alibabacloud/polardb/model/CreateDBLinkRequest.h @@ -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_; diff --git a/polardb/include/alibabacloud/polardb/model/CreateDBNodesRequest.h b/polardb/include/alibabacloud/polardb/model/CreateDBNodesRequest.h index c95fabe81..7ce69712e 100644 --- a/polardb/include/alibabacloud/polardb/model/CreateDBNodesRequest.h +++ b/polardb/include/alibabacloud/polardb/model/CreateDBNodesRequest.h @@ -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 getDBNode()const; void setDBNode(const std::vector& 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_; }; diff --git a/polardb/include/alibabacloud/polardb/model/DescribeCharacterSetNameRequest.h b/polardb/include/alibabacloud/polardb/model/DescribeCharacterSetNameRequest.h new file mode 100644 index 000000000..b5480b1e9 --- /dev/null +++ b/polardb/include/alibabacloud/polardb/model/DescribeCharacterSetNameRequest.h @@ -0,0 +1,66 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_POLARDB_MODEL_DESCRIBECHARACTERSETNAMEREQUEST_H_ +#define ALIBABACLOUD_POLARDB_MODEL_DESCRIBECHARACTERSETNAMEREQUEST_H_ + +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/polardb/include/alibabacloud/polardb/model/DescribeCharacterSetNameResult.h b/polardb/include/alibabacloud/polardb/model/DescribeCharacterSetNameResult.h new file mode 100644 index 000000000..cb95f9f6b --- /dev/null +++ b/polardb/include/alibabacloud/polardb/model/DescribeCharacterSetNameResult.h @@ -0,0 +1,53 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_POLARDB_MODEL_DESCRIBECHARACTERSETNAMERESULT_H_ +#define ALIBABACLOUD_POLARDB_MODEL_DESCRIBECHARACTERSETNAMERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace Polardb + { + namespace Model + { + class ALIBABACLOUD_POLARDB_EXPORT DescribeCharacterSetNameResult : public ServiceResult + { + public: + + + DescribeCharacterSetNameResult(); + explicit DescribeCharacterSetNameResult(const std::string &payload); + ~DescribeCharacterSetNameResult(); + std::vector getCharacterSetNameItems()const; + std::string getEngine()const; + + protected: + void parse(const std::string &payload); + private: + std::vector characterSetNameItems_; + std::string engine_; + + }; + } + } +} +#endif // !ALIBABACLOUD_POLARDB_MODEL_DESCRIBECHARACTERSETNAMERESULT_H_ \ No newline at end of file diff --git a/polardb/include/alibabacloud/polardb/model/DescribeDBInitializeVariableRequest.h b/polardb/include/alibabacloud/polardb/model/DescribeDBInitializeVariableRequest.h new file mode 100644 index 000000000..4dda88f4c --- /dev/null +++ b/polardb/include/alibabacloud/polardb/model/DescribeDBInitializeVariableRequest.h @@ -0,0 +1,63 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_POLARDB_MODEL_DESCRIBEDBINITIALIZEVARIABLEREQUEST_H_ +#define ALIBABACLOUD_POLARDB_MODEL_DESCRIBEDBINITIALIZEVARIABLEREQUEST_H_ + +#include +#include +#include +#include + +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_ \ No newline at end of file diff --git a/polardb/include/alibabacloud/polardb/model/DescribeDBInitializeVariableResult.h b/polardb/include/alibabacloud/polardb/model/DescribeDBInitializeVariableResult.h new file mode 100644 index 000000000..7fa44b477 --- /dev/null +++ b/polardb/include/alibabacloud/polardb/model/DescribeDBInitializeVariableResult.h @@ -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 +#include +#include +#include +#include + +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 getVariables()const; + std::string getDBVersion()const; + std::string getDBType()const; + + protected: + void parse(const std::string &payload); + private: + std::vector variables_; + std::string dBVersion_; + std::string dBType_; + + }; + } + } +} +#endif // !ALIBABACLOUD_POLARDB_MODEL_DESCRIBEDBINITIALIZEVARIABLERESULT_H_ \ No newline at end of file diff --git a/polardb/include/alibabacloud/polardb/model/DescribePendingMaintenanceActionsRequest.h b/polardb/include/alibabacloud/polardb/model/DescribePendingMaintenanceActionsRequest.h index 681a83912..fdf8bdf70 100644 --- a/polardb/include/alibabacloud/polardb/model/DescribePendingMaintenanceActionsRequest.h +++ b/polardb/include/alibabacloud/polardb/model/DescribePendingMaintenanceActionsRequest.h @@ -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_; diff --git a/polardb/include/alibabacloud/polardb/model/DescribeScheduleTasksRequest.h b/polardb/include/alibabacloud/polardb/model/DescribeScheduleTasksRequest.h new file mode 100644 index 000000000..590536c80 --- /dev/null +++ b/polardb/include/alibabacloud/polardb/model/DescribeScheduleTasksRequest.h @@ -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 +#include +#include +#include + +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_ \ No newline at end of file diff --git a/polardb/include/alibabacloud/polardb/model/DescribeScheduleTasksResult.h b/polardb/include/alibabacloud/polardb/model/DescribeScheduleTasksResult.h new file mode 100644 index 000000000..ec63daf77 --- /dev/null +++ b/polardb/include/alibabacloud/polardb/model/DescribeScheduleTasksResult.h @@ -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 +#include +#include +#include +#include + +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 getData()const; + std::string getCode()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + int httpStatusCode_; + std::vector data_; + std::string code_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_POLARDB_MODEL_DESCRIBESCHEDULETASKSRESULT_H_ \ No newline at end of file diff --git a/polardb/include/alibabacloud/polardb/model/ModifyDBNodeClassRequest.h b/polardb/include/alibabacloud/polardb/model/ModifyDBNodeClassRequest.h index 79c55127f..6fb932813 100644 --- a/polardb/include/alibabacloud/polardb/model/ModifyDBNodeClassRequest.h +++ b/polardb/include/alibabacloud/polardb/model/ModifyDBNodeClassRequest.h @@ -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_; }; diff --git a/polardb/include/alibabacloud/polardb/model/ModifyPendingMaintenanceActionRequest.h b/polardb/include/alibabacloud/polardb/model/ModifyPendingMaintenanceActionRequest.h index 1c5890ccc..572d18214 100644 --- a/polardb/include/alibabacloud/polardb/model/ModifyPendingMaintenanceActionRequest.h +++ b/polardb/include/alibabacloud/polardb/model/ModifyPendingMaintenanceActionRequest.h @@ -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_; diff --git a/polardb/include/alibabacloud/polardb/model/UpgradeDBClusterMinorVersionRequest.h b/polardb/include/alibabacloud/polardb/model/UpgradeDBClusterMinorVersionRequest.h index d1a6e20b2..b35822b26 100644 --- a/polardb/include/alibabacloud/polardb/model/UpgradeDBClusterMinorVersionRequest.h +++ b/polardb/include/alibabacloud/polardb/model/UpgradeDBClusterMinorVersionRequest.h @@ -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_; }; } diff --git a/polardb/src/PolardbClient.cc b/polardb/src/PolardbClient.cc index 28d780d93..5857c0caa 100644 --- a/polardb/src/PolardbClient.cc +++ b/polardb/src/PolardbClient.cc @@ -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& 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>( + [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& 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>( + [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& 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>( + [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& 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>( + [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& 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>( + [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& 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>( + [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(); diff --git a/polardb/src/model/CancelScheduleTasksRequest.cc b/polardb/src/model/CancelScheduleTasksRequest.cc new file mode 100644 index 000000000..b1f758c89 --- /dev/null +++ b/polardb/src/model/CancelScheduleTasksRequest.cc @@ -0,0 +1,106 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +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)); +} + diff --git a/polardb/src/model/CancelScheduleTasksResult.cc b/polardb/src/model/CancelScheduleTasksResult.cc new file mode 100644 index 000000000..694bec9f2 --- /dev/null +++ b/polardb/src/model/CancelScheduleTasksResult.cc @@ -0,0 +1,51 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +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_; +} + diff --git a/polardb/src/model/CheckAccountNameRequest.cc b/polardb/src/model/CheckAccountNameRequest.cc new file mode 100644 index 000000000..730510a6f --- /dev/null +++ b/polardb/src/model/CheckAccountNameRequest.cc @@ -0,0 +1,106 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +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)); +} + diff --git a/polardb/src/model/CheckAccountNameResult.cc b/polardb/src/model/CheckAccountNameResult.cc new file mode 100644 index 000000000..1f2892524 --- /dev/null +++ b/polardb/src/model/CheckAccountNameResult.cc @@ -0,0 +1,44 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +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()); + +} + diff --git a/polardb/src/model/CheckDBNameRequest.cc b/polardb/src/model/CheckDBNameRequest.cc new file mode 100644 index 000000000..8b3668fcd --- /dev/null +++ b/polardb/src/model/CheckDBNameRequest.cc @@ -0,0 +1,106 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +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); +} + diff --git a/polardb/src/model/CheckDBNameResult.cc b/polardb/src/model/CheckDBNameResult.cc new file mode 100644 index 000000000..d98a6af60 --- /dev/null +++ b/polardb/src/model/CheckDBNameResult.cc @@ -0,0 +1,44 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +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()); + +} + diff --git a/polardb/src/model/CreateAccountRequest.cc b/polardb/src/model/CreateAccountRequest.cc index d8440552e..d5a008627 100644 --- a/polardb/src/model/CreateAccountRequest.cc +++ b/polardb/src/model/CreateAccountRequest.cc @@ -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_; diff --git a/polardb/src/model/CreateBackupRequest.cc b/polardb/src/model/CreateBackupRequest.cc index 1ad9051fe..39af51144 100644 --- a/polardb/src/model/CreateBackupRequest.cc +++ b/polardb/src/model/CreateBackupRequest.cc @@ -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_; diff --git a/polardb/src/model/CreateDBLinkRequest.cc b/polardb/src/model/CreateDBLinkRequest.cc index e44860fa9..888fe810e 100644 --- a/polardb/src/model/CreateDBLinkRequest.cc +++ b/polardb/src/model/CreateDBLinkRequest.cc @@ -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_; diff --git a/polardb/src/model/CreateDBNodesRequest.cc b/polardb/src/model/CreateDBNodesRequest.cc index f5f830843..76ae26b13 100644 --- a/polardb/src/model/CreateDBNodesRequest.cc +++ b/polardb/src/model/CreateDBNodesRequest.cc @@ -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::getDBNode()const { return dBNode_; diff --git a/polardb/src/model/DescribeCharacterSetNameRequest.cc b/polardb/src/model/DescribeCharacterSetNameRequest.cc new file mode 100644 index 000000000..71c6d9de9 --- /dev/null +++ b/polardb/src/model/DescribeCharacterSetNameRequest.cc @@ -0,0 +1,106 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +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)); +} + diff --git a/polardb/src/model/DescribeCharacterSetNameResult.cc b/polardb/src/model/DescribeCharacterSetNameResult.cc new file mode 100644 index 000000000..28204deae --- /dev/null +++ b/polardb/src/model/DescribeCharacterSetNameResult.cc @@ -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 +#include + +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 DescribeCharacterSetNameResult::getCharacterSetNameItems()const +{ + return characterSetNameItems_; +} + +std::string DescribeCharacterSetNameResult::getEngine()const +{ + return engine_; +} + diff --git a/polardb/src/model/DescribeDBInitializeVariableRequest.cc b/polardb/src/model/DescribeDBInitializeVariableRequest.cc new file mode 100644 index 000000000..449033302 --- /dev/null +++ b/polardb/src/model/DescribeDBInitializeVariableRequest.cc @@ -0,0 +1,95 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +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)); +} + diff --git a/polardb/src/model/DescribeDBInitializeVariableResult.cc b/polardb/src/model/DescribeDBInitializeVariableResult.cc new file mode 100644 index 000000000..02ad0dbff --- /dev/null +++ b/polardb/src/model/DescribeDBInitializeVariableResult.cc @@ -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 +#include + +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::getVariables()const +{ + return variables_; +} + +std::string DescribeDBInitializeVariableResult::getDBVersion()const +{ + return dBVersion_; +} + +std::string DescribeDBInitializeVariableResult::getDBType()const +{ + return dBType_; +} + diff --git a/polardb/src/model/DescribePendingMaintenanceActionsRequest.cc b/polardb/src/model/DescribePendingMaintenanceActionsRequest.cc index cdbe54f56..0f0e9b45d 100644 --- a/polardb/src/model/DescribePendingMaintenanceActionsRequest.cc +++ b/polardb/src/model/DescribePendingMaintenanceActionsRequest.cc @@ -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_; diff --git a/polardb/src/model/DescribeScheduleTasksRequest.cc b/polardb/src/model/DescribeScheduleTasksRequest.cc new file mode 100644 index 000000000..74d8a38f0 --- /dev/null +++ b/polardb/src/model/DescribeScheduleTasksRequest.cc @@ -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 + +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); +} + diff --git a/polardb/src/model/DescribeScheduleTasksResult.cc b/polardb/src/model/DescribeScheduleTasksResult.cc new file mode 100644 index 000000000..5da7c1b94 --- /dev/null +++ b/polardb/src/model/DescribeScheduleTasksResult.cc @@ -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 +#include + +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::getData()const +{ + return data_; +} + +std::string DescribeScheduleTasksResult::getCode()const +{ + return code_; +} + +bool DescribeScheduleTasksResult::getSuccess()const +{ + return success_; +} + diff --git a/polardb/src/model/ModifyDBNodeClassRequest.cc b/polardb/src/model/ModifyDBNodeClassRequest.cc index 094aee802..6c8f79bc1 100644 --- a/polardb/src/model/ModifyDBNodeClassRequest.cc +++ b/polardb/src/model/ModifyDBNodeClassRequest.cc @@ -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_; diff --git a/polardb/src/model/ModifyPendingMaintenanceActionRequest.cc b/polardb/src/model/ModifyPendingMaintenanceActionRequest.cc index 882485782..2e1c88a0d 100644 --- a/polardb/src/model/ModifyPendingMaintenanceActionRequest.cc +++ b/polardb/src/model/ModifyPendingMaintenanceActionRequest.cc @@ -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_; diff --git a/polardb/src/model/UpgradeDBClusterMinorVersionRequest.cc b/polardb/src/model/UpgradeDBClusterMinorVersionRequest.cc index 813ae307c..9af1db3ad 100644 --- a/polardb/src/model/UpgradeDBClusterMinorVersionRequest.cc +++ b/polardb/src/model/UpgradeDBClusterMinorVersionRequest.cc @@ -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"); +} +