diff --git a/VERSION b/VERSION index f3141200c..a906b9bd3 100644 --- a/VERSION +++ b/VERSION @@ -1 +1 @@ -1.36.2075 \ No newline at end of file +1.36.2076 \ No newline at end of file diff --git a/oceanbasepro/CMakeLists.txt b/oceanbasepro/CMakeLists.txt index 3cd57613c..a0bbbbe8e 100644 --- a/oceanbasepro/CMakeLists.txt +++ b/oceanbasepro/CMakeLists.txt @@ -37,6 +37,8 @@ set(oceanbasepro_public_header_model include/alibabacloud/oceanbasepro/model/CreateLabelResult.h include/alibabacloud/oceanbasepro/model/CreateMySqlDataSourceRequest.h include/alibabacloud/oceanbasepro/model/CreateMySqlDataSourceResult.h + include/alibabacloud/oceanbasepro/model/CreateOasOutlineTaskRequest.h + include/alibabacloud/oceanbasepro/model/CreateOasOutlineTaskResult.h include/alibabacloud/oceanbasepro/model/CreateOceanBaseDataSourceRequest.h include/alibabacloud/oceanbasepro/model/CreateOceanBaseDataSourceResult.h include/alibabacloud/oceanbasepro/model/CreateOmsMysqlDataSourceRequest.h @@ -103,6 +105,8 @@ set(oceanbasepro_public_header_model include/alibabacloud/oceanbasepro/model/DescribeDatabasesResult.h include/alibabacloud/oceanbasepro/model/DescribeInstanceRequest.h include/alibabacloud/oceanbasepro/model/DescribeInstanceResult.h + include/alibabacloud/oceanbasepro/model/DescribeInstanceAvailableZonesRequest.h + include/alibabacloud/oceanbasepro/model/DescribeInstanceAvailableZonesResult.h include/alibabacloud/oceanbasepro/model/DescribeInstanceCreatableZoneRequest.h include/alibabacloud/oceanbasepro/model/DescribeInstanceCreatableZoneResult.h include/alibabacloud/oceanbasepro/model/DescribeInstanceSSLRequest.h @@ -153,6 +157,8 @@ set(oceanbasepro_public_header_model include/alibabacloud/oceanbasepro/model/DescribeProjectStepMetricResult.h include/alibabacloud/oceanbasepro/model/DescribeProjectStepsRequest.h include/alibabacloud/oceanbasepro/model/DescribeProjectStepsResult.h + include/alibabacloud/oceanbasepro/model/DescribeProxyServiceRequest.h + include/alibabacloud/oceanbasepro/model/DescribeProxyServiceResult.h include/alibabacloud/oceanbasepro/model/DescribeRecommendIndexRequest.h include/alibabacloud/oceanbasepro/model/DescribeRecommendIndexResult.h include/alibabacloud/oceanbasepro/model/DescribeRestorableTenantsRequest.h @@ -177,6 +183,8 @@ set(oceanbasepro_public_header_model include/alibabacloud/oceanbasepro/model/DescribeSlowSQLHistoryListResult.h include/alibabacloud/oceanbasepro/model/DescribeSlowSQLListRequest.h include/alibabacloud/oceanbasepro/model/DescribeSlowSQLListResult.h + include/alibabacloud/oceanbasepro/model/DescribeSqlAuditStatRequest.h + include/alibabacloud/oceanbasepro/model/DescribeSqlAuditStatResult.h include/alibabacloud/oceanbasepro/model/DescribeStandbyCreateModeRequest.h include/alibabacloud/oceanbasepro/model/DescribeStandbyCreateModeResult.h include/alibabacloud/oceanbasepro/model/DescribeTagValuesRequest.h @@ -271,6 +279,8 @@ set(oceanbasepro_public_header_model include/alibabacloud/oceanbasepro/model/ReleaseProjectResult.h include/alibabacloud/oceanbasepro/model/ReleaseWorkerInstanceRequest.h include/alibabacloud/oceanbasepro/model/ReleaseWorkerInstanceResult.h + include/alibabacloud/oceanbasepro/model/RemoveStandbyInstanceRequest.h + include/alibabacloud/oceanbasepro/model/RemoveStandbyInstanceResult.h include/alibabacloud/oceanbasepro/model/ResumeProjectRequest.h include/alibabacloud/oceanbasepro/model/ResumeProjectResult.h include/alibabacloud/oceanbasepro/model/RetryProjectModifyRecordsRequest.h @@ -308,6 +318,8 @@ set(oceanbasepro_src src/model/CreateLabelResult.cc src/model/CreateMySqlDataSourceRequest.cc src/model/CreateMySqlDataSourceResult.cc + src/model/CreateOasOutlineTaskRequest.cc + src/model/CreateOasOutlineTaskResult.cc src/model/CreateOceanBaseDataSourceRequest.cc src/model/CreateOceanBaseDataSourceResult.cc src/model/CreateOmsMysqlDataSourceRequest.cc @@ -374,6 +386,8 @@ set(oceanbasepro_src src/model/DescribeDatabasesResult.cc src/model/DescribeInstanceRequest.cc src/model/DescribeInstanceResult.cc + src/model/DescribeInstanceAvailableZonesRequest.cc + src/model/DescribeInstanceAvailableZonesResult.cc src/model/DescribeInstanceCreatableZoneRequest.cc src/model/DescribeInstanceCreatableZoneResult.cc src/model/DescribeInstanceSSLRequest.cc @@ -424,6 +438,8 @@ set(oceanbasepro_src src/model/DescribeProjectStepMetricResult.cc src/model/DescribeProjectStepsRequest.cc src/model/DescribeProjectStepsResult.cc + src/model/DescribeProxyServiceRequest.cc + src/model/DescribeProxyServiceResult.cc src/model/DescribeRecommendIndexRequest.cc src/model/DescribeRecommendIndexResult.cc src/model/DescribeRestorableTenantsRequest.cc @@ -448,6 +464,8 @@ set(oceanbasepro_src src/model/DescribeSlowSQLHistoryListResult.cc src/model/DescribeSlowSQLListRequest.cc src/model/DescribeSlowSQLListResult.cc + src/model/DescribeSqlAuditStatRequest.cc + src/model/DescribeSqlAuditStatResult.cc src/model/DescribeStandbyCreateModeRequest.cc src/model/DescribeStandbyCreateModeResult.cc src/model/DescribeTagValuesRequest.cc @@ -542,6 +560,8 @@ set(oceanbasepro_src src/model/ReleaseProjectResult.cc src/model/ReleaseWorkerInstanceRequest.cc src/model/ReleaseWorkerInstanceResult.cc + src/model/RemoveStandbyInstanceRequest.cc + src/model/RemoveStandbyInstanceResult.cc src/model/ResumeProjectRequest.cc src/model/ResumeProjectResult.cc src/model/RetryProjectModifyRecordsRequest.cc diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/OceanBaseProClient.h b/oceanbasepro/include/alibabacloud/oceanbasepro/OceanBaseProClient.h index 4004a2ea8..b646d3846 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/OceanBaseProClient.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/OceanBaseProClient.h @@ -38,6 +38,8 @@ #include "model/CreateLabelResult.h" #include "model/CreateMySqlDataSourceRequest.h" #include "model/CreateMySqlDataSourceResult.h" +#include "model/CreateOasOutlineTaskRequest.h" +#include "model/CreateOasOutlineTaskResult.h" #include "model/CreateOceanBaseDataSourceRequest.h" #include "model/CreateOceanBaseDataSourceResult.h" #include "model/CreateOmsMysqlDataSourceRequest.h" @@ -104,6 +106,8 @@ #include "model/DescribeDatabasesResult.h" #include "model/DescribeInstanceRequest.h" #include "model/DescribeInstanceResult.h" +#include "model/DescribeInstanceAvailableZonesRequest.h" +#include "model/DescribeInstanceAvailableZonesResult.h" #include "model/DescribeInstanceCreatableZoneRequest.h" #include "model/DescribeInstanceCreatableZoneResult.h" #include "model/DescribeInstanceSSLRequest.h" @@ -154,6 +158,8 @@ #include "model/DescribeProjectStepMetricResult.h" #include "model/DescribeProjectStepsRequest.h" #include "model/DescribeProjectStepsResult.h" +#include "model/DescribeProxyServiceRequest.h" +#include "model/DescribeProxyServiceResult.h" #include "model/DescribeRecommendIndexRequest.h" #include "model/DescribeRecommendIndexResult.h" #include "model/DescribeRestorableTenantsRequest.h" @@ -178,6 +184,8 @@ #include "model/DescribeSlowSQLHistoryListResult.h" #include "model/DescribeSlowSQLListRequest.h" #include "model/DescribeSlowSQLListResult.h" +#include "model/DescribeSqlAuditStatRequest.h" +#include "model/DescribeSqlAuditStatResult.h" #include "model/DescribeStandbyCreateModeRequest.h" #include "model/DescribeStandbyCreateModeResult.h" #include "model/DescribeTagValuesRequest.h" @@ -272,6 +280,8 @@ #include "model/ReleaseProjectResult.h" #include "model/ReleaseWorkerInstanceRequest.h" #include "model/ReleaseWorkerInstanceResult.h" +#include "model/RemoveStandbyInstanceRequest.h" +#include "model/RemoveStandbyInstanceResult.h" #include "model/ResumeProjectRequest.h" #include "model/ResumeProjectResult.h" #include "model/RetryProjectModifyRecordsRequest.h" @@ -323,6 +333,9 @@ namespace AlibabaCloud typedef Outcome CreateMySqlDataSourceOutcome; typedef std::future CreateMySqlDataSourceOutcomeCallable; typedef std::function&)> CreateMySqlDataSourceAsyncHandler; + typedef Outcome CreateOasOutlineTaskOutcome; + typedef std::future CreateOasOutlineTaskOutcomeCallable; + typedef std::function&)> CreateOasOutlineTaskAsyncHandler; typedef Outcome CreateOceanBaseDataSourceOutcome; typedef std::future CreateOceanBaseDataSourceOutcomeCallable; typedef std::function&)> CreateOceanBaseDataSourceAsyncHandler; @@ -422,6 +435,9 @@ namespace AlibabaCloud typedef Outcome DescribeInstanceOutcome; typedef std::future DescribeInstanceOutcomeCallable; typedef std::function&)> DescribeInstanceAsyncHandler; + typedef Outcome DescribeInstanceAvailableZonesOutcome; + typedef std::future DescribeInstanceAvailableZonesOutcomeCallable; + typedef std::function&)> DescribeInstanceAvailableZonesAsyncHandler; typedef Outcome DescribeInstanceCreatableZoneOutcome; typedef std::future DescribeInstanceCreatableZoneOutcomeCallable; typedef std::function&)> DescribeInstanceCreatableZoneAsyncHandler; @@ -497,6 +513,9 @@ namespace AlibabaCloud typedef Outcome DescribeProjectStepsOutcome; typedef std::future DescribeProjectStepsOutcomeCallable; typedef std::function&)> DescribeProjectStepsAsyncHandler; + typedef Outcome DescribeProxyServiceOutcome; + typedef std::future DescribeProxyServiceOutcomeCallable; + typedef std::function&)> DescribeProxyServiceAsyncHandler; typedef Outcome DescribeRecommendIndexOutcome; typedef std::future DescribeRecommendIndexOutcomeCallable; typedef std::function&)> DescribeRecommendIndexAsyncHandler; @@ -533,6 +552,9 @@ namespace AlibabaCloud typedef Outcome DescribeSlowSQLListOutcome; typedef std::future DescribeSlowSQLListOutcomeCallable; typedef std::function&)> DescribeSlowSQLListAsyncHandler; + typedef Outcome DescribeSqlAuditStatOutcome; + typedef std::future DescribeSqlAuditStatOutcomeCallable; + typedef std::function&)> DescribeSqlAuditStatAsyncHandler; typedef Outcome DescribeStandbyCreateModeOutcome; typedef std::future DescribeStandbyCreateModeOutcomeCallable; typedef std::function&)> DescribeStandbyCreateModeAsyncHandler; @@ -674,6 +696,9 @@ namespace AlibabaCloud typedef Outcome ReleaseWorkerInstanceOutcome; typedef std::future ReleaseWorkerInstanceOutcomeCallable; typedef std::function&)> ReleaseWorkerInstanceAsyncHandler; + typedef Outcome RemoveStandbyInstanceOutcome; + typedef std::future RemoveStandbyInstanceOutcomeCallable; + typedef std::function&)> RemoveStandbyInstanceAsyncHandler; typedef Outcome ResumeProjectOutcome; typedef std::future ResumeProjectOutcomeCallable; typedef std::function&)> ResumeProjectAsyncHandler; @@ -730,6 +755,9 @@ namespace AlibabaCloud CreateMySqlDataSourceOutcome createMySqlDataSource(const Model::CreateMySqlDataSourceRequest &request)const; void createMySqlDataSourceAsync(const Model::CreateMySqlDataSourceRequest& request, const CreateMySqlDataSourceAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; CreateMySqlDataSourceOutcomeCallable createMySqlDataSourceCallable(const Model::CreateMySqlDataSourceRequest& request) const; + CreateOasOutlineTaskOutcome createOasOutlineTask(const Model::CreateOasOutlineTaskRequest &request)const; + void createOasOutlineTaskAsync(const Model::CreateOasOutlineTaskRequest& request, const CreateOasOutlineTaskAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + CreateOasOutlineTaskOutcomeCallable createOasOutlineTaskCallable(const Model::CreateOasOutlineTaskRequest& request) const; CreateOceanBaseDataSourceOutcome createOceanBaseDataSource(const Model::CreateOceanBaseDataSourceRequest &request)const; void createOceanBaseDataSourceAsync(const Model::CreateOceanBaseDataSourceRequest& request, const CreateOceanBaseDataSourceAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; CreateOceanBaseDataSourceOutcomeCallable createOceanBaseDataSourceCallable(const Model::CreateOceanBaseDataSourceRequest& request) const; @@ -829,6 +857,9 @@ namespace AlibabaCloud DescribeInstanceOutcome describeInstance(const Model::DescribeInstanceRequest &request)const; void describeInstanceAsync(const Model::DescribeInstanceRequest& request, const DescribeInstanceAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; DescribeInstanceOutcomeCallable describeInstanceCallable(const Model::DescribeInstanceRequest& request) const; + DescribeInstanceAvailableZonesOutcome describeInstanceAvailableZones(const Model::DescribeInstanceAvailableZonesRequest &request)const; + void describeInstanceAvailableZonesAsync(const Model::DescribeInstanceAvailableZonesRequest& request, const DescribeInstanceAvailableZonesAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeInstanceAvailableZonesOutcomeCallable describeInstanceAvailableZonesCallable(const Model::DescribeInstanceAvailableZonesRequest& request) const; DescribeInstanceCreatableZoneOutcome describeInstanceCreatableZone(const Model::DescribeInstanceCreatableZoneRequest &request)const; void describeInstanceCreatableZoneAsync(const Model::DescribeInstanceCreatableZoneRequest& request, const DescribeInstanceCreatableZoneAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; DescribeInstanceCreatableZoneOutcomeCallable describeInstanceCreatableZoneCallable(const Model::DescribeInstanceCreatableZoneRequest& request) const; @@ -904,6 +935,9 @@ namespace AlibabaCloud DescribeProjectStepsOutcome describeProjectSteps(const Model::DescribeProjectStepsRequest &request)const; void describeProjectStepsAsync(const Model::DescribeProjectStepsRequest& request, const DescribeProjectStepsAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; DescribeProjectStepsOutcomeCallable describeProjectStepsCallable(const Model::DescribeProjectStepsRequest& request) const; + DescribeProxyServiceOutcome describeProxyService(const Model::DescribeProxyServiceRequest &request)const; + void describeProxyServiceAsync(const Model::DescribeProxyServiceRequest& request, const DescribeProxyServiceAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeProxyServiceOutcomeCallable describeProxyServiceCallable(const Model::DescribeProxyServiceRequest& request) const; DescribeRecommendIndexOutcome describeRecommendIndex(const Model::DescribeRecommendIndexRequest &request)const; void describeRecommendIndexAsync(const Model::DescribeRecommendIndexRequest& request, const DescribeRecommendIndexAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; DescribeRecommendIndexOutcomeCallable describeRecommendIndexCallable(const Model::DescribeRecommendIndexRequest& request) const; @@ -940,6 +974,9 @@ namespace AlibabaCloud DescribeSlowSQLListOutcome describeSlowSQLList(const Model::DescribeSlowSQLListRequest &request)const; void describeSlowSQLListAsync(const Model::DescribeSlowSQLListRequest& request, const DescribeSlowSQLListAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; DescribeSlowSQLListOutcomeCallable describeSlowSQLListCallable(const Model::DescribeSlowSQLListRequest& request) const; + DescribeSqlAuditStatOutcome describeSqlAuditStat(const Model::DescribeSqlAuditStatRequest &request)const; + void describeSqlAuditStatAsync(const Model::DescribeSqlAuditStatRequest& request, const DescribeSqlAuditStatAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + DescribeSqlAuditStatOutcomeCallable describeSqlAuditStatCallable(const Model::DescribeSqlAuditStatRequest& request) const; DescribeStandbyCreateModeOutcome describeStandbyCreateMode(const Model::DescribeStandbyCreateModeRequest &request)const; void describeStandbyCreateModeAsync(const Model::DescribeStandbyCreateModeRequest& request, const DescribeStandbyCreateModeAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; DescribeStandbyCreateModeOutcomeCallable describeStandbyCreateModeCallable(const Model::DescribeStandbyCreateModeRequest& request) const; @@ -1081,6 +1118,9 @@ namespace AlibabaCloud ReleaseWorkerInstanceOutcome releaseWorkerInstance(const Model::ReleaseWorkerInstanceRequest &request)const; void releaseWorkerInstanceAsync(const Model::ReleaseWorkerInstanceRequest& request, const ReleaseWorkerInstanceAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; ReleaseWorkerInstanceOutcomeCallable releaseWorkerInstanceCallable(const Model::ReleaseWorkerInstanceRequest& request) const; + RemoveStandbyInstanceOutcome removeStandbyInstance(const Model::RemoveStandbyInstanceRequest &request)const; + void removeStandbyInstanceAsync(const Model::RemoveStandbyInstanceRequest& request, const RemoveStandbyInstanceAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; + RemoveStandbyInstanceOutcomeCallable removeStandbyInstanceCallable(const Model::RemoveStandbyInstanceRequest& request) const; ResumeProjectOutcome resumeProject(const Model::ResumeProjectRequest &request)const; void resumeProjectAsync(const Model::ResumeProjectRequest& request, const ResumeProjectAsyncHandler& handler, const std::shared_ptr& context = nullptr) const; ResumeProjectOutcomeCallable resumeProjectCallable(const Model::ResumeProjectRequest& request) const; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/BatchKillProcessListRequest.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/BatchKillProcessListRequest.h index b3edd88cf..55bffedc6 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/BatchKillProcessListRequest.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/BatchKillProcessListRequest.h @@ -32,6 +32,8 @@ public: ~BatchKillProcessListRequest(); std::string getSessionList() const; void setSessionList(const std::string &sessionList); + bool getByObSessionId() const; + void setByObSessionId(bool byObSessionId); std::string getInstanceId() const; void setInstanceId(const std::string &instanceId); std::string getTenantId() const; @@ -39,6 +41,7 @@ public: private: std::string sessionList_; + bool byObSessionId_; std::string instanceId_; std::string tenantId_; }; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateOasOutlineTaskRequest.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateOasOutlineTaskRequest.h new file mode 100644 index 000000000..12fbfa309 --- /dev/null +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateOasOutlineTaskRequest.h @@ -0,0 +1,87 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_OCEANBASEPRO_MODEL_CREATEOASOUTLINETASKREQUEST_H_ +#define ALIBABACLOUD_OCEANBASEPRO_MODEL_CREATEOASOUTLINETASKREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace OceanBasePro { +namespace Model { +class ALIBABACLOUD_OCEANBASEPRO_EXPORT CreateOasOutlineTaskRequest : public RpcServiceRequest { +public: + CreateOasOutlineTaskRequest(); + ~CreateOasOutlineTaskRequest(); + std::string getStartTime() const; + void setStartTime(const std::string &startTime); + std::string getUId() const; + void setUId(const std::string &uId); + bool getDynamicSql() const; + void setDynamicSql(bool dynamicSql); + std::string getSqlText() const; + void setSqlText(const std::string &sqlText); + bool getBySqlId() const; + void setBySqlId(bool bySqlId); + int getMaxConcurrent() const; + void setMaxConcurrent(int maxConcurrent); + std::string getTenantId() const; + void setTenantId(const std::string &tenantId); + std::string getStatementId() const; + void setStatementId(const std::string &statementId); + std::string getTableName() const; + void setTableName(const std::string &tableName); + std::string getSqlId() const; + void setSqlId(const std::string &sqlId); + std::string getEndTime() const; + void setEndTime(const std::string &endTime); + std::string getInstanceId() const; + void setInstanceId(const std::string &instanceId); + std::string getPlanData() const; + void setPlanData(const std::string &planData); + std::string getIndexName() const; + void setIndexName(const std::string &indexName); + std::string getDatabaseName() const; + void setDatabaseName(const std::string &databaseName); + bool getIsConcurrentLimit() const; + void setIsConcurrentLimit(bool isConcurrentLimit); + +private: + std::string startTime_; + std::string uId_; + bool dynamicSql_; + std::string sqlText_; + bool bySqlId_; + int maxConcurrent_; + std::string tenantId_; + std::string statementId_; + std::string tableName_; + std::string sqlId_; + std::string endTime_; + std::string instanceId_; + std::string planData_; + std::string indexName_; + std::string databaseName_; + bool isConcurrentLimit_; +}; +} // namespace Model +} // namespace OceanBasePro +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_OCEANBASEPRO_MODEL_CREATEOASOUTLINETASKREQUEST_H_ diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateOasOutlineTaskResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateOasOutlineTaskResult.h new file mode 100644 index 000000000..4483082e6 --- /dev/null +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateOasOutlineTaskResult.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_OCEANBASEPRO_MODEL_CREATEOASOUTLINETASKRESULT_H_ +#define ALIBABACLOUD_OCEANBASEPRO_MODEL_CREATEOASOUTLINETASKRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace OceanBasePro + { + namespace Model + { + class ALIBABACLOUD_OCEANBASEPRO_EXPORT CreateOasOutlineTaskResult : public ServiceResult + { + public: + + + CreateOasOutlineTaskResult(); + explicit CreateOasOutlineTaskResult(const std::string &payload); + ~CreateOasOutlineTaskResult(); + std::string getMessage()const; + bool getSuccess()const; + + protected: + void parse(const std::string &payload); + private: + std::string message_; + bool success_; + + }; + } + } +} +#endif // !ALIBABACLOUD_OCEANBASEPRO_MODEL_CREATEOASOUTLINETASKRESULT_H_ \ No newline at end of file diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateProjectModifyRecordsRequest.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateProjectModifyRecordsRequest.h index f60bbcdfc..a391f31e9 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateProjectModifyRecordsRequest.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateProjectModifyRecordsRequest.h @@ -55,6 +55,12 @@ public: std::string mappedName; std::string string; std::vector filterColumns; + struct ObkvPartitionConfig { + std::string virtualColumn; + std::string partitionType; + int partitionSize; + }; + ObkvPartitionConfig obkvPartitionConfig; struct AdbTableSchema { std::string string; std::vector primaryKeys; @@ -117,15 +123,372 @@ public: ViewsItem viewsItem; std::vector views; }; + struct TransferMapping { + std::string mode; + struct DatabasesItem { + std::string mappedName; + struct SpecificViewsItem { + std::string mappedName; + std::string string; + std::vector filterColumns; + struct AdbTableSchema { + std::string string; + std::vector primaryKeys; + std::string partitionStatement; + std::string partitionLifeCycle; + std::string string; + std::vector distributedKeys; + }; + AdbTableSchema adbTableSchema; + std::string name; + std::string whereClause; + std::string id; + std::string string; + std::vector shardColumns; + }; + SpecificViewsItem specificViewsItem; + std::vector specificViews; + struct TablesItem { + std::string mappedName; + std::string string; + std::vector filterColumns; + struct ObkvPartitionConfig { + std::string virtualColumn; + std::string partitionType; + int partitionSize; + }; + ObkvPartitionConfig obkvPartitionConfig; + struct AdbTableSchema { + std::string string; + std::vector primaryKeys; + std::string partitionStatement; + std::string partitionLifeCycle; + std::string string; + std::vector distributedKeys; + }; + AdbTableSchema adbTableSchema; + std::string name; + std::string whereClause; + std::string id; + std::string string; + std::vector shardColumns; + }; + TablesItem tablesItem; + std::vector tables; + std::string clusterName; + std::string name; + std::string tenantName; + std::string id; + struct SpecificTablesItem { + std::string mappedName; + std::string string; + std::vector filterColumns; + struct AdbTableSchema { + std::string string; + std::vector primaryKeys; + std::string partitionStatement; + std::string partitionLifeCycle; + std::string string; + std::vector distributedKeys; + }; + AdbTableSchema adbTableSchema; + std::string name; + std::string whereClause; + std::string id; + std::string string; + std::vector shardColumns; + }; + SpecificTablesItem specificTablesItem; + std::vector specificTables; + struct ViewsItem { + std::string mappedName; + std::string string; + std::vector filterColumns; + struct AdbTableSchema { + std::string string; + std::vector primaryKeys; + std::string partitionStatement; + std::string partitionLifeCycle; + std::string string; + std::vector distributedKeys; + }; + AdbTableSchema adbTableSchema; + std::string name; + std::string whereClause; + std::string id; + std::string string; + std::vector shardColumns; + }; + ViewsItem viewsItem; + std::vector views; + }; + DatabasesItem databasesItem; + std::vector databases; + std::string string; + std::vector tableAndViewBlackList; + struct BlackTableRulesItem { + struct ObjectMapping { + std::string mappedName; + std::string name; + }; + ObjectMapping objectMapping; + struct SchemaMapping { + std::string mappedName; + std::string name; + }; + SchemaMapping schemaMapping; + }; + BlackTableRulesItem blackTableRulesItem; + std::vector blackTableRules; + struct SchemasItem { + std::string mappedName; + struct SpecificViewsItem { + std::string mappedName; + std::string string; + std::vector filterColumns; + struct AdbTableSchema { + std::string string; + std::vector primaryKeys; + std::string partitionStatement; + std::string partitionLifeCycle; + std::string string; + std::vector distributedKeys; + }; + AdbTableSchema adbTableSchema; + std::string name; + std::string whereClause; + std::string id; + std::string string; + std::vector shardColumns; + }; + SpecificViewsItem specificViewsItem; + std::vector specificViews; + struct TablesItem { + std::string mappedName; + std::string string; + std::vector filterColumns; + struct ObkvPartitionConfig { + std::string virtualColumn; + std::string partitionType; + int partitionSize; + }; + ObkvPartitionConfig obkvPartitionConfig; + struct AdbTableSchema { + std::string string; + std::vector primaryKeys; + std::string partitionStatement; + std::string partitionLifeCycle; + std::string string; + std::vector distributedKeys; + }; + AdbTableSchema adbTableSchema; + std::string name; + std::string whereClause; + std::string id; + std::string string; + std::vector shardColumns; + }; + TablesItem tablesItem; + std::vector tables; + std::string clusterName; + std::string name; + std::string tenantName; + std::string id; + struct SpecificTablesItem { + std::string mappedName; + std::string string; + std::vector filterColumns; + struct AdbTableSchema { + std::string string; + std::vector primaryKeys; + std::string partitionStatement; + std::string partitionLifeCycle; + std::string string; + std::vector distributedKeys; + }; + AdbTableSchema adbTableSchema; + std::string name; + std::string whereClause; + std::string id; + std::string string; + std::vector shardColumns; + }; + SpecificTablesItem specificTablesItem; + std::vector specificTables; + struct ViewsItem { + std::string mappedName; + std::string string; + std::vector filterColumns; + struct AdbTableSchema { + std::string string; + std::vector primaryKeys; + std::string partitionStatement; + std::string partitionLifeCycle; + std::string string; + std::vector distributedKeys; + }; + AdbTableSchema adbTableSchema; + std::string name; + std::string whereClause; + std::string id; + std::string string; + std::vector shardColumns; + }; + ViewsItem viewsItem; + std::vector views; + }; + SchemasItem schemasItem; + std::vector schemas; + struct BlackViewRulesItem { + struct ObjectMapping { + std::string mappedName; + std::string name; + }; + ObjectMapping objectMapping; + struct SchemaMapping { + std::string mappedName; + std::string name; + }; + SchemaMapping schemaMapping; + }; + BlackViewRulesItem blackViewRulesItem; + std::vector blackViewRules; + struct DatabasesBlackItem { + std::string mappedName; + struct SpecificViewsItem { + std::string mappedName; + std::string string; + std::vector filterColumns; + struct AdbTableSchema { + std::string string; + std::vector primaryKeys; + std::string partitionStatement; + std::string partitionLifeCycle; + std::string string; + std::vector distributedKeys; + }; + AdbTableSchema adbTableSchema; + std::string name; + std::string whereClause; + std::string id; + std::string string; + std::vector shardColumns; + }; + SpecificViewsItem specificViewsItem; + std::vector specificViews; + struct TablesItem { + std::string mappedName; + std::string string; + std::vector filterColumns; + struct AdbTableSchema { + std::string string; + std::vector primaryKeys; + std::string partitionStatement; + std::string partitionLifeCycle; + std::string string; + std::vector distributedKeys; + }; + AdbTableSchema adbTableSchema; + std::string name; + std::string whereClause; + std::string id; + std::string string; + std::vector shardColumns; + }; + TablesItem tablesItem; + std::vector tables; + std::string clusterName; + std::string name; + std::string tenantName; + std::string id; + struct SpecificTablesItem { + std::string mappedName; + std::string string; + std::vector filterColumns; + struct AdbTableSchema { + std::string string; + std::vector primaryKeys; + std::string partitionStatement; + std::string partitionLifeCycle; + std::string string; + std::vector distributedKeys; + }; + AdbTableSchema adbTableSchema; + std::string name; + std::string whereClause; + std::string id; + std::string string; + std::vector shardColumns; + }; + SpecificTablesItem specificTablesItem; + std::vector specificTables; + struct ViewsItem { + std::string mappedName; + std::string string; + std::vector filterColumns; + struct AdbTableSchema { + std::string string; + std::vector primaryKeys; + std::string partitionStatement; + std::string partitionLifeCycle; + std::string string; + std::vector distributedKeys; + }; + AdbTableSchema adbTableSchema; + std::string name; + std::string whereClause; + std::string id; + std::string string; + std::vector shardColumns; + }; + ViewsItem viewsItem; + std::vector views; + }; + DatabasesBlackItem databasesBlackItem; + std::vector databasesBlack; + struct WhiteTableRulesItem { + struct ObjectMapping { + std::string mappedName; + std::string name; + }; + ObjectMapping objectMapping; + struct SchemaMapping { + std::string mappedName; + std::string name; + }; + SchemaMapping schemaMapping; + }; + WhiteTableRulesItem whiteTableRulesItem; + std::vector whiteTableRules; + struct WhiteViewRulesItem { + struct ObjectMapping { + std::string mappedName; + std::string name; + }; + ObjectMapping objectMapping; + struct SchemaMapping { + std::string mappedName; + std::string name; + }; + SchemaMapping schemaMapping; + }; + WhiteViewRulesItem whiteViewRulesItem; + std::vector whiteViewRules; + std::string string; + std::vector tableAndViewWhiteList; + }; CreateProjectModifyRecordsRequest(); ~CreateProjectModifyRecordsRequest(); std::vector getDatabases() const; void setDatabases(const std::vector &databases); + TransferMapping getTransferMapping() const; + void setTransferMapping(const TransferMapping &transferMapping); std::string getId() const; void setId(const std::string &id); private: std::vector databases_; + TransferMapping transferMapping_; std::string id_; }; } // namespace Model diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateProjectRequest.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateProjectRequest.h index 28124d43e..79c432613 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateProjectRequest.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateProjectRequest.h @@ -29,10 +29,14 @@ namespace Model { class ALIBABACLOUD_OCEANBASEPRO_EXPORT CreateProjectRequest : public RpcServiceRequest { public: struct FullTransferConfig { + int indexDDLConcurrencyLimit; + std::string hbaseObjMigMode; bool nonePkUkTruncateDstTable; int throttleRps; std::string fullVerifySpeedMode; int writeWorkerNum; + std::string hbaseObjCheckMode; + int maxConcurrentIndexDDLs; int readWorkerNum; std::string fullTransferSpeedMode; bool allowDestTableNotEmpty; @@ -67,6 +71,12 @@ public: std::string mappedName; std::string string; std::vector filterColumns; + struct ObkvPartitionConfig { + std::string virtualColumn; + std::string partitionType; + int partitionSize; + }; + ObkvPartitionConfig obkvPartitionConfig; struct AdbTableSchema { std::string string; std::vector primaryKeys; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateTenantUserRequest.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateTenantUserRequest.h index b64cad12f..c6474091a 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateTenantUserRequest.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateTenantUserRequest.h @@ -36,6 +36,8 @@ public: void setDescription(const std::string &description); std::string getUserPassword() const; void setUserPassword(const std::string &userPassword); + std::string getGlobalPermissions() const; + void setGlobalPermissions(const std::string &globalPermissions); std::string getTenantId() const; void setTenantId(const std::string &tenantId); std::string getEncryptionType() const; @@ -51,6 +53,7 @@ private: std::string roles_; std::string description_; std::string userPassword_; + std::string globalPermissions_; std::string tenantId_; std::string encryptionType_; std::string userType_; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateTenantUserResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateTenantUserResult.h index deb715db1..adb1aea50 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateTenantUserResult.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateTenantUserResult.h @@ -40,6 +40,7 @@ namespace AlibabaCloud std::string database; }; std::string userName; + std::string globalPermissions; std::vector roles; std::string userType; std::string userStatus; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeDataBackupSetResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeDataBackupSetResult.h index e6dab84a2..66fafc804 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeDataBackupSetResult.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeDataBackupSetResult.h @@ -75,7 +75,7 @@ namespace AlibabaCloud int dataSize; int dataVersion; std::vector backupResults; - int setId; + std::string setId; }; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceAvailableZonesRequest.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceAvailableZonesRequest.h new file mode 100644 index 000000000..df4721e7c --- /dev/null +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceAvailableZonesRequest.h @@ -0,0 +1,42 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBEINSTANCEAVAILABLEZONESREQUEST_H_ +#define ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBEINSTANCEAVAILABLEZONESREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace OceanBasePro { +namespace Model { +class ALIBABACLOUD_OCEANBASEPRO_EXPORT DescribeInstanceAvailableZonesRequest : public RpcServiceRequest { +public: + DescribeInstanceAvailableZonesRequest(); + ~DescribeInstanceAvailableZonesRequest(); + std::string getInstanceId() const; + void setInstanceId(const std::string &instanceId); + +private: + std::string instanceId_; +}; +} // namespace Model +} // namespace OceanBasePro +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBEINSTANCEAVAILABLEZONESREQUEST_H_ diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceAvailableZonesResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceAvailableZonesResult.h new file mode 100644 index 000000000..821018fbf --- /dev/null +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceAvailableZonesResult.h @@ -0,0 +1,58 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBEINSTANCEAVAILABLEZONESRESULT_H_ +#define ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBEINSTANCEAVAILABLEZONESRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace OceanBasePro + { + namespace Model + { + class ALIBABACLOUD_OCEANBASEPRO_EXPORT DescribeInstanceAvailableZonesResult : public ServiceResult + { + public: + struct ZoneListItem + { + std::string replicateZoneIndex; + std::string zone; + bool isInCluster; + std::string logicalZoneName; + }; + + + DescribeInstanceAvailableZonesResult(); + explicit DescribeInstanceAvailableZonesResult(const std::string &payload); + ~DescribeInstanceAvailableZonesResult(); + std::vector getZoneList()const; + + protected: + void parse(const std::string &payload); + private: + std::vector zoneList_; + + }; + } + } +} +#endif // !ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBEINSTANCEAVAILABLEZONESRESULT_H_ \ No newline at end of file diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceCreatableZoneResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceCreatableZoneResult.h index b7e4c0d6c..211a85f09 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceCreatableZoneResult.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceCreatableZoneResult.h @@ -34,8 +34,11 @@ namespace AlibabaCloud public: struct ZoneListItem { + long replicateZoneIndex; bool isInCluster; std::string zone; + std::string logicalZoneName; + std::string fullCopyId; }; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceRequest.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceRequest.h index 4cdb159c6..241dd8557 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceRequest.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceRequest.h @@ -32,14 +32,11 @@ public: ~DescribeInstanceRequest(); int getPageNumber() const; void setPageNumber(int pageNumber); - std::string getMaxConnectionLimit() const; - void setMaxConnectionLimit(const std::string &maxConnectionLimit); std::string getInstanceId() const; void setInstanceId(const std::string &instanceId); private: int pageNumber_; - std::string maxConnectionLimit_; std::string instanceId_; }; } // namespace Model diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceSSLRequest.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceSSLRequest.h index 8997184b4..fad3ae744 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceSSLRequest.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceSSLRequest.h @@ -32,9 +32,12 @@ public: ~DescribeInstanceSSLRequest(); std::string getInstanceId() const; void setInstanceId(const std::string &instanceId); + std::string getTenantId() const; + void setTenantId(const std::string &tenantId); private: std::string instanceId_; + std::string tenantId_; }; } // namespace Model } // namespace OceanBasePro diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceSSLResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceSSLResult.h index 6adab50a9..1c28816ec 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceSSLResult.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceSSLResult.h @@ -37,8 +37,10 @@ namespace AlibabaCloud std::string status; std::string forceSSL; std::string enableSSL; + std::string tenantId; std::string validPeriod; std::string instanceId; + std::string autoUpdate; std::string caUrl; bool forceSSLSupport; }; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceSummaryResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceSummaryResult.h index 8999454cf..58eea0b17 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceSummaryResult.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceSummaryResult.h @@ -36,12 +36,12 @@ namespace AlibabaCloud { struct RegionalInstanceSummaryLis { - std::string immediatelyExpiredInstancesCount; - std::string recentCreatedInstancesCount; - std::string expiredInstancesCount; + long immediatelyExpiredInstancesCount; + long recentCreatedInstancesCount; + long expiredInstancesCount; std::string region; - std::string runningInstancesCount; - std::string totalInstancesCount; + long runningInstancesCount; + long totalInstancesCount; }; long immediatelyExpiredInstancesCount; long tenantInstancesCount; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceTopologyResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceTopologyResult.h index 41414430b..8ff9d2da1 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceTopologyResult.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceTopologyResult.h @@ -51,6 +51,7 @@ namespace AlibabaCloud std::string unitStatus; bool manualMigrate; }; + std::string readOnlyReplicaType; std::string tenantZoneRole; std::string replicaType; bool isPrimaryTenantZone; @@ -107,6 +108,7 @@ namespace AlibabaCloud Cpu cpu; }; NodeResource nodeResource; + std::string readOnlyReplicaType; std::string replicaType; std::string nodeId; std::string logicalZone; @@ -146,11 +148,13 @@ namespace AlibabaCloud }; int zoneLogicalId; std::string status; + std::string readOnlyReplicaType; ReplicaResource replicaResource; int nodeNum; std::string replicaType; std::string logicalZone; std::string zoneRegionName; + long onlineNodeNum; std::string zoneLogicalName; }; std::vector tenants; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstancesRequest.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstancesRequest.h index a4c43ce63..8221398fb 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstancesRequest.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstancesRequest.h @@ -36,20 +36,23 @@ public: void setPageNumber(int pageNumber); std::string getResourceGroupId() const; void setResourceGroupId(const std::string &resourceGroupId); + int getPageSize() const; + void setPageSize(int pageSize); std::string getInstanceId() const; void setInstanceId(const std::string &instanceId); std::string getInstanceName() const; void setInstanceName(const std::string &instanceName); - int getPageSize() const; - void setPageSize(int pageSize); + bool getWithOBCloudInstances() const; + void setWithOBCloudInstances(bool withOBCloudInstances); private: std::string searchKey_; int pageNumber_; std::string resourceGroupId_; + int pageSize_; std::string instanceId_; std::string instanceName_; - int pageSize_; + bool withOBCloudInstances_; }; } // namespace Model } // namespace OceanBasePro diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstancesResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstancesResult.h index 4f1f5e110..35d54e0b0 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstancesResult.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstancesResult.h @@ -80,7 +80,23 @@ namespace AlibabaCloud double upperThreshold; bool autoScale; }; + struct MigrationInfo + { + struct CheckResult + { + std::string subModule; + std::string codeName; + std::string moduleName; + std::string level; + std::string module; + std::string code; + std::string subModuleName; + }; + CheckResult checkResult; + bool migratable; + }; std::string deployType; + MigrationInfo migrationInfo; std::string resourceGroupId; std::string specType; bool enableUpgradeNodes; @@ -93,15 +109,17 @@ namespace AlibabaCloud std::string cpuArchitecture; std::string version; std::string commodityCode; - std::string diskSize; + long diskSize; std::string instanceRole; std::string instanceType; std::string maintainTime; std::string obRpmVersion; + std::string replicaMode; std::string instanceId; std::string createTime; Resource resource; std::string instanceClass; + bool migratable; std::string payType; std::string instanceName; std::string series; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeOasAnomalySQLListResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeOasAnomalySQLListResult.h index 58afdf9b5..a2803cc1e 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeOasAnomalySQLListResult.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeOasAnomalySQLListResult.h @@ -40,7 +40,7 @@ namespace AlibabaCloud double executions; double sumDbTime; std::string userName; - double lastExecutedTime; + std::string lastExecutedTime; float avgRetryCount; double avgGetPlanTime; double cpuTime; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeOasSQLHistoryListResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeOasSQLHistoryListResult.h index 2fc6b71f3..851d5e720 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeOasSQLHistoryListResult.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeOasSQLHistoryListResult.h @@ -98,6 +98,7 @@ namespace AlibabaCloud double avgScheduleTime; double maxConcurrencyWaitTime; double missPlanPercentage; + std::string waitEvent; double retCode4012Count; double avgElapsedTime; double failPercentage; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeOasSQLPlansResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeOasSQLPlansResult.h index 609ddebd8..008ff303a 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeOasSQLPlansResult.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeOasSQLPlansResult.h @@ -65,6 +65,7 @@ namespace AlibabaCloud std::string firstLoadTime; double avgRowProcessed; std::string planUnionHash; + std::string sqlText; long mergedVersion; bool hitDiagnosis; std::string sqlId; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeOasTopSQLListRequest.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeOasTopSQLListRequest.h index b9f3cce12..dd782011e 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeOasTopSQLListRequest.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeOasTopSQLListRequest.h @@ -32,6 +32,8 @@ public: ~DescribeOasTopSQLListRequest(); std::string getStartTime() const; void setStartTime(const std::string &startTime); + std::string getCustomColumns() const; + void setCustomColumns(const std::string &customColumns); std::string getSearchRule() const; void setSearchRule(const std::string &searchRule); bool getMergeDynamicSql() const; @@ -65,6 +67,7 @@ public: private: std::string startTime_; + std::string customColumns_; std::string searchRule_; bool mergeDynamicSql_; bool dynamicSql_; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeOasTopSQLListResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeOasTopSQLListResult.h index 9913f5aba..01d2cc521 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeOasTopSQLListResult.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeOasTopSQLListResult.h @@ -34,6 +34,11 @@ namespace AlibabaCloud public: struct DataItem { + struct CustomColumns + { + std::string expression; + std::string value; + }; struct SqlListItem { long executions; @@ -126,6 +131,7 @@ namespace AlibabaCloud double avgUserIoWaitTime; double retryCount; long retCode6002Count; + std::string obDbId; double missPlans; long retCode5167Count; std::string sqlType; @@ -161,6 +167,7 @@ namespace AlibabaCloud double avgBlockIndexCacheHit; double sumElapsedTime; double avgBloomFilterCacheHit; + CustomColumns customColumns; double avgReturnRows; double avgPartitionCount; double failCount; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeOutlineBindingResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeOutlineBindingResult.h index 08006c476..561d7ebde 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeOutlineBindingResult.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeOutlineBindingResult.h @@ -36,7 +36,9 @@ namespace AlibabaCloud { std::string tableName; int maxConcurrent; + std::string sqlText; long outlineId; + long sqlTextConcurrentNum; std::string bindPlan; std::string bindIndex; }; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeParametersHistoryResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeParametersHistoryResult.h index 6d750bd2e..7ca10ed6e 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeParametersHistoryResult.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeParametersHistoryResult.h @@ -32,7 +32,7 @@ namespace AlibabaCloud class ALIBABACLOUD_OCEANBASEPRO_EXPORT DescribeParametersHistoryResult : public ServiceResult { public: - struct Data + struct Respond { struct ParametersItem { @@ -45,7 +45,7 @@ namespace AlibabaCloud std::string name; }; int totalCount; - std::vector parameters; + std::vector parameters; int pageNumber; }; @@ -53,12 +53,12 @@ namespace AlibabaCloud DescribeParametersHistoryResult(); explicit DescribeParametersHistoryResult(const std::string &payload); ~DescribeParametersHistoryResult(); - std::vector getRespond()const; + Respond getRespond()const; protected: void parse(const std::string &payload); private: - std::vector respond_; + Respond respond_; }; } diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeProcessStatsCompositionRequest.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeProcessStatsCompositionRequest.h index e91f3038a..3dcb6e28c 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeProcessStatsCompositionRequest.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeProcessStatsCompositionRequest.h @@ -32,6 +32,8 @@ public: ~DescribeProcessStatsCompositionRequest(); std::string getUId() const; void setUId(const std::string &uId); + bool getMergeDynamicSql() const; + void setMergeDynamicSql(bool mergeDynamicSql); std::string getSqlText() const; void setSqlText(const std::string &sqlText); std::string getClientIp() const; @@ -49,6 +51,7 @@ public: private: std::string uId_; + bool mergeDynamicSql_; std::string sqlText_; std::string clientIp_; std::string tenantId_; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeProcessStatsCompositionResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeProcessStatsCompositionResult.h index eaaedbadd..a55e8164a 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeProcessStatsCompositionResult.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeProcessStatsCompositionResult.h @@ -63,17 +63,59 @@ namespace AlibabaCloud }; struct AllProcessListItem { + struct ProcessSqlListsItem + { + struct ProcessSqlListItem + { + std::string status; + std::string dynamicSql; + std::string user; + long executeTime; + std::string proxySessId; + std::string serverIp; + std::string planId; + std::string sqlText; + long cpuTime; + std::string clientIp; + std::string sqlId; + std::string tenantId; + std::string command; + std::string database; + std::string traceId; + long sessionId; + }; + std::string status; + std::string dynamicSql; + std::string user; + long executeTime; + std::string proxySessId; + std::string serverIp; + std::string planId; + std::string sqlText; + long cpuTime; + std::string clientIp; + std::string sqlId; + std::vector processSqlList; + std::string tenantId; + std::string command; + std::string database; + std::string traceId; + long sessionId; + }; std::string status; + std::string dynamicSql; std::string user; long executeTime; std::string proxySessId; std::string serverIp; std::string planId; std::string sqlText; + std::vector processSqlLists; long cpuTime; std::string clientIp; std::string sqlId; std::string tenantId; + std::string serverSn; std::string command; std::string database; std::string traceId; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeProxyServiceRequest.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeProxyServiceRequest.h new file mode 100644 index 000000000..250cfd558 --- /dev/null +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeProxyServiceRequest.h @@ -0,0 +1,42 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBEPROXYSERVICEREQUEST_H_ +#define ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBEPROXYSERVICEREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace OceanBasePro { +namespace Model { +class ALIBABACLOUD_OCEANBASEPRO_EXPORT DescribeProxyServiceRequest : public RpcServiceRequest { +public: + DescribeProxyServiceRequest(); + ~DescribeProxyServiceRequest(); + std::string getInstanceId() const; + void setInstanceId(const std::string &instanceId); + +private: + std::string instanceId_; +}; +} // namespace Model +} // namespace OceanBasePro +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBEPROXYSERVICEREQUEST_H_ diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeProxyServiceResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeProxyServiceResult.h new file mode 100644 index 000000000..f75628e33 --- /dev/null +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeProxyServiceResult.h @@ -0,0 +1,67 @@ +/* + * 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_OCEANBASEPRO_MODEL_DESCRIBEPROXYSERVICERESULT_H_ +#define ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBEPROXYSERVICERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace OceanBasePro + { + namespace Model + { + class ALIBABACLOUD_OCEANBASEPRO_EXPORT DescribeProxyServiceResult : public ServiceResult + { + public: + struct Data + { + std::string status; + long currentEndpointNum; + std::string zone; + long unitNum; + std::string createTime; + std::string proxyVersion; + std::string proxyClusterId; + long unitNumLimit; + long endpointNumQuota; + std::string unitSpec; + std::string expireTime; + std::string proxyServiceVersion; + std::string proxyMode; + }; + + + DescribeProxyServiceResult(); + explicit DescribeProxyServiceResult(const std::string &payload); + ~DescribeProxyServiceResult(); + Data getData()const; + + protected: + void parse(const std::string &payload); + private: + Data data_; + + }; + } + } +} +#endif // !ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBEPROXYSERVICERESULT_H_ \ No newline at end of file diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeSampleSqlRawTextsRequest.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeSampleSqlRawTextsRequest.h index 153061e7c..cf7449c87 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeSampleSqlRawTextsRequest.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeSampleSqlRawTextsRequest.h @@ -34,6 +34,8 @@ public: void setTraceId(const std::string &traceId); std::string getStartTime() const; void setStartTime(const std::string &startTime); + bool getDynamicSql() const; + void setDynamicSql(bool dynamicSql); std::string getTenantId() const; void setTenantId(const std::string &tenantId); std::string getLimit() const; @@ -50,6 +52,7 @@ public: private: std::string traceId_; std::string startTime_; + bool dynamicSql_; std::string tenantId_; std::string limit_; std::string sqlId_; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeSqlAuditStatRequest.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeSqlAuditStatRequest.h new file mode 100644 index 000000000..161773239 --- /dev/null +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeSqlAuditStatRequest.h @@ -0,0 +1,57 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBESQLAUDITSTATREQUEST_H_ +#define ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBESQLAUDITSTATREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace OceanBasePro { +namespace Model { +class ALIBABACLOUD_OCEANBASEPRO_EXPORT DescribeSqlAuditStatRequest : public RpcServiceRequest { +public: + DescribeSqlAuditStatRequest(); + ~DescribeSqlAuditStatRequest(); + std::string getStartTime() const; + void setStartTime(const std::string &startTime); + int getPageNumber() const; + void setPageNumber(int pageNumber); + std::string getTenantId() const; + void setTenantId(const std::string &tenantId); + int getPageSize() const; + void setPageSize(int pageSize); + std::string getEndTime() const; + void setEndTime(const std::string &endTime); + std::string getInstanceId() const; + void setInstanceId(const std::string &instanceId); + +private: + std::string startTime_; + int pageNumber_; + std::string tenantId_; + int pageSize_; + std::string endTime_; + std::string instanceId_; +}; +} // namespace Model +} // namespace OceanBasePro +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBESQLAUDITSTATREQUEST_H_ diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeSqlAuditStatResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeSqlAuditStatResult.h new file mode 100644 index 000000000..1dd1662df --- /dev/null +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeSqlAuditStatResult.h @@ -0,0 +1,71 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBESQLAUDITSTATRESULT_H_ +#define ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBESQLAUDITSTATRESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace OceanBasePro + { + namespace Model + { + class ALIBABACLOUD_OCEANBASEPRO_EXPORT DescribeSqlAuditStatResult : public ServiceResult + { + public: + struct DataItem + { + std::string userName; + long totalScanRows; + std::string instanceId; + double executeTime; + std::string databaseName; + long totalSucceed; + double returnRows; + std::string operatorType; + std::string sqlId; + long totalAffectRows; + std::string sqlStatement; + std::string tenantId; + long totalFailed; + double scanRows; + long totalReturnRows; + std::string userClientIp; + double affectRows; + }; + + + DescribeSqlAuditStatResult(); + explicit DescribeSqlAuditStatResult(const std::string &payload); + ~DescribeSqlAuditStatResult(); + std::vector getData()const; + + protected: + void parse(const std::string &payload); + private: + std::vector data_; + + }; + } + } +} +#endif // !ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBESQLAUDITSTATRESULT_H_ \ No newline at end of file diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantResult.h index c95468598..21738ae2e 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantResult.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantResult.h @@ -119,6 +119,7 @@ namespace AlibabaCloud std::string proxyClusterId; int intranetPort; long parallelQueryDegree; + int internetSqlPort; int internetRpcPort; std::string connectionReplicaType; std::string internetAddressStatus; @@ -140,7 +141,8 @@ namespace AlibabaCloud { struct TenantZoneReplicasItem { - std::string zoneNodes; + std::string readOnlyReplicaType; + long zoneNodes; int zoneCopyId; std::string logicZoneName; std::string readOnlyCopyId; @@ -153,6 +155,7 @@ namespace AlibabaCloud std::string region; }; std::string deployType; + std::string parameterTemplate; ReadOnlyResource readOnlyResource; std::string description; long maxParallelQueryDegree; @@ -189,6 +192,7 @@ namespace AlibabaCloud std::string timeZone; TenantResource tenantResource; std::string vpcId; + std::string tenantMaxConnections; }; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantUserRolesRequest.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantUserRolesRequest.h index 5a8d20626..a0d3ffca1 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantUserRolesRequest.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantUserRolesRequest.h @@ -30,10 +30,13 @@ class ALIBABACLOUD_OCEANBASEPRO_EXPORT DescribeTenantUserRolesRequest : public R public: DescribeTenantUserRolesRequest(); ~DescribeTenantUserRolesRequest(); + std::string getInstanceId() const; + void setInstanceId(const std::string &instanceId); std::string getTenantId() const; void setTenantId(const std::string &tenantId); private: + std::string instanceId_; std::string tenantId_; }; } // namespace Model diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantUsersResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantUsersResult.h index 7546c8fc2..12296df6b 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantUsersResult.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantUsersResult.h @@ -46,6 +46,7 @@ namespace AlibabaCloud std::string description; std::string userName; std::string instanceId; + std::string globalPermissions; std::string userType; std::string userStatus; }; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantsResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantsResult.h index ca1a8cd0f..4ced7b434 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantsResult.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantsResult.h @@ -37,6 +37,7 @@ namespace AlibabaCloud std::string status; std::string deployType; int unitCpu; + std::string parameterTemplate; std::string description; std::string tenantName; int unitNum; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceSSLRequest.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceSSLRequest.h index 87c46ad1e..b6f3920d6 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceSSLRequest.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceSSLRequest.h @@ -34,10 +34,13 @@ public: void setInstanceId(const std::string &instanceId); std::string getEnableSSL() const; void setEnableSSL(const std::string &enableSSL); + std::string getTenantId() const; + void setTenantId(const std::string &tenantId); private: std::string instanceId_; std::string enableSSL_; + std::string tenantId_; }; } // namespace Model } // namespace OceanBasePro diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceSSLResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceSSLResult.h index 2ebc50bee..a8f0e55ea 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceSSLResult.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceSSLResult.h @@ -35,6 +35,7 @@ namespace AlibabaCloud struct InstanceSSL { std::string enableSSL; + std::string tenantId; std::string instanceId; }; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyTenantUserRolesRequest.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyTenantUserRolesRequest.h index 2cf419bea..1016a3787 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyTenantUserRolesRequest.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyTenantUserRolesRequest.h @@ -30,21 +30,27 @@ class ALIBABACLOUD_OCEANBASEPRO_EXPORT ModifyTenantUserRolesRequest : public Rpc public: ModifyTenantUserRolesRequest(); ~ModifyTenantUserRolesRequest(); + std::string getUserType() const; + void setUserType(const std::string &userType); std::string getUserRole() const; void setUserRole(const std::string &userRole); std::string getInstanceId() const; void setInstanceId(const std::string &instanceId); std::string getModifyType() const; void setModifyType(const std::string &modifyType); + std::string getGlobalPermissions() const; + void setGlobalPermissions(const std::string &globalPermissions); std::string getTenantId() const; void setTenantId(const std::string &tenantId); std::string getUserName() const; void setUserName(const std::string &userName); private: + std::string userType_; std::string userRole_; std::string instanceId_; std::string modifyType_; + std::string globalPermissions_; std::string tenantId_; std::string userName_; }; diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/RemoveStandbyInstanceRequest.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/RemoveStandbyInstanceRequest.h new file mode 100644 index 000000000..6f420e899 --- /dev/null +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/RemoveStandbyInstanceRequest.h @@ -0,0 +1,48 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef ALIBABACLOUD_OCEANBASEPRO_MODEL_REMOVESTANDBYINSTANCEREQUEST_H_ +#define ALIBABACLOUD_OCEANBASEPRO_MODEL_REMOVESTANDBYINSTANCEREQUEST_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud { +namespace OceanBasePro { +namespace Model { +class ALIBABACLOUD_OCEANBASEPRO_EXPORT RemoveStandbyInstanceRequest : public RpcServiceRequest { +public: + RemoveStandbyInstanceRequest(); + ~RemoveStandbyInstanceRequest(); + bool getForced() const; + void setForced(bool forced); + std::string getInstanceId() const; + void setInstanceId(const std::string &instanceId); + std::string getTargetInstanceId() const; + void setTargetInstanceId(const std::string &targetInstanceId); + +private: + bool forced_; + std::string instanceId_; + std::string targetInstanceId_; +}; +} // namespace Model +} // namespace OceanBasePro +} // namespace AlibabaCloud +#endif // !ALIBABACLOUD_OCEANBASEPRO_MODEL_REMOVESTANDBYINSTANCEREQUEST_H_ diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/RemoveStandbyInstanceResult.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/RemoveStandbyInstanceResult.h new file mode 100644 index 000000000..4b55d8384 --- /dev/null +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/RemoveStandbyInstanceResult.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_OCEANBASEPRO_MODEL_REMOVESTANDBYINSTANCERESULT_H_ +#define ALIBABACLOUD_OCEANBASEPRO_MODEL_REMOVESTANDBYINSTANCERESULT_H_ + +#include +#include +#include +#include +#include + +namespace AlibabaCloud +{ + namespace OceanBasePro + { + namespace Model + { + class ALIBABACLOUD_OCEANBASEPRO_EXPORT RemoveStandbyInstanceResult : public ServiceResult + { + public: + + + RemoveStandbyInstanceResult(); + explicit RemoveStandbyInstanceResult(const std::string &payload); + ~RemoveStandbyInstanceResult(); + + protected: + void parse(const std::string &payload); + private: + + }; + } + } +} +#endif // !ALIBABACLOUD_OCEANBASEPRO_MODEL_REMOVESTANDBYINSTANCERESULT_H_ \ No newline at end of file diff --git a/oceanbasepro/include/alibabacloud/oceanbasepro/model/UpdateProjectConfigRequest.h b/oceanbasepro/include/alibabacloud/oceanbasepro/model/UpdateProjectConfigRequest.h index 83d8f75d9..5de275aa4 100644 --- a/oceanbasepro/include/alibabacloud/oceanbasepro/model/UpdateProjectConfigRequest.h +++ b/oceanbasepro/include/alibabacloud/oceanbasepro/model/UpdateProjectConfigRequest.h @@ -42,8 +42,10 @@ public: int incrSyncThreadCount; }; struct FullTransferConfig { + int indexDDLConcurrencyLimit; int throttleRps; int writeWorkerNum; + int maxConcurrentIndexDDLs; int readWorkerNum; int throttleIOPS; }; diff --git a/oceanbasepro/src/OceanBaseProClient.cc b/oceanbasepro/src/OceanBaseProClient.cc index d2f4df38c..f2c4d45f3 100644 --- a/oceanbasepro/src/OceanBaseProClient.cc +++ b/oceanbasepro/src/OceanBaseProClient.cc @@ -339,6 +339,42 @@ OceanBaseProClient::CreateMySqlDataSourceOutcomeCallable OceanBaseProClient::cre return task->get_future(); } +OceanBaseProClient::CreateOasOutlineTaskOutcome OceanBaseProClient::createOasOutlineTask(const CreateOasOutlineTaskRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return CreateOasOutlineTaskOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return CreateOasOutlineTaskOutcome(CreateOasOutlineTaskResult(outcome.result())); + else + return CreateOasOutlineTaskOutcome(outcome.error()); +} + +void OceanBaseProClient::createOasOutlineTaskAsync(const CreateOasOutlineTaskRequest& request, const CreateOasOutlineTaskAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, createOasOutlineTask(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +OceanBaseProClient::CreateOasOutlineTaskOutcomeCallable OceanBaseProClient::createOasOutlineTaskCallable(const CreateOasOutlineTaskRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->createOasOutlineTask(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + OceanBaseProClient::CreateOceanBaseDataSourceOutcome OceanBaseProClient::createOceanBaseDataSource(const CreateOceanBaseDataSourceRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -1527,6 +1563,42 @@ OceanBaseProClient::DescribeInstanceOutcomeCallable OceanBaseProClient::describe return task->get_future(); } +OceanBaseProClient::DescribeInstanceAvailableZonesOutcome OceanBaseProClient::describeInstanceAvailableZones(const DescribeInstanceAvailableZonesRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeInstanceAvailableZonesOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeInstanceAvailableZonesOutcome(DescribeInstanceAvailableZonesResult(outcome.result())); + else + return DescribeInstanceAvailableZonesOutcome(outcome.error()); +} + +void OceanBaseProClient::describeInstanceAvailableZonesAsync(const DescribeInstanceAvailableZonesRequest& request, const DescribeInstanceAvailableZonesAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeInstanceAvailableZones(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +OceanBaseProClient::DescribeInstanceAvailableZonesOutcomeCallable OceanBaseProClient::describeInstanceAvailableZonesCallable(const DescribeInstanceAvailableZonesRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeInstanceAvailableZones(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + OceanBaseProClient::DescribeInstanceCreatableZoneOutcome OceanBaseProClient::describeInstanceCreatableZone(const DescribeInstanceCreatableZoneRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -2427,6 +2499,42 @@ OceanBaseProClient::DescribeProjectStepsOutcomeCallable OceanBaseProClient::desc return task->get_future(); } +OceanBaseProClient::DescribeProxyServiceOutcome OceanBaseProClient::describeProxyService(const DescribeProxyServiceRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeProxyServiceOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeProxyServiceOutcome(DescribeProxyServiceResult(outcome.result())); + else + return DescribeProxyServiceOutcome(outcome.error()); +} + +void OceanBaseProClient::describeProxyServiceAsync(const DescribeProxyServiceRequest& request, const DescribeProxyServiceAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeProxyService(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +OceanBaseProClient::DescribeProxyServiceOutcomeCallable OceanBaseProClient::describeProxyServiceCallable(const DescribeProxyServiceRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeProxyService(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + OceanBaseProClient::DescribeRecommendIndexOutcome OceanBaseProClient::describeRecommendIndex(const DescribeRecommendIndexRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -2859,6 +2967,42 @@ OceanBaseProClient::DescribeSlowSQLListOutcomeCallable OceanBaseProClient::descr return task->get_future(); } +OceanBaseProClient::DescribeSqlAuditStatOutcome OceanBaseProClient::describeSqlAuditStat(const DescribeSqlAuditStatRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return DescribeSqlAuditStatOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return DescribeSqlAuditStatOutcome(DescribeSqlAuditStatResult(outcome.result())); + else + return DescribeSqlAuditStatOutcome(outcome.error()); +} + +void OceanBaseProClient::describeSqlAuditStatAsync(const DescribeSqlAuditStatRequest& request, const DescribeSqlAuditStatAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, describeSqlAuditStat(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +OceanBaseProClient::DescribeSqlAuditStatOutcomeCallable OceanBaseProClient::describeSqlAuditStatCallable(const DescribeSqlAuditStatRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->describeSqlAuditStat(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + OceanBaseProClient::DescribeStandbyCreateModeOutcome OceanBaseProClient::describeStandbyCreateMode(const DescribeStandbyCreateModeRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); @@ -4551,6 +4695,42 @@ OceanBaseProClient::ReleaseWorkerInstanceOutcomeCallable OceanBaseProClient::rel return task->get_future(); } +OceanBaseProClient::RemoveStandbyInstanceOutcome OceanBaseProClient::removeStandbyInstance(const RemoveStandbyInstanceRequest &request) const +{ + auto endpointOutcome = endpointProvider_->getEndpoint(); + if (!endpointOutcome.isSuccess()) + return RemoveStandbyInstanceOutcome(endpointOutcome.error()); + + auto outcome = makeRequest(endpointOutcome.result(), request); + + if (outcome.isSuccess()) + return RemoveStandbyInstanceOutcome(RemoveStandbyInstanceResult(outcome.result())); + else + return RemoveStandbyInstanceOutcome(outcome.error()); +} + +void OceanBaseProClient::removeStandbyInstanceAsync(const RemoveStandbyInstanceRequest& request, const RemoveStandbyInstanceAsyncHandler& handler, const std::shared_ptr& context) const +{ + auto fn = [this, request, handler, context]() + { + handler(this, request, removeStandbyInstance(request), context); + }; + + asyncExecute(new Runnable(fn)); +} + +OceanBaseProClient::RemoveStandbyInstanceOutcomeCallable OceanBaseProClient::removeStandbyInstanceCallable(const RemoveStandbyInstanceRequest &request) const +{ + auto task = std::make_shared>( + [this, request]() + { + return this->removeStandbyInstance(request); + }); + + asyncExecute(new Runnable([task]() { (*task)(); })); + return task->get_future(); +} + OceanBaseProClient::ResumeProjectOutcome OceanBaseProClient::resumeProject(const ResumeProjectRequest &request) const { auto endpointOutcome = endpointProvider_->getEndpoint(); diff --git a/oceanbasepro/src/model/BatchKillProcessListRequest.cc b/oceanbasepro/src/model/BatchKillProcessListRequest.cc index 671a890b9..0ae15e5be 100644 --- a/oceanbasepro/src/model/BatchKillProcessListRequest.cc +++ b/oceanbasepro/src/model/BatchKillProcessListRequest.cc @@ -34,6 +34,15 @@ void BatchKillProcessListRequest::setSessionList(const std::string &sessionList) setBodyParameter(std::string("SessionList"), sessionList); } +bool BatchKillProcessListRequest::getByObSessionId() const { + return byObSessionId_; +} + +void BatchKillProcessListRequest::setByObSessionId(bool byObSessionId) { + byObSessionId_ = byObSessionId; + setBodyParameter(std::string("ByObSessionId"), byObSessionId ? "true" : "false"); +} + std::string BatchKillProcessListRequest::getInstanceId() const { return instanceId_; } diff --git a/oceanbasepro/src/model/CreateOasOutlineTaskRequest.cc b/oceanbasepro/src/model/CreateOasOutlineTaskRequest.cc new file mode 100644 index 000000000..5b9733bf6 --- /dev/null +++ b/oceanbasepro/src/model/CreateOasOutlineTaskRequest.cc @@ -0,0 +1,171 @@ +/* + * 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::OceanBasePro::Model::CreateOasOutlineTaskRequest; + +CreateOasOutlineTaskRequest::CreateOasOutlineTaskRequest() + : RpcServiceRequest("oceanbasepro", "2019-09-01", "CreateOasOutlineTask") { + setMethod(HttpRequest::Method::Post); +} + +CreateOasOutlineTaskRequest::~CreateOasOutlineTaskRequest() {} + +std::string CreateOasOutlineTaskRequest::getStartTime() const { + return startTime_; +} + +void CreateOasOutlineTaskRequest::setStartTime(const std::string &startTime) { + startTime_ = startTime; + setBodyParameter(std::string("StartTime"), startTime); +} + +std::string CreateOasOutlineTaskRequest::getUId() const { + return uId_; +} + +void CreateOasOutlineTaskRequest::setUId(const std::string &uId) { + uId_ = uId; + setBodyParameter(std::string("UId"), uId); +} + +bool CreateOasOutlineTaskRequest::getDynamicSql() const { + return dynamicSql_; +} + +void CreateOasOutlineTaskRequest::setDynamicSql(bool dynamicSql) { + dynamicSql_ = dynamicSql; + setBodyParameter(std::string("DynamicSql"), dynamicSql ? "true" : "false"); +} + +std::string CreateOasOutlineTaskRequest::getSqlText() const { + return sqlText_; +} + +void CreateOasOutlineTaskRequest::setSqlText(const std::string &sqlText) { + sqlText_ = sqlText; + setBodyParameter(std::string("SqlText"), sqlText); +} + +bool CreateOasOutlineTaskRequest::getBySqlId() const { + return bySqlId_; +} + +void CreateOasOutlineTaskRequest::setBySqlId(bool bySqlId) { + bySqlId_ = bySqlId; + setBodyParameter(std::string("BySqlId"), bySqlId ? "true" : "false"); +} + +int CreateOasOutlineTaskRequest::getMaxConcurrent() const { + return maxConcurrent_; +} + +void CreateOasOutlineTaskRequest::setMaxConcurrent(int maxConcurrent) { + maxConcurrent_ = maxConcurrent; + setBodyParameter(std::string("MaxConcurrent"), std::to_string(maxConcurrent)); +} + +std::string CreateOasOutlineTaskRequest::getTenantId() const { + return tenantId_; +} + +void CreateOasOutlineTaskRequest::setTenantId(const std::string &tenantId) { + tenantId_ = tenantId; + setBodyParameter(std::string("TenantId"), tenantId); +} + +std::string CreateOasOutlineTaskRequest::getStatementId() const { + return statementId_; +} + +void CreateOasOutlineTaskRequest::setStatementId(const std::string &statementId) { + statementId_ = statementId; + setBodyParameter(std::string("StatementId"), statementId); +} + +std::string CreateOasOutlineTaskRequest::getTableName() const { + return tableName_; +} + +void CreateOasOutlineTaskRequest::setTableName(const std::string &tableName) { + tableName_ = tableName; + setBodyParameter(std::string("TableName"), tableName); +} + +std::string CreateOasOutlineTaskRequest::getSqlId() const { + return sqlId_; +} + +void CreateOasOutlineTaskRequest::setSqlId(const std::string &sqlId) { + sqlId_ = sqlId; + setBodyParameter(std::string("SqlId"), sqlId); +} + +std::string CreateOasOutlineTaskRequest::getEndTime() const { + return endTime_; +} + +void CreateOasOutlineTaskRequest::setEndTime(const std::string &endTime) { + endTime_ = endTime; + setBodyParameter(std::string("EndTime"), endTime); +} + +std::string CreateOasOutlineTaskRequest::getInstanceId() const { + return instanceId_; +} + +void CreateOasOutlineTaskRequest::setInstanceId(const std::string &instanceId) { + instanceId_ = instanceId; + setBodyParameter(std::string("InstanceId"), instanceId); +} + +std::string CreateOasOutlineTaskRequest::getPlanData() const { + return planData_; +} + +void CreateOasOutlineTaskRequest::setPlanData(const std::string &planData) { + planData_ = planData; + setBodyParameter(std::string("PlanData"), planData); +} + +std::string CreateOasOutlineTaskRequest::getIndexName() const { + return indexName_; +} + +void CreateOasOutlineTaskRequest::setIndexName(const std::string &indexName) { + indexName_ = indexName; + setBodyParameter(std::string("IndexName"), indexName); +} + +std::string CreateOasOutlineTaskRequest::getDatabaseName() const { + return databaseName_; +} + +void CreateOasOutlineTaskRequest::setDatabaseName(const std::string &databaseName) { + databaseName_ = databaseName; + setBodyParameter(std::string("DatabaseName"), databaseName); +} + +bool CreateOasOutlineTaskRequest::getIsConcurrentLimit() const { + return isConcurrentLimit_; +} + +void CreateOasOutlineTaskRequest::setIsConcurrentLimit(bool isConcurrentLimit) { + isConcurrentLimit_ = isConcurrentLimit; + setBodyParameter(std::string("IsConcurrentLimit"), isConcurrentLimit ? "true" : "false"); +} + diff --git a/oceanbasepro/src/model/CreateOasOutlineTaskResult.cc b/oceanbasepro/src/model/CreateOasOutlineTaskResult.cc new file mode 100644 index 000000000..b05307880 --- /dev/null +++ b/oceanbasepro/src/model/CreateOasOutlineTaskResult.cc @@ -0,0 +1,58 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include +#include + +using namespace AlibabaCloud::OceanBasePro; +using namespace AlibabaCloud::OceanBasePro::Model; + +CreateOasOutlineTaskResult::CreateOasOutlineTaskResult() : + ServiceResult() +{} + +CreateOasOutlineTaskResult::CreateOasOutlineTaskResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +CreateOasOutlineTaskResult::~CreateOasOutlineTaskResult() +{} + +void CreateOasOutlineTaskResult::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"; + if(!value["Message"].isNull()) + message_ = value["Message"].asString(); + +} + +std::string CreateOasOutlineTaskResult::getMessage()const +{ + return message_; +} + +bool CreateOasOutlineTaskResult::getSuccess()const +{ + return success_; +} + diff --git a/oceanbasepro/src/model/CreateProjectModifyRecordsRequest.cc b/oceanbasepro/src/model/CreateProjectModifyRecordsRequest.cc index 14441ad3d..9dfa6f3b7 100644 --- a/oceanbasepro/src/model/CreateProjectModifyRecordsRequest.cc +++ b/oceanbasepro/src/model/CreateProjectModifyRecordsRequest.cc @@ -58,6 +58,9 @@ void CreateProjectModifyRecordsRequest::setDatabases(const std::vector + +using AlibabaCloud::OceanBasePro::Model::DescribeInstanceAvailableZonesRequest; + +DescribeInstanceAvailableZonesRequest::DescribeInstanceAvailableZonesRequest() + : RpcServiceRequest("oceanbasepro", "2019-09-01", "DescribeInstanceAvailableZones") { + setMethod(HttpRequest::Method::Post); +} + +DescribeInstanceAvailableZonesRequest::~DescribeInstanceAvailableZonesRequest() {} + +std::string DescribeInstanceAvailableZonesRequest::getInstanceId() const { + return instanceId_; +} + +void DescribeInstanceAvailableZonesRequest::setInstanceId(const std::string &instanceId) { + instanceId_ = instanceId; + setBodyParameter(std::string("InstanceId"), instanceId); +} + diff --git a/oceanbasepro/src/model/DescribeInstanceAvailableZonesResult.cc b/oceanbasepro/src/model/DescribeInstanceAvailableZonesResult.cc new file mode 100644 index 000000000..b03d0b811 --- /dev/null +++ b/oceanbasepro/src/model/DescribeInstanceAvailableZonesResult.cc @@ -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. + */ + +#include +#include + +using namespace AlibabaCloud::OceanBasePro; +using namespace AlibabaCloud::OceanBasePro::Model; + +DescribeInstanceAvailableZonesResult::DescribeInstanceAvailableZonesResult() : + ServiceResult() +{} + +DescribeInstanceAvailableZonesResult::DescribeInstanceAvailableZonesResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeInstanceAvailableZonesResult::~DescribeInstanceAvailableZonesResult() +{} + +void DescribeInstanceAvailableZonesResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allZoneListNode = value["ZoneList"]["ZoneListItem"]; + for (auto valueZoneListZoneListItem : allZoneListNode) + { + ZoneListItem zoneListObject; + if(!valueZoneListZoneListItem["Zone"].isNull()) + zoneListObject.zone = valueZoneListZoneListItem["Zone"].asString(); + if(!valueZoneListZoneListItem["IsInCluster"].isNull()) + zoneListObject.isInCluster = valueZoneListZoneListItem["IsInCluster"].asString() == "true"; + if(!valueZoneListZoneListItem["ReplicateZoneIndex"].isNull()) + zoneListObject.replicateZoneIndex = valueZoneListZoneListItem["ReplicateZoneIndex"].asString(); + if(!valueZoneListZoneListItem["LogicalZoneName"].isNull()) + zoneListObject.logicalZoneName = valueZoneListZoneListItem["LogicalZoneName"].asString(); + zoneList_.push_back(zoneListObject); + } + +} + +std::vector DescribeInstanceAvailableZonesResult::getZoneList()const +{ + return zoneList_; +} + diff --git a/oceanbasepro/src/model/DescribeInstanceCreatableZoneResult.cc b/oceanbasepro/src/model/DescribeInstanceCreatableZoneResult.cc index 6329fe2f4..ee5f12c44 100644 --- a/oceanbasepro/src/model/DescribeInstanceCreatableZoneResult.cc +++ b/oceanbasepro/src/model/DescribeInstanceCreatableZoneResult.cc @@ -47,6 +47,12 @@ void DescribeInstanceCreatableZoneResult::parse(const std::string &payload) zoneListObject.isInCluster = valueZoneListZoneListItem["IsInCluster"].asString() == "true"; if(!valueZoneListZoneListItem["Zone"].isNull()) zoneListObject.zone = valueZoneListZoneListItem["Zone"].asString(); + if(!valueZoneListZoneListItem["FullCopyId"].isNull()) + zoneListObject.fullCopyId = valueZoneListZoneListItem["FullCopyId"].asString(); + if(!valueZoneListZoneListItem["LogicalZoneName"].isNull()) + zoneListObject.logicalZoneName = valueZoneListZoneListItem["LogicalZoneName"].asString(); + if(!valueZoneListZoneListItem["ReplicateZoneIndex"].isNull()) + zoneListObject.replicateZoneIndex = std::stol(valueZoneListZoneListItem["ReplicateZoneIndex"].asString()); zoneList_.push_back(zoneListObject); } diff --git a/oceanbasepro/src/model/DescribeInstanceRequest.cc b/oceanbasepro/src/model/DescribeInstanceRequest.cc index e07795584..4bd27a814 100644 --- a/oceanbasepro/src/model/DescribeInstanceRequest.cc +++ b/oceanbasepro/src/model/DescribeInstanceRequest.cc @@ -34,15 +34,6 @@ void DescribeInstanceRequest::setPageNumber(int pageNumber) { setBodyParameter(std::string("PageNumber"), std::to_string(pageNumber)); } -std::string DescribeInstanceRequest::getMaxConnectionLimit() const { - return maxConnectionLimit_; -} - -void DescribeInstanceRequest::setMaxConnectionLimit(const std::string &maxConnectionLimit) { - maxConnectionLimit_ = maxConnectionLimit; - setBodyParameter(std::string("MaxConnectionLimit"), maxConnectionLimit); -} - std::string DescribeInstanceRequest::getInstanceId() const { return instanceId_; } diff --git a/oceanbasepro/src/model/DescribeInstanceSSLRequest.cc b/oceanbasepro/src/model/DescribeInstanceSSLRequest.cc index 8c915a226..7a01afe17 100644 --- a/oceanbasepro/src/model/DescribeInstanceSSLRequest.cc +++ b/oceanbasepro/src/model/DescribeInstanceSSLRequest.cc @@ -34,3 +34,12 @@ void DescribeInstanceSSLRequest::setInstanceId(const std::string &instanceId) { setBodyParameter(std::string("InstanceId"), instanceId); } +std::string DescribeInstanceSSLRequest::getTenantId() const { + return tenantId_; +} + +void DescribeInstanceSSLRequest::setTenantId(const std::string &tenantId) { + tenantId_ = tenantId; + setBodyParameter(std::string("TenantId"), tenantId); +} + diff --git a/oceanbasepro/src/model/DescribeInstanceSSLResult.cc b/oceanbasepro/src/model/DescribeInstanceSSLResult.cc index 9329bfd90..c5301ea6d 100644 --- a/oceanbasepro/src/model/DescribeInstanceSSLResult.cc +++ b/oceanbasepro/src/model/DescribeInstanceSSLResult.cc @@ -54,6 +54,10 @@ void DescribeInstanceSSLResult::parse(const std::string &payload) instanceSSL_.forceSSLSupport = instanceSSLNode["ForceSSLSupport"].asString() == "true"; if(!instanceSSLNode["ForceSSL"].isNull()) instanceSSL_.forceSSL = instanceSSLNode["ForceSSL"].asString(); + if(!instanceSSLNode["AutoUpdate"].isNull()) + instanceSSL_.autoUpdate = instanceSSLNode["AutoUpdate"].asString(); + if(!instanceSSLNode["TenantId"].isNull()) + instanceSSL_.tenantId = instanceSSLNode["TenantId"].asString(); } diff --git a/oceanbasepro/src/model/DescribeInstanceSummaryResult.cc b/oceanbasepro/src/model/DescribeInstanceSummaryResult.cc index 4487d25c1..a8f6c53b6 100644 --- a/oceanbasepro/src/model/DescribeInstanceSummaryResult.cc +++ b/oceanbasepro/src/model/DescribeInstanceSummaryResult.cc @@ -69,15 +69,15 @@ void DescribeInstanceSummaryResult::parse(const std::string &payload) if(!instanceSummaryNodeRegionalInstanceSummaryListRegionalInstanceSummaryLis["Region"].isNull()) regionalInstanceSummaryLisObject.region = instanceSummaryNodeRegionalInstanceSummaryListRegionalInstanceSummaryLis["Region"].asString(); if(!instanceSummaryNodeRegionalInstanceSummaryListRegionalInstanceSummaryLis["TotalInstancesCount"].isNull()) - regionalInstanceSummaryLisObject.totalInstancesCount = instanceSummaryNodeRegionalInstanceSummaryListRegionalInstanceSummaryLis["TotalInstancesCount"].asString(); + regionalInstanceSummaryLisObject.totalInstancesCount = std::stol(instanceSummaryNodeRegionalInstanceSummaryListRegionalInstanceSummaryLis["TotalInstancesCount"].asString()); if(!instanceSummaryNodeRegionalInstanceSummaryListRegionalInstanceSummaryLis["ImmediatelyExpiredInstancesCount"].isNull()) - regionalInstanceSummaryLisObject.immediatelyExpiredInstancesCount = instanceSummaryNodeRegionalInstanceSummaryListRegionalInstanceSummaryLis["ImmediatelyExpiredInstancesCount"].asString(); + regionalInstanceSummaryLisObject.immediatelyExpiredInstancesCount = std::stol(instanceSummaryNodeRegionalInstanceSummaryListRegionalInstanceSummaryLis["ImmediatelyExpiredInstancesCount"].asString()); if(!instanceSummaryNodeRegionalInstanceSummaryListRegionalInstanceSummaryLis["RunningInstancesCount"].isNull()) - regionalInstanceSummaryLisObject.runningInstancesCount = instanceSummaryNodeRegionalInstanceSummaryListRegionalInstanceSummaryLis["RunningInstancesCount"].asString(); + regionalInstanceSummaryLisObject.runningInstancesCount = std::stol(instanceSummaryNodeRegionalInstanceSummaryListRegionalInstanceSummaryLis["RunningInstancesCount"].asString()); if(!instanceSummaryNodeRegionalInstanceSummaryListRegionalInstanceSummaryLis["ExpiredInstancesCount"].isNull()) - regionalInstanceSummaryLisObject.expiredInstancesCount = instanceSummaryNodeRegionalInstanceSummaryListRegionalInstanceSummaryLis["ExpiredInstancesCount"].asString(); + regionalInstanceSummaryLisObject.expiredInstancesCount = std::stol(instanceSummaryNodeRegionalInstanceSummaryListRegionalInstanceSummaryLis["ExpiredInstancesCount"].asString()); if(!instanceSummaryNodeRegionalInstanceSummaryListRegionalInstanceSummaryLis["RecentCreatedInstancesCount"].isNull()) - regionalInstanceSummaryLisObject.recentCreatedInstancesCount = instanceSummaryNodeRegionalInstanceSummaryListRegionalInstanceSummaryLis["RecentCreatedInstancesCount"].asString(); + regionalInstanceSummaryLisObject.recentCreatedInstancesCount = std::stol(instanceSummaryNodeRegionalInstanceSummaryListRegionalInstanceSummaryLis["RecentCreatedInstancesCount"].asString()); instanceSummary_.regionalInstanceSummaryList.push_back(regionalInstanceSummaryLisObject); } diff --git a/oceanbasepro/src/model/DescribeInstanceTopologyResult.cc b/oceanbasepro/src/model/DescribeInstanceTopologyResult.cc index 16ac6ebbd..bbfdb1fb9 100644 --- a/oceanbasepro/src/model/DescribeInstanceTopologyResult.cc +++ b/oceanbasepro/src/model/DescribeInstanceTopologyResult.cc @@ -82,6 +82,8 @@ void DescribeInstanceTopologyResult::parse(const std::string &payload) tenantZonesObject.logicalZone = instanceTopologyNodeTenantsTenantsItemTenantZonesTenantZonesItem["LogicalZone"].asString(); if(!instanceTopologyNodeTenantsTenantsItemTenantZonesTenantZonesItem["ReplicaType"].isNull()) tenantZonesObject.replicaType = instanceTopologyNodeTenantsTenantsItemTenantZonesTenantZonesItem["ReplicaType"].asString(); + if(!instanceTopologyNodeTenantsTenantsItemTenantZonesTenantZonesItem["ReadOnlyReplicaType"].isNull()) + tenantZonesObject.readOnlyReplicaType = instanceTopologyNodeTenantsTenantsItemTenantZonesTenantZonesItem["ReadOnlyReplicaType"].asString(); auto allUnitsNode = instanceTopologyNodeTenantsTenantsItemTenantZonesTenantZonesItem["Units"]["UnitsItem"]; for (auto instanceTopologyNodeTenantsTenantsItemTenantZonesTenantZonesItemUnitsUnitsItem : allUnitsNode) { @@ -140,6 +142,8 @@ void DescribeInstanceTopologyResult::parse(const std::string &payload) nodesObject.readOnlyCopyId = std::stol(instanceTopologyNodeZonesZonesItemNodesNodesItem["ReadOnlyCopyId"].asString()); if(!instanceTopologyNodeZonesZonesItemNodesNodesItem["LogicalZone"].isNull()) nodesObject.logicalZone = instanceTopologyNodeZonesZonesItemNodesNodesItem["LogicalZone"].asString(); + if(!instanceTopologyNodeZonesZonesItemNodesNodesItem["ReadOnlyReplicaType"].isNull()) + nodesObject.readOnlyReplicaType = instanceTopologyNodeZonesZonesItemNodesNodesItem["ReadOnlyReplicaType"].asString(); auto nodeResourceNode = value["NodeResource"]; auto cpuNode = nodeResourceNode["Cpu"]; if(!cpuNode["UsedCpu"].isNull()) @@ -185,6 +189,10 @@ void DescribeInstanceTopologyResult::parse(const std::string &payload) replicasItemObject.replicaType = instanceTopologyNodeReplicasReplicasItem["ReplicaType"].asString(); if(!instanceTopologyNodeReplicasReplicasItem["Status"].isNull()) replicasItemObject.status = instanceTopologyNodeReplicasReplicasItem["Status"].asString(); + if(!instanceTopologyNodeReplicasReplicasItem["ReadOnlyReplicaType"].isNull()) + replicasItemObject.readOnlyReplicaType = instanceTopologyNodeReplicasReplicasItem["ReadOnlyReplicaType"].asString(); + if(!instanceTopologyNodeReplicasReplicasItem["OnlineNodeNum"].isNull()) + replicasItemObject.onlineNodeNum = std::stol(instanceTopologyNodeReplicasReplicasItem["OnlineNodeNum"].asString()); auto replicaResourceNode = value["ReplicaResource"]; auto memory2Node = replicaResourceNode["Memory"]; if(!memory2Node["UsedMemory"].isNull()) diff --git a/oceanbasepro/src/model/DescribeInstancesRequest.cc b/oceanbasepro/src/model/DescribeInstancesRequest.cc index dcca32238..119ec7804 100644 --- a/oceanbasepro/src/model/DescribeInstancesRequest.cc +++ b/oceanbasepro/src/model/DescribeInstancesRequest.cc @@ -52,6 +52,15 @@ void DescribeInstancesRequest::setResourceGroupId(const std::string &resourceGro setBodyParameter(std::string("ResourceGroupId"), resourceGroupId); } +int DescribeInstancesRequest::getPageSize() const { + return pageSize_; +} + +void DescribeInstancesRequest::setPageSize(int pageSize) { + pageSize_ = pageSize; + setBodyParameter(std::string("PageSize"), std::to_string(pageSize)); +} + std::string DescribeInstancesRequest::getInstanceId() const { return instanceId_; } @@ -70,12 +79,12 @@ void DescribeInstancesRequest::setInstanceName(const std::string &instanceName) setBodyParameter(std::string("InstanceName"), instanceName); } -int DescribeInstancesRequest::getPageSize() const { - return pageSize_; +bool DescribeInstancesRequest::getWithOBCloudInstances() const { + return withOBCloudInstances_; } -void DescribeInstancesRequest::setPageSize(int pageSize) { - pageSize_ = pageSize; - setBodyParameter(std::string("PageSize"), std::to_string(pageSize)); +void DescribeInstancesRequest::setWithOBCloudInstances(bool withOBCloudInstances) { + withOBCloudInstances_ = withOBCloudInstances; + setBodyParameter(std::string("WithOBCloudInstances"), withOBCloudInstances ? "true" : "false"); } diff --git a/oceanbasepro/src/model/DescribeInstancesResult.cc b/oceanbasepro/src/model/DescribeInstancesResult.cc index 9829ed0aa..fcf413662 100644 --- a/oceanbasepro/src/model/DescribeInstancesResult.cc +++ b/oceanbasepro/src/model/DescribeInstancesResult.cc @@ -66,7 +66,7 @@ void DescribeInstancesResult::parse(const std::string &payload) if(!valueInstancesData["PayType"].isNull()) instancesObject.payType = valueInstancesData["PayType"].asString(); if(!valueInstancesData["DiskSize"].isNull()) - instancesObject.diskSize = valueInstancesData["DiskSize"].asString(); + instancesObject.diskSize = std::stol(valueInstancesData["DiskSize"].asString()); if(!valueInstancesData["DiskType"].isNull()) instancesObject.diskType = valueInstancesData["DiskType"].asString(); if(!valueInstancesData["InstanceId"].isNull()) @@ -101,6 +101,10 @@ void DescribeInstancesResult::parse(const std::string &payload) instancesObject.specType = valueInstancesData["SpecType"].asString(); if(!valueInstancesData["ObRpmVersion"].isNull()) instancesObject.obRpmVersion = valueInstancesData["ObRpmVersion"].asString(); + if(!valueInstancesData["ReplicaMode"].isNull()) + instancesObject.replicaMode = valueInstancesData["ReplicaMode"].asString(); + if(!valueInstancesData["Migratable"].isNull()) + instancesObject.migratable = valueInstancesData["Migratable"].asString() == "true"; auto resourceNode = value["Resource"]; if(!resourceNode["UnitCount"].isNull()) instancesObject.resource.unitCount = std::stol(resourceNode["UnitCount"].asString()); @@ -155,6 +159,24 @@ void DescribeInstancesResult::parse(const std::string &payload) instancesObject.dataDiskAutoScaleConfig.scaleStepInMerge = dataDiskAutoScaleConfigNode["ScaleStepInMerge"].asString(); if(!dataDiskAutoScaleConfigNode["UpperScaleStrategy"].isNull()) instancesObject.dataDiskAutoScaleConfig.upperScaleStrategy = dataDiskAutoScaleConfigNode["UpperScaleStrategy"].asString(); + auto migrationInfoNode = value["MigrationInfo"]; + if(!migrationInfoNode["Migratable"].isNull()) + instancesObject.migrationInfo.migratable = migrationInfoNode["Migratable"].asString() == "true"; + auto checkResultNode = migrationInfoNode["CheckResult"]; + if(!checkResultNode["Level"].isNull()) + instancesObject.migrationInfo.checkResult.level = checkResultNode["Level"].asString(); + if(!checkResultNode["Code"].isNull()) + instancesObject.migrationInfo.checkResult.code = checkResultNode["Code"].asString(); + if(!checkResultNode["CodeName"].isNull()) + instancesObject.migrationInfo.checkResult.codeName = checkResultNode["CodeName"].asString(); + if(!checkResultNode["Module"].isNull()) + instancesObject.migrationInfo.checkResult.module = checkResultNode["Module"].asString(); + if(!checkResultNode["ModuleName"].isNull()) + instancesObject.migrationInfo.checkResult.moduleName = checkResultNode["ModuleName"].asString(); + if(!checkResultNode["SubModule"].isNull()) + instancesObject.migrationInfo.checkResult.subModule = checkResultNode["SubModule"].asString(); + if(!checkResultNode["SubModuleName"].isNull()) + instancesObject.migrationInfo.checkResult.subModuleName = checkResultNode["SubModuleName"].asString(); auto allAvailableZones = value["AvailableZones"]["AvailableZones"]; for (auto value : allAvailableZones) instancesObject.availableZones.push_back(value.asString()); diff --git a/oceanbasepro/src/model/DescribeOasSQLHistoryListResult.cc b/oceanbasepro/src/model/DescribeOasSQLHistoryListResult.cc index a5a3944b6..d5e04ea3a 100644 --- a/oceanbasepro/src/model/DescribeOasSQLHistoryListResult.cc +++ b/oceanbasepro/src/model/DescribeOasSQLHistoryListResult.cc @@ -181,6 +181,8 @@ void DescribeOasSQLHistoryListResult::parse(const std::string &payload) dataObject.avgDbTime = valueDataDataItem["AvgDbTime"].asString(); if(!valueDataDataItem["SumDbTime"].isNull()) dataObject.sumDbTime = valueDataDataItem["SumDbTime"].asString(); + if(!valueDataDataItem["WaitEvent"].isNull()) + dataObject.waitEvent = valueDataDataItem["WaitEvent"].asString(); data_.push_back(dataObject); } diff --git a/oceanbasepro/src/model/DescribeOasSQLPlansResult.cc b/oceanbasepro/src/model/DescribeOasSQLPlansResult.cc index d6d61cb41..5763f6da8 100644 --- a/oceanbasepro/src/model/DescribeOasSQLPlansResult.cc +++ b/oceanbasepro/src/model/DescribeOasSQLPlansResult.cc @@ -145,6 +145,8 @@ void DescribeOasSQLPlansResult::parse(const std::string &payload) plansObject.planUnionHash = valueDataDataItemPlansPlansItem["PlanUnionHash"].asString(); if(!valueDataDataItemPlansPlansItem["SqlId"].isNull()) plansObject.sqlId = valueDataDataItemPlansPlansItem["SqlId"].asString(); + if(!valueDataDataItemPlansPlansItem["SqlText"].isNull()) + plansObject.sqlText = valueDataDataItemPlansPlansItem["SqlText"].asString(); dataObject.plans.push_back(plansObject); } auto planExplainNode = value["PlanExplain"]; diff --git a/oceanbasepro/src/model/DescribeOasTopSQLListRequest.cc b/oceanbasepro/src/model/DescribeOasTopSQLListRequest.cc index cfa49e53d..6bd68e420 100644 --- a/oceanbasepro/src/model/DescribeOasTopSQLListRequest.cc +++ b/oceanbasepro/src/model/DescribeOasTopSQLListRequest.cc @@ -34,6 +34,15 @@ void DescribeOasTopSQLListRequest::setStartTime(const std::string &startTime) { setBodyParameter(std::string("StartTime"), startTime); } +std::string DescribeOasTopSQLListRequest::getCustomColumns() const { + return customColumns_; +} + +void DescribeOasTopSQLListRequest::setCustomColumns(const std::string &customColumns) { + customColumns_ = customColumns; + setBodyParameter(std::string("CustomColumns"), customColumns); +} + std::string DescribeOasTopSQLListRequest::getSearchRule() const { return searchRule_; } diff --git a/oceanbasepro/src/model/DescribeOasTopSQLListResult.cc b/oceanbasepro/src/model/DescribeOasTopSQLListResult.cc index 6eaf67842..de99b5922 100644 --- a/oceanbasepro/src/model/DescribeOasTopSQLListResult.cc +++ b/oceanbasepro/src/model/DescribeOasTopSQLListResult.cc @@ -203,6 +203,8 @@ void DescribeOasTopSQLListResult::parse(const std::string &payload) dataObject.avgDbTime = valueDataDataItem["AvgDbTime"].asString(); if(!valueDataDataItem["SumDbTime"].isNull()) dataObject.sumDbTime = valueDataDataItem["SumDbTime"].asString(); + if(!valueDataDataItem["ObDbId"].isNull()) + dataObject.obDbId = valueDataDataItem["ObDbId"].asString(); auto allSqlListNode = valueDataDataItem["SqlList"]["SqlListItem"]; for (auto valueDataDataItemSqlListSqlListItem : allSqlListNode) { @@ -365,6 +367,11 @@ void DescribeOasTopSQLListResult::parse(const std::string &payload) sqlListObject.sumDbTime = valueDataDataItemSqlListSqlListItem["SumDbTime"].asString(); dataObject.sqlList.push_back(sqlListObject); } + auto customColumnsNode = value["CustomColumns"]; + if(!customColumnsNode["Expression"].isNull()) + dataObject.customColumns.expression = customColumnsNode["Expression"].asString(); + if(!customColumnsNode["Value"].isNull()) + dataObject.customColumns.value = customColumnsNode["Value"].asString(); data_.push_back(dataObject); } diff --git a/oceanbasepro/src/model/DescribeOutlineBindingResult.cc b/oceanbasepro/src/model/DescribeOutlineBindingResult.cc index 36b5cdb02..77d03927e 100644 --- a/oceanbasepro/src/model/DescribeOutlineBindingResult.cc +++ b/oceanbasepro/src/model/DescribeOutlineBindingResult.cc @@ -50,6 +50,10 @@ void DescribeOutlineBindingResult::parse(const std::string &payload) outlineBinding_.maxConcurrent = std::stoi(outlineBindingNode["MaxConcurrent"].asString()); if(!outlineBindingNode["TableName"].isNull()) outlineBinding_.tableName = outlineBindingNode["TableName"].asString(); + if(!outlineBindingNode["SqlText"].isNull()) + outlineBinding_.sqlText = outlineBindingNode["SqlText"].asString(); + if(!outlineBindingNode["SqlTextConcurrentNum"].isNull()) + outlineBinding_.sqlTextConcurrentNum = std::stol(outlineBindingNode["SqlTextConcurrentNum"].asString()); } diff --git a/oceanbasepro/src/model/DescribeParametersHistoryResult.cc b/oceanbasepro/src/model/DescribeParametersHistoryResult.cc index ab7b89f22..bb7206869 100644 --- a/oceanbasepro/src/model/DescribeParametersHistoryResult.cc +++ b/oceanbasepro/src/model/DescribeParametersHistoryResult.cc @@ -39,40 +39,35 @@ void DescribeParametersHistoryResult::parse(const std::string &payload) Json::Value value; reader.parse(payload, value); setRequestId(value["RequestId"].asString()); - auto allRespondNode = value["Respond"]["Data"]; - for (auto valueRespondData : allRespondNode) + auto respondNode = value["Respond"]; + if(!respondNode["TotalCount"].isNull()) + respond_.totalCount = std::stoi(respondNode["TotalCount"].asString()); + if(!respondNode["PageNumber"].isNull()) + respond_.pageNumber = std::stoi(respondNode["PageNumber"].asString()); + auto allParametersNode = respondNode["Parameters"]["ParametersItem"]; + for (auto respondNodeParametersParametersItem : allParametersNode) { - Data respondObject; - if(!valueRespondData["TotalCount"].isNull()) - respondObject.totalCount = std::stoi(valueRespondData["TotalCount"].asString()); - if(!valueRespondData["PageNumber"].isNull()) - respondObject.pageNumber = std::stoi(valueRespondData["PageNumber"].asString()); - auto allParametersNode = valueRespondData["Parameters"]["ParametersItem"]; - for (auto valueRespondDataParametersParametersItem : allParametersNode) - { - Data::ParametersItem parametersObject; - if(!valueRespondDataParametersParametersItem["Status"].isNull()) - parametersObject.status = valueRespondDataParametersParametersItem["Status"].asString(); - if(!valueRespondDataParametersParametersItem["OldValue"].isNull()) - parametersObject.oldValue = valueRespondDataParametersParametersItem["OldValue"].asString(); - if(!valueRespondDataParametersParametersItem["UpdateTime"].isNull()) - parametersObject.updateTime = valueRespondDataParametersParametersItem["UpdateTime"].asString(); - if(!valueRespondDataParametersParametersItem["CreateTime"].isNull()) - parametersObject.createTime = valueRespondDataParametersParametersItem["CreateTime"].asString(); - if(!valueRespondDataParametersParametersItem["DimensionValue"].isNull()) - parametersObject.dimensionValue = valueRespondDataParametersParametersItem["DimensionValue"].asString(); - if(!valueRespondDataParametersParametersItem["Name"].isNull()) - parametersObject.name = valueRespondDataParametersParametersItem["Name"].asString(); - if(!valueRespondDataParametersParametersItem["NewValue"].isNull()) - parametersObject.newValue = valueRespondDataParametersParametersItem["NewValue"].asString(); - respondObject.parameters.push_back(parametersObject); - } - respond_.push_back(respondObject); + Respond::ParametersItem parametersItemObject; + if(!respondNodeParametersParametersItem["Status"].isNull()) + parametersItemObject.status = respondNodeParametersParametersItem["Status"].asString(); + if(!respondNodeParametersParametersItem["OldValue"].isNull()) + parametersItemObject.oldValue = respondNodeParametersParametersItem["OldValue"].asString(); + if(!respondNodeParametersParametersItem["UpdateTime"].isNull()) + parametersItemObject.updateTime = respondNodeParametersParametersItem["UpdateTime"].asString(); + if(!respondNodeParametersParametersItem["CreateTime"].isNull()) + parametersItemObject.createTime = respondNodeParametersParametersItem["CreateTime"].asString(); + if(!respondNodeParametersParametersItem["DimensionValue"].isNull()) + parametersItemObject.dimensionValue = respondNodeParametersParametersItem["DimensionValue"].asString(); + if(!respondNodeParametersParametersItem["Name"].isNull()) + parametersItemObject.name = respondNodeParametersParametersItem["Name"].asString(); + if(!respondNodeParametersParametersItem["NewValue"].isNull()) + parametersItemObject.newValue = respondNodeParametersParametersItem["NewValue"].asString(); + respond_.parameters.push_back(parametersItemObject); } } -std::vector DescribeParametersHistoryResult::getRespond()const +DescribeParametersHistoryResult::Respond DescribeParametersHistoryResult::getRespond()const { return respond_; } diff --git a/oceanbasepro/src/model/DescribeProcessStatsCompositionRequest.cc b/oceanbasepro/src/model/DescribeProcessStatsCompositionRequest.cc index 57c195271..872d6329d 100644 --- a/oceanbasepro/src/model/DescribeProcessStatsCompositionRequest.cc +++ b/oceanbasepro/src/model/DescribeProcessStatsCompositionRequest.cc @@ -34,6 +34,15 @@ void DescribeProcessStatsCompositionRequest::setUId(const std::string &uId) { setBodyParameter(std::string("UId"), uId); } +bool DescribeProcessStatsCompositionRequest::getMergeDynamicSql() const { + return mergeDynamicSql_; +} + +void DescribeProcessStatsCompositionRequest::setMergeDynamicSql(bool mergeDynamicSql) { + mergeDynamicSql_ = mergeDynamicSql; + setBodyParameter(std::string("MergeDynamicSql"), mergeDynamicSql ? "true" : "false"); +} + std::string DescribeProcessStatsCompositionRequest::getSqlText() const { return sqlText_; } diff --git a/oceanbasepro/src/model/DescribeProcessStatsCompositionResult.cc b/oceanbasepro/src/model/DescribeProcessStatsCompositionResult.cc index 8c11274c0..6cf232802 100644 --- a/oceanbasepro/src/model/DescribeProcessStatsCompositionResult.cc +++ b/oceanbasepro/src/model/DescribeProcessStatsCompositionResult.cc @@ -82,6 +82,86 @@ void DescribeProcessStatsCompositionResult::parse(const std::string &payload) allProcessListItemObject.traceId = dataNodeAllProcessListAllProcessListItem["TraceId"].asString(); if(!dataNodeAllProcessListAllProcessListItem["PlanId"].isNull()) allProcessListItemObject.planId = dataNodeAllProcessListAllProcessListItem["PlanId"].asString(); + if(!dataNodeAllProcessListAllProcessListItem["DynamicSql"].isNull()) + allProcessListItemObject.dynamicSql = dataNodeAllProcessListAllProcessListItem["DynamicSql"].asString(); + if(!dataNodeAllProcessListAllProcessListItem["ServerSn"].isNull()) + allProcessListItemObject.serverSn = dataNodeAllProcessListAllProcessListItem["ServerSn"].asString(); + auto allProcessSqlListsNode = dataNodeAllProcessListAllProcessListItem["ProcessSqlLists"]["ProcessSqlListsItem"]; + for (auto dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem : allProcessSqlListsNode) + { + Data::AllProcessListItem::ProcessSqlListsItem processSqlListsObject; + if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["SqlText"].isNull()) + processSqlListsObject.sqlText = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["SqlText"].asString(); + if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["TenantId"].isNull()) + processSqlListsObject.tenantId = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["TenantId"].asString(); + if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["Database"].isNull()) + processSqlListsObject.database = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["Database"].asString(); + if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["User"].isNull()) + processSqlListsObject.user = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["User"].asString(); + if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["ExecuteTime"].isNull()) + processSqlListsObject.executeTime = std::stol(dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["ExecuteTime"].asString()); + if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["CpuTime"].isNull()) + processSqlListsObject.cpuTime = std::stol(dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["CpuTime"].asString()); + if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["ServerIp"].isNull()) + processSqlListsObject.serverIp = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["ServerIp"].asString(); + if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["ClientIp"].isNull()) + processSqlListsObject.clientIp = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["ClientIp"].asString(); + if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["SessionId"].isNull()) + processSqlListsObject.sessionId = std::stol(dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["SessionId"].asString()); + if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["ProxySessId"].isNull()) + processSqlListsObject.proxySessId = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["ProxySessId"].asString(); + if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["Command"].isNull()) + processSqlListsObject.command = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["Command"].asString(); + if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["Status"].isNull()) + processSqlListsObject.status = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["Status"].asString(); + if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["SqlId"].isNull()) + processSqlListsObject.sqlId = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["SqlId"].asString(); + if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["TraceId"].isNull()) + processSqlListsObject.traceId = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["TraceId"].asString(); + if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["PlanId"].isNull()) + processSqlListsObject.planId = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["PlanId"].asString(); + if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["DynamicSql"].isNull()) + processSqlListsObject.dynamicSql = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["DynamicSql"].asString(); + auto allProcessSqlListNode = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["ProcessSqlList"]["ProcessSqlListItem"]; + for (auto dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem : allProcessSqlListNode) + { + Data::AllProcessListItem::ProcessSqlListsItem::ProcessSqlListItem processSqlListObject; + if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["SqlText"].isNull()) + processSqlListObject.sqlText = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["SqlText"].asString(); + if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["TenantId"].isNull()) + processSqlListObject.tenantId = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["TenantId"].asString(); + if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["Database"].isNull()) + processSqlListObject.database = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["Database"].asString(); + if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["User"].isNull()) + processSqlListObject.user = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["User"].asString(); + if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["ExecuteTime"].isNull()) + processSqlListObject.executeTime = std::stol(dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["ExecuteTime"].asString()); + if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["CpuTime"].isNull()) + processSqlListObject.cpuTime = std::stol(dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["CpuTime"].asString()); + if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["ServerIp"].isNull()) + processSqlListObject.serverIp = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["ServerIp"].asString(); + if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["ClientIp"].isNull()) + processSqlListObject.clientIp = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["ClientIp"].asString(); + if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["SessionId"].isNull()) + processSqlListObject.sessionId = std::stol(dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["SessionId"].asString()); + if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["ProxySessId"].isNull()) + processSqlListObject.proxySessId = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["ProxySessId"].asString(); + if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["Command"].isNull()) + processSqlListObject.command = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["Command"].asString(); + if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["Status"].isNull()) + processSqlListObject.status = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["Status"].asString(); + if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["SqlId"].isNull()) + processSqlListObject.sqlId = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["SqlId"].asString(); + if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["TraceId"].isNull()) + processSqlListObject.traceId = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["TraceId"].asString(); + if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["PlanId"].isNull()) + processSqlListObject.planId = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["PlanId"].asString(); + if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["DynamicSql"].isNull()) + processSqlListObject.dynamicSql = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["DynamicSql"].asString(); + processSqlListsObject.processSqlList.push_back(processSqlListObject); + } + allProcessListItemObject.processSqlLists.push_back(processSqlListsObject); + } data_.allProcessList.push_back(allProcessListItemObject); } auto sessionStatisticsNode = dataNode["SessionStatistics"]; diff --git a/oceanbasepro/src/model/DescribeProxyServiceRequest.cc b/oceanbasepro/src/model/DescribeProxyServiceRequest.cc new file mode 100644 index 000000000..889f0f3a5 --- /dev/null +++ b/oceanbasepro/src/model/DescribeProxyServiceRequest.cc @@ -0,0 +1,36 @@ +/* + * 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::OceanBasePro::Model::DescribeProxyServiceRequest; + +DescribeProxyServiceRequest::DescribeProxyServiceRequest() + : RpcServiceRequest("oceanbasepro", "2019-09-01", "DescribeProxyService") { + setMethod(HttpRequest::Method::Post); +} + +DescribeProxyServiceRequest::~DescribeProxyServiceRequest() {} + +std::string DescribeProxyServiceRequest::getInstanceId() const { + return instanceId_; +} + +void DescribeProxyServiceRequest::setInstanceId(const std::string &instanceId) { + instanceId_ = instanceId; + setBodyParameter(std::string("InstanceId"), instanceId); +} + diff --git a/oceanbasepro/src/model/DescribeProxyServiceResult.cc b/oceanbasepro/src/model/DescribeProxyServiceResult.cc new file mode 100644 index 000000000..c71865935 --- /dev/null +++ b/oceanbasepro/src/model/DescribeProxyServiceResult.cc @@ -0,0 +1,76 @@ +/* + * 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::OceanBasePro; +using namespace AlibabaCloud::OceanBasePro::Model; + +DescribeProxyServiceResult::DescribeProxyServiceResult() : + ServiceResult() +{} + +DescribeProxyServiceResult::DescribeProxyServiceResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeProxyServiceResult::~DescribeProxyServiceResult() +{} + +void DescribeProxyServiceResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto dataNode = value["Data"]; + if(!dataNode["ProxyClusterId"].isNull()) + data_.proxyClusterId = dataNode["ProxyClusterId"].asString(); + if(!dataNode["ProxyMode"].isNull()) + data_.proxyMode = dataNode["ProxyMode"].asString(); + if(!dataNode["Zone"].isNull()) + data_.zone = dataNode["Zone"].asString(); + if(!dataNode["UnitSpec"].isNull()) + data_.unitSpec = dataNode["UnitSpec"].asString(); + if(!dataNode["UnitNum"].isNull()) + data_.unitNum = std::stol(dataNode["UnitNum"].asString()); + if(!dataNode["CurrentEndpointNum"].isNull()) + data_.currentEndpointNum = std::stol(dataNode["CurrentEndpointNum"].asString()); + if(!dataNode["EndpointNumQuota"].isNull()) + data_.endpointNumQuota = std::stol(dataNode["EndpointNumQuota"].asString()); + if(!dataNode["CreateTime"].isNull()) + data_.createTime = dataNode["CreateTime"].asString(); + if(!dataNode["Status"].isNull()) + data_.status = dataNode["Status"].asString(); + if(!dataNode["ProxyServiceVersion"].isNull()) + data_.proxyServiceVersion = dataNode["ProxyServiceVersion"].asString(); + if(!dataNode["ExpireTime"].isNull()) + data_.expireTime = dataNode["ExpireTime"].asString(); + if(!dataNode["UnitNumLimit"].isNull()) + data_.unitNumLimit = std::stol(dataNode["UnitNumLimit"].asString()); + if(!dataNode["ProxyVersion"].isNull()) + data_.proxyVersion = dataNode["ProxyVersion"].asString(); + +} + +DescribeProxyServiceResult::Data DescribeProxyServiceResult::getData()const +{ + return data_; +} + diff --git a/oceanbasepro/src/model/DescribeSampleSqlRawTextsRequest.cc b/oceanbasepro/src/model/DescribeSampleSqlRawTextsRequest.cc index 0a5dd3217..454dbcb59 100644 --- a/oceanbasepro/src/model/DescribeSampleSqlRawTextsRequest.cc +++ b/oceanbasepro/src/model/DescribeSampleSqlRawTextsRequest.cc @@ -43,6 +43,15 @@ void DescribeSampleSqlRawTextsRequest::setStartTime(const std::string &startTime setBodyParameter(std::string("StartTime"), startTime); } +bool DescribeSampleSqlRawTextsRequest::getDynamicSql() const { + return dynamicSql_; +} + +void DescribeSampleSqlRawTextsRequest::setDynamicSql(bool dynamicSql) { + dynamicSql_ = dynamicSql; + setBodyParameter(std::string("DynamicSql"), dynamicSql ? "true" : "false"); +} + std::string DescribeSampleSqlRawTextsRequest::getTenantId() const { return tenantId_; } diff --git a/oceanbasepro/src/model/DescribeSqlAuditStatRequest.cc b/oceanbasepro/src/model/DescribeSqlAuditStatRequest.cc new file mode 100644 index 000000000..8d9778c35 --- /dev/null +++ b/oceanbasepro/src/model/DescribeSqlAuditStatRequest.cc @@ -0,0 +1,81 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::OceanBasePro::Model::DescribeSqlAuditStatRequest; + +DescribeSqlAuditStatRequest::DescribeSqlAuditStatRequest() + : RpcServiceRequest("oceanbasepro", "2019-09-01", "DescribeSqlAuditStat") { + setMethod(HttpRequest::Method::Post); +} + +DescribeSqlAuditStatRequest::~DescribeSqlAuditStatRequest() {} + +std::string DescribeSqlAuditStatRequest::getStartTime() const { + return startTime_; +} + +void DescribeSqlAuditStatRequest::setStartTime(const std::string &startTime) { + startTime_ = startTime; + setBodyParameter(std::string("StartTime"), startTime); +} + +int DescribeSqlAuditStatRequest::getPageNumber() const { + return pageNumber_; +} + +void DescribeSqlAuditStatRequest::setPageNumber(int pageNumber) { + pageNumber_ = pageNumber; + setBodyParameter(std::string("PageNumber"), std::to_string(pageNumber)); +} + +std::string DescribeSqlAuditStatRequest::getTenantId() const { + return tenantId_; +} + +void DescribeSqlAuditStatRequest::setTenantId(const std::string &tenantId) { + tenantId_ = tenantId; + setBodyParameter(std::string("TenantId"), tenantId); +} + +int DescribeSqlAuditStatRequest::getPageSize() const { + return pageSize_; +} + +void DescribeSqlAuditStatRequest::setPageSize(int pageSize) { + pageSize_ = pageSize; + setBodyParameter(std::string("PageSize"), std::to_string(pageSize)); +} + +std::string DescribeSqlAuditStatRequest::getEndTime() const { + return endTime_; +} + +void DescribeSqlAuditStatRequest::setEndTime(const std::string &endTime) { + endTime_ = endTime; + setBodyParameter(std::string("EndTime"), endTime); +} + +std::string DescribeSqlAuditStatRequest::getInstanceId() const { + return instanceId_; +} + +void DescribeSqlAuditStatRequest::setInstanceId(const std::string &instanceId) { + instanceId_ = instanceId; + setBodyParameter(std::string("InstanceId"), instanceId); +} + diff --git a/oceanbasepro/src/model/DescribeSqlAuditStatResult.cc b/oceanbasepro/src/model/DescribeSqlAuditStatResult.cc new file mode 100644 index 000000000..f8847782b --- /dev/null +++ b/oceanbasepro/src/model/DescribeSqlAuditStatResult.cc @@ -0,0 +1,89 @@ +/* + * 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::OceanBasePro; +using namespace AlibabaCloud::OceanBasePro::Model; + +DescribeSqlAuditStatResult::DescribeSqlAuditStatResult() : + ServiceResult() +{} + +DescribeSqlAuditStatResult::DescribeSqlAuditStatResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +DescribeSqlAuditStatResult::~DescribeSqlAuditStatResult() +{} + +void DescribeSqlAuditStatResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + auto allDataNode = value["Data"]["DataItem"]; + for (auto valueDataDataItem : allDataNode) + { + DataItem dataObject; + if(!valueDataDataItem["InstanceId"].isNull()) + dataObject.instanceId = valueDataDataItem["InstanceId"].asString(); + if(!valueDataDataItem["TenantId"].isNull()) + dataObject.tenantId = valueDataDataItem["TenantId"].asString(); + if(!valueDataDataItem["UserClientIp"].isNull()) + dataObject.userClientIp = valueDataDataItem["UserClientIp"].asString(); + if(!valueDataDataItem["UserName"].isNull()) + dataObject.userName = valueDataDataItem["UserName"].asString(); + if(!valueDataDataItem["DatabaseName"].isNull()) + dataObject.databaseName = valueDataDataItem["DatabaseName"].asString(); + if(!valueDataDataItem["SqlId"].isNull()) + dataObject.sqlId = valueDataDataItem["SqlId"].asString(); + if(!valueDataDataItem["TotalSucceed"].isNull()) + dataObject.totalSucceed = std::stol(valueDataDataItem["TotalSucceed"].asString()); + if(!valueDataDataItem["TotalFailed"].isNull()) + dataObject.totalFailed = std::stol(valueDataDataItem["TotalFailed"].asString()); + if(!valueDataDataItem["TotalAffectRows"].isNull()) + dataObject.totalAffectRows = std::stol(valueDataDataItem["TotalAffectRows"].asString()); + if(!valueDataDataItem["TotalScanRows"].isNull()) + dataObject.totalScanRows = std::stol(valueDataDataItem["TotalScanRows"].asString()); + if(!valueDataDataItem["TotalReturnRows"].isNull()) + dataObject.totalReturnRows = std::stol(valueDataDataItem["TotalReturnRows"].asString()); + if(!valueDataDataItem["AffectRows"].isNull()) + dataObject.affectRows = valueDataDataItem["AffectRows"].asString(); + if(!valueDataDataItem["ScanRows"].isNull()) + dataObject.scanRows = valueDataDataItem["ScanRows"].asString(); + if(!valueDataDataItem["ReturnRows"].isNull()) + dataObject.returnRows = valueDataDataItem["ReturnRows"].asString(); + if(!valueDataDataItem["ExecuteTime"].isNull()) + dataObject.executeTime = valueDataDataItem["ExecuteTime"].asString(); + if(!valueDataDataItem["SqlStatement"].isNull()) + dataObject.sqlStatement = valueDataDataItem["SqlStatement"].asString(); + if(!valueDataDataItem["OperatorType"].isNull()) + dataObject.operatorType = valueDataDataItem["OperatorType"].asString(); + data_.push_back(dataObject); + } + +} + +std::vector DescribeSqlAuditStatResult::getData()const +{ + return data_; +} + diff --git a/oceanbasepro/src/model/DescribeTenantResult.cc b/oceanbasepro/src/model/DescribeTenantResult.cc index 2ebc6cf9b..ac4c1d6ff 100644 --- a/oceanbasepro/src/model/DescribeTenantResult.cc +++ b/oceanbasepro/src/model/DescribeTenantResult.cc @@ -104,6 +104,10 @@ void DescribeTenantResult::parse(const std::string &payload) tenant_.version = tenantNode["Version"].asString(); if(!tenantNode["OdpVersion"].isNull()) tenant_.odpVersion = tenantNode["OdpVersion"].asString(); + if(!tenantNode["TenantMaxConnections"].isNull()) + tenant_.tenantMaxConnections = tenantNode["TenantMaxConnections"].asString(); + if(!tenantNode["ParameterTemplate"].isNull()) + tenant_.parameterTemplate = tenantNode["ParameterTemplate"].asString(); auto allTenantConnectionsNode = tenantNode["TenantConnections"]["TenantConnectionsItem"]; for (auto tenantNodeTenantConnectionsTenantConnectionsItem : allTenantConnectionsNode) { @@ -158,6 +162,8 @@ void DescribeTenantResult::parse(const std::string &payload) tenantConnectionsItemObject.intranetSqlPort = std::stoi(tenantNodeTenantConnectionsTenantConnectionsItem["IntranetSqlPort"].asString()); if(!tenantNodeTenantConnectionsTenantConnectionsItem["OdpVersion"].isNull()) tenantConnectionsItemObject.odpVersion = tenantNodeTenantConnectionsTenantConnectionsItem["OdpVersion"].asString(); + if(!tenantNodeTenantConnectionsTenantConnectionsItem["InternetSqlPort"].isNull()) + tenantConnectionsItemObject.internetSqlPort = std::stoi(tenantNodeTenantConnectionsTenantConnectionsItem["InternetSqlPort"].asString()); auto allConnectionZones = value["ConnectionZones"]["ConnectionZones"]; for (auto value : allConnectionZones) tenantConnectionsItemObject.connectionZones.push_back(value.asString()); @@ -183,7 +189,7 @@ void DescribeTenantResult::parse(const std::string &payload) if(!tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["ZoneReplicaType"].isNull()) tenantZoneReplicasObject.zoneReplicaType = tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["ZoneReplicaType"].asString(); if(!tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["ZoneNodes"].isNull()) - tenantZoneReplicasObject.zoneNodes = tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["ZoneNodes"].asString(); + tenantZoneReplicasObject.zoneNodes = std::stol(tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["ZoneNodes"].asString()); if(!tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["LogicZoneName"].isNull()) tenantZoneReplicasObject.logicZoneName = tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["LogicZoneName"].asString(); if(!tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["ZoneCopyId"].isNull()) @@ -192,6 +198,8 @@ void DescribeTenantResult::parse(const std::string &payload) tenantZoneReplicasObject.fullCopyId = std::stoi(tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["FullCopyId"].asString()); if(!tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["ReadOnlyCopyId"].isNull()) tenantZoneReplicasObject.readOnlyCopyId = tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["ReadOnlyCopyId"].asString(); + if(!tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["ReadOnlyReplicaType"].isNull()) + tenantZoneReplicasObject.readOnlyReplicaType = tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["ReadOnlyReplicaType"].asString(); tenantZonesItemObject.tenantZoneReplicas.push_back(tenantZoneReplicasObject); } tenant_.tenantZones.push_back(tenantZonesItemObject); diff --git a/oceanbasepro/src/model/DescribeTenantUserRolesRequest.cc b/oceanbasepro/src/model/DescribeTenantUserRolesRequest.cc index 844143eb2..6e09552e9 100644 --- a/oceanbasepro/src/model/DescribeTenantUserRolesRequest.cc +++ b/oceanbasepro/src/model/DescribeTenantUserRolesRequest.cc @@ -25,6 +25,15 @@ DescribeTenantUserRolesRequest::DescribeTenantUserRolesRequest() DescribeTenantUserRolesRequest::~DescribeTenantUserRolesRequest() {} +std::string DescribeTenantUserRolesRequest::getInstanceId() const { + return instanceId_; +} + +void DescribeTenantUserRolesRequest::setInstanceId(const std::string &instanceId) { + instanceId_ = instanceId; + setBodyParameter(std::string("InstanceId"), instanceId); +} + std::string DescribeTenantUserRolesRequest::getTenantId() const { return tenantId_; } diff --git a/oceanbasepro/src/model/DescribeTenantUsersResult.cc b/oceanbasepro/src/model/DescribeTenantUsersResult.cc index 13f6f5b33..471a6c66c 100644 --- a/oceanbasepro/src/model/DescribeTenantUsersResult.cc +++ b/oceanbasepro/src/model/DescribeTenantUsersResult.cc @@ -55,6 +55,8 @@ void DescribeTenantUsersResult::parse(const std::string &payload) tenantUsersObject.tenantId = valueTenantUsersTenantUsersItem["TenantId"].asString(); if(!valueTenantUsersTenantUsersItem["InstanceId"].isNull()) tenantUsersObject.instanceId = valueTenantUsersTenantUsersItem["InstanceId"].asString(); + if(!valueTenantUsersTenantUsersItem["GlobalPermissions"].isNull()) + tenantUsersObject.globalPermissions = valueTenantUsersTenantUsersItem["GlobalPermissions"].asString(); auto allDatabasesNode = valueTenantUsersTenantUsersItem["Databases"]["DatabasesItem"]; for (auto valueTenantUsersTenantUsersItemDatabasesDatabasesItem : allDatabasesNode) { diff --git a/oceanbasepro/src/model/DescribeTenantsResult.cc b/oceanbasepro/src/model/DescribeTenantsResult.cc index 71573467e..87f08bd9a 100644 --- a/oceanbasepro/src/model/DescribeTenantsResult.cc +++ b/oceanbasepro/src/model/DescribeTenantsResult.cc @@ -81,6 +81,8 @@ void DescribeTenantsResult::parse(const std::string &payload) tenantsObject.collation = valueTenantsData["Collation"].asString(); if(!valueTenantsData["EnableReadOnlyReplica"].isNull()) tenantsObject.enableReadOnlyReplica = valueTenantsData["EnableReadOnlyReplica"].asString() == "true"; + if(!valueTenantsData["ParameterTemplate"].isNull()) + tenantsObject.parameterTemplate = valueTenantsData["ParameterTemplate"].asString(); tenants_.push_back(tenantsObject); } if(!value["TotalCount"].isNull()) diff --git a/oceanbasepro/src/model/ModifyInstanceSSLRequest.cc b/oceanbasepro/src/model/ModifyInstanceSSLRequest.cc index 2ef4b16bf..aea86df10 100644 --- a/oceanbasepro/src/model/ModifyInstanceSSLRequest.cc +++ b/oceanbasepro/src/model/ModifyInstanceSSLRequest.cc @@ -43,3 +43,12 @@ void ModifyInstanceSSLRequest::setEnableSSL(const std::string &enableSSL) { setBodyParameter(std::string("EnableSSL"), enableSSL); } +std::string ModifyInstanceSSLRequest::getTenantId() const { + return tenantId_; +} + +void ModifyInstanceSSLRequest::setTenantId(const std::string &tenantId) { + tenantId_ = tenantId; + setBodyParameter(std::string("TenantId"), tenantId); +} + diff --git a/oceanbasepro/src/model/ModifyInstanceSSLResult.cc b/oceanbasepro/src/model/ModifyInstanceSSLResult.cc index 0d904386a..618fbb4a9 100644 --- a/oceanbasepro/src/model/ModifyInstanceSSLResult.cc +++ b/oceanbasepro/src/model/ModifyInstanceSSLResult.cc @@ -44,6 +44,8 @@ void ModifyInstanceSSLResult::parse(const std::string &payload) instanceSSL_.instanceId = instanceSSLNode["InstanceId"].asString(); if(!instanceSSLNode["EnableSSL"].isNull()) instanceSSL_.enableSSL = instanceSSLNode["EnableSSL"].asString(); + if(!instanceSSLNode["TenantId"].isNull()) + instanceSSL_.tenantId = instanceSSLNode["TenantId"].asString(); } diff --git a/oceanbasepro/src/model/ModifyTenantUserRolesRequest.cc b/oceanbasepro/src/model/ModifyTenantUserRolesRequest.cc index 1296cc074..02b4d83f1 100644 --- a/oceanbasepro/src/model/ModifyTenantUserRolesRequest.cc +++ b/oceanbasepro/src/model/ModifyTenantUserRolesRequest.cc @@ -25,6 +25,15 @@ ModifyTenantUserRolesRequest::ModifyTenantUserRolesRequest() ModifyTenantUserRolesRequest::~ModifyTenantUserRolesRequest() {} +std::string ModifyTenantUserRolesRequest::getUserType() const { + return userType_; +} + +void ModifyTenantUserRolesRequest::setUserType(const std::string &userType) { + userType_ = userType; + setBodyParameter(std::string("UserType"), userType); +} + std::string ModifyTenantUserRolesRequest::getUserRole() const { return userRole_; } @@ -52,6 +61,15 @@ void ModifyTenantUserRolesRequest::setModifyType(const std::string &modifyType) setBodyParameter(std::string("ModifyType"), modifyType); } +std::string ModifyTenantUserRolesRequest::getGlobalPermissions() const { + return globalPermissions_; +} + +void ModifyTenantUserRolesRequest::setGlobalPermissions(const std::string &globalPermissions) { + globalPermissions_ = globalPermissions; + setBodyParameter(std::string("GlobalPermissions"), globalPermissions); +} + std::string ModifyTenantUserRolesRequest::getTenantId() const { return tenantId_; } diff --git a/oceanbasepro/src/model/RemoveStandbyInstanceRequest.cc b/oceanbasepro/src/model/RemoveStandbyInstanceRequest.cc new file mode 100644 index 000000000..414b30cdf --- /dev/null +++ b/oceanbasepro/src/model/RemoveStandbyInstanceRequest.cc @@ -0,0 +1,54 @@ +/* + * Copyright 2009-2017 Alibaba Cloud All rights reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include + +using AlibabaCloud::OceanBasePro::Model::RemoveStandbyInstanceRequest; + +RemoveStandbyInstanceRequest::RemoveStandbyInstanceRequest() + : RpcServiceRequest("oceanbasepro", "2019-09-01", "RemoveStandbyInstance") { + setMethod(HttpRequest::Method::Post); +} + +RemoveStandbyInstanceRequest::~RemoveStandbyInstanceRequest() {} + +bool RemoveStandbyInstanceRequest::getForced() const { + return forced_; +} + +void RemoveStandbyInstanceRequest::setForced(bool forced) { + forced_ = forced; + setBodyParameter(std::string("Forced"), forced ? "true" : "false"); +} + +std::string RemoveStandbyInstanceRequest::getInstanceId() const { + return instanceId_; +} + +void RemoveStandbyInstanceRequest::setInstanceId(const std::string &instanceId) { + instanceId_ = instanceId; + setBodyParameter(std::string("InstanceId"), instanceId); +} + +std::string RemoveStandbyInstanceRequest::getTargetInstanceId() const { + return targetInstanceId_; +} + +void RemoveStandbyInstanceRequest::setTargetInstanceId(const std::string &targetInstanceId) { + targetInstanceId_ = targetInstanceId; + setBodyParameter(std::string("TargetInstanceId"), targetInstanceId); +} + diff --git a/oceanbasepro/src/model/RemoveStandbyInstanceResult.cc b/oceanbasepro/src/model/RemoveStandbyInstanceResult.cc new file mode 100644 index 000000000..8846eebcf --- /dev/null +++ b/oceanbasepro/src/model/RemoveStandbyInstanceResult.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::OceanBasePro; +using namespace AlibabaCloud::OceanBasePro::Model; + +RemoveStandbyInstanceResult::RemoveStandbyInstanceResult() : + ServiceResult() +{} + +RemoveStandbyInstanceResult::RemoveStandbyInstanceResult(const std::string &payload) : + ServiceResult() +{ + parse(payload); +} + +RemoveStandbyInstanceResult::~RemoveStandbyInstanceResult() +{} + +void RemoveStandbyInstanceResult::parse(const std::string &payload) +{ + Json::Reader reader; + Json::Value value; + reader.parse(payload, value); + setRequestId(value["RequestId"].asString()); + +} + diff --git a/oceanbasepro/src/model/UpdateProjectConfigRequest.cc b/oceanbasepro/src/model/UpdateProjectConfigRequest.cc index 226a8038d..bf1c12591 100644 --- a/oceanbasepro/src/model/UpdateProjectConfigRequest.cc +++ b/oceanbasepro/src/model/UpdateProjectConfigRequest.cc @@ -58,8 +58,10 @@ UpdateProjectConfigRequest::FullTransferConfig UpdateProjectConfigRequest::getFu void UpdateProjectConfigRequest::setFullTransferConfig(const UpdateProjectConfigRequest::FullTransferConfig &fullTransferConfig) { fullTransferConfig_ = fullTransferConfig; + setBodyParameter(std::string("FullTransferConfig") + ".IndexDDLConcurrencyLimit", std::to_string(fullTransferConfig.indexDDLConcurrencyLimit)); setBodyParameter(std::string("FullTransferConfig") + ".ThrottleRps", std::to_string(fullTransferConfig.throttleRps)); setBodyParameter(std::string("FullTransferConfig") + ".WriteWorkerNum", std::to_string(fullTransferConfig.writeWorkerNum)); + setBodyParameter(std::string("FullTransferConfig") + ".MaxConcurrentIndexDDLs", std::to_string(fullTransferConfig.maxConcurrentIndexDDLs)); setBodyParameter(std::string("FullTransferConfig") + ".ReadWorkerNum", std::to_string(fullTransferConfig.readWorkerNum)); setBodyParameter(std::string("FullTransferConfig") + ".ThrottleIOPS", std::to_string(fullTransferConfig.throttleIOPS)); }