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

Generated 2019-09-01 for OceanBasePro.

Browse Source
This commit is contained in:
sdk-team
2025-06-11 09:27:26 +00:00
parent d2887a4adc
commit 2616afb389
87 changed files with 2640 additions and 71 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
VERSION
View File

@@ -1 +1 @@
1.36.2075
1.36.2076

20
oceanbasepro/CMakeLists.txt
View File

@@ -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

40
oceanbasepro/include/alibabacloud/oceanbasepro/OceanBaseProClient.h
View File

@@ -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<Error, Model::CreateMySqlDataSourceResult> CreateMySqlDataSourceOutcome;
typedef std::future<CreateMySqlDataSourceOutcome> CreateMySqlDataSourceOutcomeCallable;
typedef std::function<void(const OceanBaseProClient*, const Model::CreateMySqlDataSourceRequest&, const CreateMySqlDataSourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateMySqlDataSourceAsyncHandler;
typedef Outcome<Error, Model::CreateOasOutlineTaskResult> CreateOasOutlineTaskOutcome;
typedef std::future<CreateOasOutlineTaskOutcome> CreateOasOutlineTaskOutcomeCallable;
typedef std::function<void(const OceanBaseProClient*, const Model::CreateOasOutlineTaskRequest&, const CreateOasOutlineTaskOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateOasOutlineTaskAsyncHandler;
typedef Outcome<Error, Model::CreateOceanBaseDataSourceResult> CreateOceanBaseDataSourceOutcome;
typedef std::future<CreateOceanBaseDataSourceOutcome> CreateOceanBaseDataSourceOutcomeCallable;
typedef std::function<void(const OceanBaseProClient*, const Model::CreateOceanBaseDataSourceRequest&, const CreateOceanBaseDataSourceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> CreateOceanBaseDataSourceAsyncHandler;
@@ -422,6 +435,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DescribeInstanceResult> DescribeInstanceOutcome;
typedef std::future<DescribeInstanceOutcome> DescribeInstanceOutcomeCallable;
typedef std::function<void(const OceanBaseProClient*, const Model::DescribeInstanceRequest&, const DescribeInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeInstanceAsyncHandler;
typedef Outcome<Error, Model::DescribeInstanceAvailableZonesResult> DescribeInstanceAvailableZonesOutcome;
typedef std::future<DescribeInstanceAvailableZonesOutcome> DescribeInstanceAvailableZonesOutcomeCallable;
typedef std::function<void(const OceanBaseProClient*, const Model::DescribeInstanceAvailableZonesRequest&, const DescribeInstanceAvailableZonesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeInstanceAvailableZonesAsyncHandler;
typedef Outcome<Error, Model::DescribeInstanceCreatableZoneResult> DescribeInstanceCreatableZoneOutcome;
typedef std::future<DescribeInstanceCreatableZoneOutcome> DescribeInstanceCreatableZoneOutcomeCallable;
typedef std::function<void(const OceanBaseProClient*, const Model::DescribeInstanceCreatableZoneRequest&, const DescribeInstanceCreatableZoneOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeInstanceCreatableZoneAsyncHandler;
@@ -497,6 +513,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DescribeProjectStepsResult> DescribeProjectStepsOutcome;
typedef std::future<DescribeProjectStepsOutcome> DescribeProjectStepsOutcomeCallable;
typedef std::function<void(const OceanBaseProClient*, const Model::DescribeProjectStepsRequest&, const DescribeProjectStepsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeProjectStepsAsyncHandler;
typedef Outcome<Error, Model::DescribeProxyServiceResult> DescribeProxyServiceOutcome;
typedef std::future<DescribeProxyServiceOutcome> DescribeProxyServiceOutcomeCallable;
typedef std::function<void(const OceanBaseProClient*, const Model::DescribeProxyServiceRequest&, const DescribeProxyServiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeProxyServiceAsyncHandler;
typedef Outcome<Error, Model::DescribeRecommendIndexResult> DescribeRecommendIndexOutcome;
typedef std::future<DescribeRecommendIndexOutcome> DescribeRecommendIndexOutcomeCallable;
typedef std::function<void(const OceanBaseProClient*, const Model::DescribeRecommendIndexRequest&, const DescribeRecommendIndexOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRecommendIndexAsyncHandler;
@@ -533,6 +552,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::DescribeSlowSQLListResult> DescribeSlowSQLListOutcome;
typedef std::future<DescribeSlowSQLListOutcome> DescribeSlowSQLListOutcomeCallable;
typedef std::function<void(const OceanBaseProClient*, const Model::DescribeSlowSQLListRequest&, const DescribeSlowSQLListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSlowSQLListAsyncHandler;
typedef Outcome<Error, Model::DescribeSqlAuditStatResult> DescribeSqlAuditStatOutcome;
typedef std::future<DescribeSqlAuditStatOutcome> DescribeSqlAuditStatOutcomeCallable;
typedef std::function<void(const OceanBaseProClient*, const Model::DescribeSqlAuditStatRequest&, const DescribeSqlAuditStatOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSqlAuditStatAsyncHandler;
typedef Outcome<Error, Model::DescribeStandbyCreateModeResult> DescribeStandbyCreateModeOutcome;
typedef std::future<DescribeStandbyCreateModeOutcome> DescribeStandbyCreateModeOutcomeCallable;
typedef std::function<void(const OceanBaseProClient*, const Model::DescribeStandbyCreateModeRequest&, const DescribeStandbyCreateModeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeStandbyCreateModeAsyncHandler;
@@ -674,6 +696,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::ReleaseWorkerInstanceResult> ReleaseWorkerInstanceOutcome;
typedef std::future<ReleaseWorkerInstanceOutcome> ReleaseWorkerInstanceOutcomeCallable;
typedef std::function<void(const OceanBaseProClient*, const Model::ReleaseWorkerInstanceRequest&, const ReleaseWorkerInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ReleaseWorkerInstanceAsyncHandler;
typedef Outcome<Error, Model::RemoveStandbyInstanceResult> RemoveStandbyInstanceOutcome;
typedef std::future<RemoveStandbyInstanceOutcome> RemoveStandbyInstanceOutcomeCallable;
typedef std::function<void(const OceanBaseProClient*, const Model::RemoveStandbyInstanceRequest&, const RemoveStandbyInstanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RemoveStandbyInstanceAsyncHandler;
typedef Outcome<Error, Model::ResumeProjectResult> ResumeProjectOutcome;
typedef std::future<ResumeProjectOutcome> ResumeProjectOutcomeCallable;
typedef std::function<void(const OceanBaseProClient*, const Model::ResumeProjectRequest&, const ResumeProjectOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& 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<const AsyncCallerContext>& context = nullptr) const;
ResumeProjectOutcomeCallable resumeProjectCallable(const Model::ResumeProjectRequest& request) const;

3
oceanbasepro/include/alibabacloud/oceanbasepro/model/BatchKillProcessListRequest.h
View File

@@ -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_;
};

87
oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateOasOutlineTaskRequest.h Normal file
View File

@@ -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 <alibabacloud/oceanbasepro/OceanBaseProExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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_

53
oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateOasOutlineTaskResult.h Normal file
View File

@@ -0,0 +1,53 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OCEANBASEPRO_MODEL_CREATEOASOUTLINETASKRESULT_H_
#define ALIBABACLOUD_OCEANBASEPRO_MODEL_CREATEOASOUTLINETASKRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/oceanbasepro/OceanBaseProExport.h>
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_

363
oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateProjectModifyRecordsRequest.h
View File

@@ -55,6 +55,12 @@ public:
std::string mappedName;
std::string string;
std::vector<std::string> filterColumns;
struct ObkvPartitionConfig {
std::string virtualColumn;
std::string partitionType;
int partitionSize;
};
ObkvPartitionConfig obkvPartitionConfig;
struct AdbTableSchema {
std::string string;
std::vector<std::string> primaryKeys;
@@ -117,15 +123,372 @@ public:
ViewsItem viewsItem;
std::vector<ViewsItem> views;
};
struct TransferMapping {
std::string mode;
struct DatabasesItem {
std::string mappedName;
struct SpecificViewsItem {
std::string mappedName;
std::string string;
std::vector<std::string> filterColumns;
struct AdbTableSchema {
std::string string;
std::vector<std::string> primaryKeys;
std::string partitionStatement;
std::string partitionLifeCycle;
std::string string;
std::vector<std::string> distributedKeys;
};
AdbTableSchema adbTableSchema;
std::string name;
std::string whereClause;
std::string id;
std::string string;
std::vector<std::string> shardColumns;
};
SpecificViewsItem specificViewsItem;
std::vector<SpecificViewsItem> specificViews;
struct TablesItem {
std::string mappedName;
std::string string;
std::vector<std::string> filterColumns;
struct ObkvPartitionConfig {
std::string virtualColumn;
std::string partitionType;
int partitionSize;
};
ObkvPartitionConfig obkvPartitionConfig;
struct AdbTableSchema {
std::string string;
std::vector<std::string> primaryKeys;
std::string partitionStatement;
std::string partitionLifeCycle;
std::string string;
std::vector<std::string> distributedKeys;
};
AdbTableSchema adbTableSchema;
std::string name;
std::string whereClause;
std::string id;
std::string string;
std::vector<std::string> shardColumns;
};
TablesItem tablesItem;
std::vector<TablesItem> tables;
std::string clusterName;
std::string name;
std::string tenantName;
std::string id;
struct SpecificTablesItem {
std::string mappedName;
std::string string;
std::vector<std::string> filterColumns;
struct AdbTableSchema {
std::string string;
std::vector<std::string> primaryKeys;
std::string partitionStatement;
std::string partitionLifeCycle;
std::string string;
std::vector<std::string> distributedKeys;
};
AdbTableSchema adbTableSchema;
std::string name;
std::string whereClause;
std::string id;
std::string string;
std::vector<std::string> shardColumns;
};
SpecificTablesItem specificTablesItem;
std::vector<SpecificTablesItem> specificTables;
struct ViewsItem {
std::string mappedName;
std::string string;
std::vector<std::string> filterColumns;
struct AdbTableSchema {
std::string string;
std::vector<std::string> primaryKeys;
std::string partitionStatement;
std::string partitionLifeCycle;
std::string string;
std::vector<std::string> distributedKeys;
};
AdbTableSchema adbTableSchema;
std::string name;
std::string whereClause;
std::string id;
std::string string;
std::vector<std::string> shardColumns;
};
ViewsItem viewsItem;
std::vector<ViewsItem> views;
};
DatabasesItem databasesItem;
std::vector<DatabasesItem> databases;
std::string string;
std::vector<std::string> 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<BlackTableRulesItem> blackTableRules;
struct SchemasItem {
std::string mappedName;
struct SpecificViewsItem {
std::string mappedName;
std::string string;
std::vector<std::string> filterColumns;
struct AdbTableSchema {
std::string string;
std::vector<std::string> primaryKeys;
std::string partitionStatement;
std::string partitionLifeCycle;
std::string string;
std::vector<std::string> distributedKeys;
};
AdbTableSchema adbTableSchema;
std::string name;
std::string whereClause;
std::string id;
std::string string;
std::vector<std::string> shardColumns;
};
SpecificViewsItem specificViewsItem;
std::vector<SpecificViewsItem> specificViews;
struct TablesItem {
std::string mappedName;
std::string string;
std::vector<std::string> filterColumns;
struct ObkvPartitionConfig {
std::string virtualColumn;
std::string partitionType;
int partitionSize;
};
ObkvPartitionConfig obkvPartitionConfig;
struct AdbTableSchema {
std::string string;
std::vector<std::string> primaryKeys;
std::string partitionStatement;
std::string partitionLifeCycle;
std::string string;
std::vector<std::string> distributedKeys;
};
AdbTableSchema adbTableSchema;
std::string name;
std::string whereClause;
std::string id;
std::string string;
std::vector<std::string> shardColumns;
};
TablesItem tablesItem;
std::vector<TablesItem> tables;
std::string clusterName;
std::string name;
std::string tenantName;
std::string id;
struct SpecificTablesItem {
std::string mappedName;
std::string string;
std::vector<std::string> filterColumns;
struct AdbTableSchema {
std::string string;
std::vector<std::string> primaryKeys;
std::string partitionStatement;
std::string partitionLifeCycle;
std::string string;
std::vector<std::string> distributedKeys;
};
AdbTableSchema adbTableSchema;
std::string name;
std::string whereClause;
std::string id;
std::string string;
std::vector<std::string> shardColumns;
};
SpecificTablesItem specificTablesItem;
std::vector<SpecificTablesItem> specificTables;
struct ViewsItem {
std::string mappedName;
std::string string;
std::vector<std::string> filterColumns;
struct AdbTableSchema {
std::string string;
std::vector<std::string> primaryKeys;
std::string partitionStatement;
std::string partitionLifeCycle;
std::string string;
std::vector<std::string> distributedKeys;
};
AdbTableSchema adbTableSchema;
std::string name;
std::string whereClause;
std::string id;
std::string string;
std::vector<std::string> shardColumns;
};
ViewsItem viewsItem;
std::vector<ViewsItem> views;
};
SchemasItem schemasItem;
std::vector<SchemasItem> 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<BlackViewRulesItem> blackViewRules;
struct DatabasesBlackItem {
std::string mappedName;
struct SpecificViewsItem {
std::string mappedName;
std::string string;
std::vector<std::string> filterColumns;
struct AdbTableSchema {
std::string string;
std::vector<std::string> primaryKeys;
std::string partitionStatement;
std::string partitionLifeCycle;
std::string string;
std::vector<std::string> distributedKeys;
};
AdbTableSchema adbTableSchema;
std::string name;
std::string whereClause;
std::string id;
std::string string;
std::vector<std::string> shardColumns;
};
SpecificViewsItem specificViewsItem;
std::vector<SpecificViewsItem> specificViews;
struct TablesItem {
std::string mappedName;
std::string string;
std::vector<std::string> filterColumns;
struct AdbTableSchema {
std::string string;
std::vector<std::string> primaryKeys;
std::string partitionStatement;
std::string partitionLifeCycle;
std::string string;
std::vector<std::string> distributedKeys;
};
AdbTableSchema adbTableSchema;
std::string name;
std::string whereClause;
std::string id;
std::string string;
std::vector<std::string> shardColumns;
};
TablesItem tablesItem;
std::vector<TablesItem> tables;
std::string clusterName;
std::string name;
std::string tenantName;
std::string id;
struct SpecificTablesItem {
std::string mappedName;
std::string string;
std::vector<std::string> filterColumns;
struct AdbTableSchema {
std::string string;
std::vector<std::string> primaryKeys;
std::string partitionStatement;
std::string partitionLifeCycle;
std::string string;
std::vector<std::string> distributedKeys;
};
AdbTableSchema adbTableSchema;
std::string name;
std::string whereClause;
std::string id;
std::string string;
std::vector<std::string> shardColumns;
};
SpecificTablesItem specificTablesItem;
std::vector<SpecificTablesItem> specificTables;
struct ViewsItem {
std::string mappedName;
std::string string;
std::vector<std::string> filterColumns;
struct AdbTableSchema {
std::string string;
std::vector<std::string> primaryKeys;
std::string partitionStatement;
std::string partitionLifeCycle;
std::string string;
std::vector<std::string> distributedKeys;
};
AdbTableSchema adbTableSchema;
std::string name;
std::string whereClause;
std::string id;
std::string string;
std::vector<std::string> shardColumns;
};
ViewsItem viewsItem;
std::vector<ViewsItem> views;
};
DatabasesBlackItem databasesBlackItem;
std::vector<DatabasesBlackItem> 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<WhiteTableRulesItem> 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<WhiteViewRulesItem> whiteViewRules;
std::string string;
std::vector<std::string> tableAndViewWhiteList;
};
CreateProjectModifyRecordsRequest();
~CreateProjectModifyRecordsRequest();
std::vector<Databases> getDatabases() const;
void setDatabases(const std::vector<Databases> &databases);
TransferMapping getTransferMapping() const;
void setTransferMapping(const TransferMapping &transferMapping);
std::string getId() const;
void setId(const std::string &id);
private:
std::vector<Databases> databases_;
TransferMapping transferMapping_;
std::string id_;
};
} // namespace Model

10
oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateProjectRequest.h
View File

@@ -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<std::string> filterColumns;
struct ObkvPartitionConfig {
std::string virtualColumn;
std::string partitionType;
int partitionSize;
};
ObkvPartitionConfig obkvPartitionConfig;
struct AdbTableSchema {
std::string string;
std::vector<std::string> primaryKeys;

3
oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateTenantUserRequest.h
View File

@@ -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_;

1
oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateTenantUserResult.h
View File

@@ -40,6 +40,7 @@ namespace AlibabaCloud
std::string database;
};
std::string userName;
std::string globalPermissions;
std::vector<RolesItem> roles;
std::string userType;
std::string userStatus;

2
oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeDataBackupSetResult.h
View File

@@ -75,7 +75,7 @@ namespace AlibabaCloud
int dataSize;
int dataVersion;
std::vector<DataItem::BackupResultsItem> backupResults;
int setId;
std::string setId;
};

42
oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceAvailableZonesRequest.h Normal file
View File

@@ -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 <alibabacloud/oceanbasepro/OceanBaseProExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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_

58
oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceAvailableZonesResult.h Normal file
View File

@@ -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 <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/oceanbasepro/OceanBaseProExport.h>
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<ZoneListItem> getZoneList()const;
protected:
void parse(const std::string &payload);
private:
std::vector<ZoneListItem> zoneList_;
};
}
}
}
#endif // !ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBEINSTANCEAVAILABLEZONESRESULT_H_

3
oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceCreatableZoneResult.h
View File

@@ -34,8 +34,11 @@ namespace AlibabaCloud
public:
struct ZoneListItem
{
long replicateZoneIndex;
bool isInCluster;
std::string zone;
std::string logicalZoneName;
std::string fullCopyId;
};

3
oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceRequest.h
View File

@@ -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

3
oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceSSLRequest.h
View File

@@ -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

2
oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceSSLResult.h
View File

@@ -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;
};

10
oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceSummaryResult.h
View File

@@ -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;

4
oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceTopologyResult.h
View File

@@ -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<TenantsItem> tenants;

9
oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstancesRequest.h
View File

@@ -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

20
oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstancesResult.h
View File

@@ -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;

2
oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeOasAnomalySQLListResult.h
View File

@@ -40,7 +40,7 @@ namespace AlibabaCloud
double executions;
double sumDbTime;
std::string userName;
double lastExecutedTime;
std::string lastExecutedTime;
float avgRetryCount;
double avgGetPlanTime;
double cpuTime;

1
oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeOasSQLHistoryListResult.h
View File

@@ -98,6 +98,7 @@ namespace AlibabaCloud
double avgScheduleTime;
double maxConcurrencyWaitTime;
double missPlanPercentage;
std::string waitEvent;
double retCode4012Count;
double avgElapsedTime;
double failPercentage;

1
oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeOasSQLPlansResult.h
View File

@@ -65,6 +65,7 @@ namespace AlibabaCloud
std::string firstLoadTime;
double avgRowProcessed;
std::string planUnionHash;
std::string sqlText;
long mergedVersion;
bool hitDiagnosis;
std::string sqlId;

3
oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeOasTopSQLListRequest.h
View File

@@ -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_;

7
oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeOasTopSQLListResult.h
View File

@@ -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;

2
oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeOutlineBindingResult.h
View File

@@ -36,7 +36,9 @@ namespace AlibabaCloud
{
std::string tableName;
int maxConcurrent;
std::string sqlText;
long outlineId;
long sqlTextConcurrentNum;
std::string bindPlan;
std::string bindIndex;
};

8
oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeParametersHistoryResult.h
View File

@@ -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<Data::ParametersItem> parameters;
std::vector<ParametersItem> parameters;
int pageNumber;
};
@@ -53,12 +53,12 @@ namespace AlibabaCloud
DescribeParametersHistoryResult();
explicit DescribeParametersHistoryResult(const std::string &payload);
~DescribeParametersHistoryResult();
std::vector<Data> getRespond()const;
Respond getRespond()const;
protected:
void parse(const std::string &payload);
private:
std::vector<Data> respond_;
Respond respond_;
};
}

3
oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeProcessStatsCompositionRequest.h
View File

@@ -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_;

42
oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeProcessStatsCompositionResult.h
View File

@@ -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<ProcessSqlListsItem::ProcessSqlListItem> 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<AllProcessListItem::ProcessSqlListsItem> processSqlLists;
long cpuTime;
std::string clientIp;
std::string sqlId;
std::string tenantId;
std::string serverSn;
std::string command;
std::string database;
std::string traceId;

42
oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeProxyServiceRequest.h Normal file
View File

@@ -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 <alibabacloud/oceanbasepro/OceanBaseProExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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_

67
oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeProxyServiceResult.h Normal file
View File

@@ -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 <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/oceanbasepro/OceanBaseProExport.h>
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_

3
oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeSampleSqlRawTextsRequest.h
View File

@@ -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_;

57
oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeSqlAuditStatRequest.h Normal file
View File

@@ -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 <alibabacloud/oceanbasepro/OceanBaseProExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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_

71
oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeSqlAuditStatResult.h Normal file
View File

@@ -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 <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/oceanbasepro/OceanBaseProExport.h>
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<DataItem> getData()const;
protected:
void parse(const std::string &payload);
private:
std::vector<DataItem> data_;
};
}
}
}
#endif // !ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBESQLAUDITSTATRESULT_H_

6
oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantResult.h
View File

@@ -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;
};

3
oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantUserRolesRequest.h
View File

@@ -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

1
oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantUsersResult.h
View File

@@ -46,6 +46,7 @@ namespace AlibabaCloud
std::string description;
std::string userName;
std::string instanceId;
std::string globalPermissions;
std::string userType;
std::string userStatus;
};

1
oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantsResult.h
View File

@@ -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;

3
oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceSSLRequest.h
View File

@@ -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

1
oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceSSLResult.h
View File

@@ -35,6 +35,7 @@ namespace AlibabaCloud
struct InstanceSSL
{
std::string enableSSL;
std::string tenantId;
std::string instanceId;
};

6
oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyTenantUserRolesRequest.h
View File

@@ -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_;
};

48
oceanbasepro/include/alibabacloud/oceanbasepro/model/RemoveStandbyInstanceRequest.h Normal file
View File

@@ -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 <alibabacloud/oceanbasepro/OceanBaseProExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
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_

49
oceanbasepro/include/alibabacloud/oceanbasepro/model/RemoveStandbyInstanceResult.h Normal file
View File

@@ -0,0 +1,49 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OCEANBASEPRO_MODEL_REMOVESTANDBYINSTANCERESULT_H_
#define ALIBABACLOUD_OCEANBASEPRO_MODEL_REMOVESTANDBYINSTANCERESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/oceanbasepro/OceanBaseProExport.h>
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_

2
oceanbasepro/include/alibabacloud/oceanbasepro/model/UpdateProjectConfigRequest.h
View File

@@ -42,8 +42,10 @@ public:
int incrSyncThreadCount;
};
struct FullTransferConfig {
int indexDDLConcurrencyLimit;
int throttleRps;
int writeWorkerNum;
int maxConcurrentIndexDDLs;
int readWorkerNum;
int throttleIOPS;
};

180
oceanbasepro/src/OceanBaseProClient.cc
View File

@@ -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<const AsyncCallerContext>& 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<std::packaged_task<CreateOasOutlineTaskOutcome()>>(
[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<const AsyncCallerContext>& 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<std::packaged_task<DescribeInstanceAvailableZonesOutcome()>>(
[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<const AsyncCallerContext>& 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<std::packaged_task<DescribeProxyServiceOutcome()>>(
[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<const AsyncCallerContext>& 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<std::packaged_task<DescribeSqlAuditStatOutcome()>>(
[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<const AsyncCallerContext>& 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<std::packaged_task<RemoveStandbyInstanceOutcome()>>(
[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();

9
oceanbasepro/src/model/BatchKillProcessListRequest.cc
View File

@@ -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_;
}

171
oceanbasepro/src/model/CreateOasOutlineTaskRequest.cc Normal file
View File

@@ -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 <alibabacloud/oceanbasepro/model/CreateOasOutlineTaskRequest.h>
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");
}

58
oceanbasepro/src/model/CreateOasOutlineTaskResult.cc Normal file
View File

@@ -0,0 +1,58 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/oceanbasepro/model/CreateOasOutlineTaskResult.h>
#include <json/json.h>
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_;
}

309
oceanbasepro/src/model/CreateProjectModifyRecordsRequest.cc
View File

@@ -58,6 +58,9 @@ void CreateProjectModifyRecordsRequest::setDatabases(const std::vector<CreatePro
for(int dep3 = 0; dep3 != databases[dep1].tables[dep2].filterColumns.size(); dep3++) {
setBodyParameter(std::string("Databases") + "." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".FilterColumns." + std::to_string(dep3 + 1), databases[dep1].tables[dep2].filterColumns[dep3]);
}
setBodyParameter(std::string("Databases") + "." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".ObkvPartitionConfig.VirtualColumn", databases[dep1].tables[dep2].obkvPartitionConfig.virtualColumn);
setBodyParameter(std::string("Databases") + "." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".ObkvPartitionConfig.PartitionType", databases[dep1].tables[dep2].obkvPartitionConfig.partitionType);
setBodyParameter(std::string("Databases") + "." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".ObkvPartitionConfig.PartitionSize", std::to_string(databases[dep1].tables[dep2].obkvPartitionConfig.partitionSize));
for(int dep3 = 0; dep3 != databases[dep1].tables[dep2].adbTableSchema.primaryKeys.size(); dep3++) {
setBodyParameter(std::string("Databases") + "." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".AdbTableSchema.PrimaryKeys." + std::to_string(dep3 + 1), databases[dep1].tables[dep2].adbTableSchema.primaryKeys[dep3]);
}
@@ -118,6 +121,312 @@ void CreateProjectModifyRecordsRequest::setDatabases(const std::vector<CreatePro
}
}
CreateProjectModifyRecordsRequest::TransferMapping CreateProjectModifyRecordsRequest::getTransferMapping() const {
return transferMapping_;
}
void CreateProjectModifyRecordsRequest::setTransferMapping(const CreateProjectModifyRecordsRequest::TransferMapping &transferMapping) {
transferMapping_ = transferMapping;
setBodyParameter(std::string("TransferMapping") + ".Mode", transferMapping.mode);
for(int dep1 = 0; dep1 != transferMapping.databases.size(); dep1++) {
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".MappedName", transferMapping.databases[dep1].mappedName);
for(int dep2 = 0; dep2 != transferMapping.databases[dep1].specificViews.size(); dep2++) {
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".SpecificViews." + std::to_string(dep2 + 1) + ".MappedName", transferMapping.databases[dep1].specificViews[dep2].mappedName);
for(int dep3 = 0; dep3 != transferMapping.databases[dep1].specificViews[dep2].filterColumns.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".SpecificViews." + std::to_string(dep2 + 1) + ".FilterColumns." + std::to_string(dep3 + 1), transferMapping.databases[dep1].specificViews[dep2].filterColumns[dep3]);
}
for(int dep3 = 0; dep3 != transferMapping.databases[dep1].specificViews[dep2].adbTableSchema.primaryKeys.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".SpecificViews." + std::to_string(dep2 + 1) + ".AdbTableSchema.PrimaryKeys." + std::to_string(dep3 + 1), transferMapping.databases[dep1].specificViews[dep2].adbTableSchema.primaryKeys[dep3]);
}
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".SpecificViews." + std::to_string(dep2 + 1) + ".AdbTableSchema.PartitionStatement", transferMapping.databases[dep1].specificViews[dep2].adbTableSchema.partitionStatement);
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".SpecificViews." + std::to_string(dep2 + 1) + ".AdbTableSchema.PartitionLifeCycle", transferMapping.databases[dep1].specificViews[dep2].adbTableSchema.partitionLifeCycle);
for(int dep3 = 0; dep3 != transferMapping.databases[dep1].specificViews[dep2].adbTableSchema.distributedKeys.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".SpecificViews." + std::to_string(dep2 + 1) + ".AdbTableSchema.DistributedKeys." + std::to_string(dep3 + 1), transferMapping.databases[dep1].specificViews[dep2].adbTableSchema.distributedKeys[dep3]);
}
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".SpecificViews." + std::to_string(dep2 + 1) + ".Name", transferMapping.databases[dep1].specificViews[dep2].name);
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".SpecificViews." + std::to_string(dep2 + 1) + ".WhereClause", transferMapping.databases[dep1].specificViews[dep2].whereClause);
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".SpecificViews." + std::to_string(dep2 + 1) + ".Id", transferMapping.databases[dep1].specificViews[dep2].id);
for(int dep3 = 0; dep3 != transferMapping.databases[dep1].specificViews[dep2].shardColumns.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".SpecificViews." + std::to_string(dep2 + 1) + ".ShardColumns." + std::to_string(dep3 + 1), transferMapping.databases[dep1].specificViews[dep2].shardColumns[dep3]);
}
}
for(int dep2 = 0; dep2 != transferMapping.databases[dep1].tables.size(); dep2++) {
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".MappedName", transferMapping.databases[dep1].tables[dep2].mappedName);
for(int dep3 = 0; dep3 != transferMapping.databases[dep1].tables[dep2].filterColumns.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".FilterColumns." + std::to_string(dep3 + 1), transferMapping.databases[dep1].tables[dep2].filterColumns[dep3]);
}
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".ObkvPartitionConfig.VirtualColumn", transferMapping.databases[dep1].tables[dep2].obkvPartitionConfig.virtualColumn);
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".ObkvPartitionConfig.PartitionType", transferMapping.databases[dep1].tables[dep2].obkvPartitionConfig.partitionType);
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".ObkvPartitionConfig.PartitionSize", std::to_string(transferMapping.databases[dep1].tables[dep2].obkvPartitionConfig.partitionSize));
for(int dep3 = 0; dep3 != transferMapping.databases[dep1].tables[dep2].adbTableSchema.primaryKeys.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".AdbTableSchema.PrimaryKeys." + std::to_string(dep3 + 1), transferMapping.databases[dep1].tables[dep2].adbTableSchema.primaryKeys[dep3]);
}
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".AdbTableSchema.PartitionStatement", transferMapping.databases[dep1].tables[dep2].adbTableSchema.partitionStatement);
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".AdbTableSchema.PartitionLifeCycle", transferMapping.databases[dep1].tables[dep2].adbTableSchema.partitionLifeCycle);
for(int dep3 = 0; dep3 != transferMapping.databases[dep1].tables[dep2].adbTableSchema.distributedKeys.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".AdbTableSchema.DistributedKeys." + std::to_string(dep3 + 1), transferMapping.databases[dep1].tables[dep2].adbTableSchema.distributedKeys[dep3]);
}
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".Name", transferMapping.databases[dep1].tables[dep2].name);
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".WhereClause", transferMapping.databases[dep1].tables[dep2].whereClause);
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".Id", transferMapping.databases[dep1].tables[dep2].id);
for(int dep3 = 0; dep3 != transferMapping.databases[dep1].tables[dep2].shardColumns.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".ShardColumns." + std::to_string(dep3 + 1), transferMapping.databases[dep1].tables[dep2].shardColumns[dep3]);
}
}
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".ClusterName", transferMapping.databases[dep1].clusterName);
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".Name", transferMapping.databases[dep1].name);
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".TenantName", transferMapping.databases[dep1].tenantName);
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".Id", transferMapping.databases[dep1].id);
for(int dep2 = 0; dep2 != transferMapping.databases[dep1].specificTables.size(); dep2++) {
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".SpecificTables." + std::to_string(dep2 + 1) + ".MappedName", transferMapping.databases[dep1].specificTables[dep2].mappedName);
for(int dep3 = 0; dep3 != transferMapping.databases[dep1].specificTables[dep2].filterColumns.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".SpecificTables." + std::to_string(dep2 + 1) + ".FilterColumns." + std::to_string(dep3 + 1), transferMapping.databases[dep1].specificTables[dep2].filterColumns[dep3]);
}
for(int dep3 = 0; dep3 != transferMapping.databases[dep1].specificTables[dep2].adbTableSchema.primaryKeys.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".SpecificTables." + std::to_string(dep2 + 1) + ".AdbTableSchema.PrimaryKeys." + std::to_string(dep3 + 1), transferMapping.databases[dep1].specificTables[dep2].adbTableSchema.primaryKeys[dep3]);
}
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".SpecificTables." + std::to_string(dep2 + 1) + ".AdbTableSchema.PartitionStatement", transferMapping.databases[dep1].specificTables[dep2].adbTableSchema.partitionStatement);
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".SpecificTables." + std::to_string(dep2 + 1) + ".AdbTableSchema.PartitionLifeCycle", transferMapping.databases[dep1].specificTables[dep2].adbTableSchema.partitionLifeCycle);
for(int dep3 = 0; dep3 != transferMapping.databases[dep1].specificTables[dep2].adbTableSchema.distributedKeys.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".SpecificTables." + std::to_string(dep2 + 1) + ".AdbTableSchema.DistributedKeys." + std::to_string(dep3 + 1), transferMapping.databases[dep1].specificTables[dep2].adbTableSchema.distributedKeys[dep3]);
}
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".SpecificTables." + std::to_string(dep2 + 1) + ".Name", transferMapping.databases[dep1].specificTables[dep2].name);
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".SpecificTables." + std::to_string(dep2 + 1) + ".WhereClause", transferMapping.databases[dep1].specificTables[dep2].whereClause);
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".SpecificTables." + std::to_string(dep2 + 1) + ".Id", transferMapping.databases[dep1].specificTables[dep2].id);
for(int dep3 = 0; dep3 != transferMapping.databases[dep1].specificTables[dep2].shardColumns.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".SpecificTables." + std::to_string(dep2 + 1) + ".ShardColumns." + std::to_string(dep3 + 1), transferMapping.databases[dep1].specificTables[dep2].shardColumns[dep3]);
}
}
for(int dep2 = 0; dep2 != transferMapping.databases[dep1].views.size(); dep2++) {
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".Views." + std::to_string(dep2 + 1) + ".MappedName", transferMapping.databases[dep1].views[dep2].mappedName);
for(int dep3 = 0; dep3 != transferMapping.databases[dep1].views[dep2].filterColumns.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".Views." + std::to_string(dep2 + 1) + ".FilterColumns." + std::to_string(dep3 + 1), transferMapping.databases[dep1].views[dep2].filterColumns[dep3]);
}
for(int dep3 = 0; dep3 != transferMapping.databases[dep1].views[dep2].adbTableSchema.primaryKeys.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".Views." + std::to_string(dep2 + 1) + ".AdbTableSchema.PrimaryKeys." + std::to_string(dep3 + 1), transferMapping.databases[dep1].views[dep2].adbTableSchema.primaryKeys[dep3]);
}
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".Views." + std::to_string(dep2 + 1) + ".AdbTableSchema.PartitionStatement", transferMapping.databases[dep1].views[dep2].adbTableSchema.partitionStatement);
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".Views." + std::to_string(dep2 + 1) + ".AdbTableSchema.PartitionLifeCycle", transferMapping.databases[dep1].views[dep2].adbTableSchema.partitionLifeCycle);
for(int dep3 = 0; dep3 != transferMapping.databases[dep1].views[dep2].adbTableSchema.distributedKeys.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".Views." + std::to_string(dep2 + 1) + ".AdbTableSchema.DistributedKeys." + std::to_string(dep3 + 1), transferMapping.databases[dep1].views[dep2].adbTableSchema.distributedKeys[dep3]);
}
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".Views." + std::to_string(dep2 + 1) + ".Name", transferMapping.databases[dep1].views[dep2].name);
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".Views." + std::to_string(dep2 + 1) + ".WhereClause", transferMapping.databases[dep1].views[dep2].whereClause);
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".Views." + std::to_string(dep2 + 1) + ".Id", transferMapping.databases[dep1].views[dep2].id);
for(int dep3 = 0; dep3 != transferMapping.databases[dep1].views[dep2].shardColumns.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".Views." + std::to_string(dep2 + 1) + ".ShardColumns." + std::to_string(dep3 + 1), transferMapping.databases[dep1].views[dep2].shardColumns[dep3]);
}
}
}
for(int dep1 = 0; dep1 != transferMapping.tableAndViewBlackList.size(); dep1++) {
setBodyParameter(std::string("TransferMapping") + ".TableAndViewBlackList." + std::to_string(dep1 + 1), transferMapping.tableAndViewBlackList[dep1]);
}
for(int dep1 = 0; dep1 != transferMapping.blackTableRules.size(); dep1++) {
setBodyParameter(std::string("TransferMapping") + ".BlackTableRules." + std::to_string(dep1 + 1) + ".ObjectMapping.MappedName", transferMapping.blackTableRules[dep1].objectMapping.mappedName);
setBodyParameter(std::string("TransferMapping") + ".BlackTableRules." + std::to_string(dep1 + 1) + ".ObjectMapping.Name", transferMapping.blackTableRules[dep1].objectMapping.name);
setBodyParameter(std::string("TransferMapping") + ".BlackTableRules." + std::to_string(dep1 + 1) + ".SchemaMapping.MappedName", transferMapping.blackTableRules[dep1].schemaMapping.mappedName);
setBodyParameter(std::string("TransferMapping") + ".BlackTableRules." + std::to_string(dep1 + 1) + ".SchemaMapping.Name", transferMapping.blackTableRules[dep1].schemaMapping.name);
}
for(int dep1 = 0; dep1 != transferMapping.schemas.size(); dep1++) {
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".MappedName", transferMapping.schemas[dep1].mappedName);
for(int dep2 = 0; dep2 != transferMapping.schemas[dep1].specificViews.size(); dep2++) {
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".SpecificViews." + std::to_string(dep2 + 1) + ".MappedName", transferMapping.schemas[dep1].specificViews[dep2].mappedName);
for(int dep3 = 0; dep3 != transferMapping.schemas[dep1].specificViews[dep2].filterColumns.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".SpecificViews." + std::to_string(dep2 + 1) + ".FilterColumns." + std::to_string(dep3 + 1), transferMapping.schemas[dep1].specificViews[dep2].filterColumns[dep3]);
}
for(int dep3 = 0; dep3 != transferMapping.schemas[dep1].specificViews[dep2].adbTableSchema.primaryKeys.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".SpecificViews." + std::to_string(dep2 + 1) + ".AdbTableSchema.PrimaryKeys." + std::to_string(dep3 + 1), transferMapping.schemas[dep1].specificViews[dep2].adbTableSchema.primaryKeys[dep3]);
}
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".SpecificViews." + std::to_string(dep2 + 1) + ".AdbTableSchema.PartitionStatement", transferMapping.schemas[dep1].specificViews[dep2].adbTableSchema.partitionStatement);
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".SpecificViews." + std::to_string(dep2 + 1) + ".AdbTableSchema.PartitionLifeCycle", transferMapping.schemas[dep1].specificViews[dep2].adbTableSchema.partitionLifeCycle);
for(int dep3 = 0; dep3 != transferMapping.schemas[dep1].specificViews[dep2].adbTableSchema.distributedKeys.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".SpecificViews." + std::to_string(dep2 + 1) + ".AdbTableSchema.DistributedKeys." + std::to_string(dep3 + 1), transferMapping.schemas[dep1].specificViews[dep2].adbTableSchema.distributedKeys[dep3]);
}
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".SpecificViews." + std::to_string(dep2 + 1) + ".Name", transferMapping.schemas[dep1].specificViews[dep2].name);
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".SpecificViews." + std::to_string(dep2 + 1) + ".WhereClause", transferMapping.schemas[dep1].specificViews[dep2].whereClause);
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".SpecificViews." + std::to_string(dep2 + 1) + ".Id", transferMapping.schemas[dep1].specificViews[dep2].id);
for(int dep3 = 0; dep3 != transferMapping.schemas[dep1].specificViews[dep2].shardColumns.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".SpecificViews." + std::to_string(dep2 + 1) + ".ShardColumns." + std::to_string(dep3 + 1), transferMapping.schemas[dep1].specificViews[dep2].shardColumns[dep3]);
}
}
for(int dep2 = 0; dep2 != transferMapping.schemas[dep1].tables.size(); dep2++) {
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".MappedName", transferMapping.schemas[dep1].tables[dep2].mappedName);
for(int dep3 = 0; dep3 != transferMapping.schemas[dep1].tables[dep2].filterColumns.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".FilterColumns." + std::to_string(dep3 + 1), transferMapping.schemas[dep1].tables[dep2].filterColumns[dep3]);
}
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".ObkvPartitionConfig.VirtualColumn", transferMapping.schemas[dep1].tables[dep2].obkvPartitionConfig.virtualColumn);
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".ObkvPartitionConfig.PartitionType", transferMapping.schemas[dep1].tables[dep2].obkvPartitionConfig.partitionType);
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".ObkvPartitionConfig.PartitionSize", std::to_string(transferMapping.schemas[dep1].tables[dep2].obkvPartitionConfig.partitionSize));
for(int dep3 = 0; dep3 != transferMapping.schemas[dep1].tables[dep2].adbTableSchema.primaryKeys.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".AdbTableSchema.PrimaryKeys." + std::to_string(dep3 + 1), transferMapping.schemas[dep1].tables[dep2].adbTableSchema.primaryKeys[dep3]);
}
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".AdbTableSchema.PartitionStatement", transferMapping.schemas[dep1].tables[dep2].adbTableSchema.partitionStatement);
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".AdbTableSchema.PartitionLifeCycle", transferMapping.schemas[dep1].tables[dep2].adbTableSchema.partitionLifeCycle);
for(int dep3 = 0; dep3 != transferMapping.schemas[dep1].tables[dep2].adbTableSchema.distributedKeys.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".AdbTableSchema.DistributedKeys." + std::to_string(dep3 + 1), transferMapping.schemas[dep1].tables[dep2].adbTableSchema.distributedKeys[dep3]);
}
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".Name", transferMapping.schemas[dep1].tables[dep2].name);
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".WhereClause", transferMapping.schemas[dep1].tables[dep2].whereClause);
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".Id", transferMapping.schemas[dep1].tables[dep2].id);
for(int dep3 = 0; dep3 != transferMapping.schemas[dep1].tables[dep2].shardColumns.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".ShardColumns." + std::to_string(dep3 + 1), transferMapping.schemas[dep1].tables[dep2].shardColumns[dep3]);
}
}
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".ClusterName", transferMapping.schemas[dep1].clusterName);
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".Name", transferMapping.schemas[dep1].name);
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".TenantName", transferMapping.schemas[dep1].tenantName);
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".Id", transferMapping.schemas[dep1].id);
for(int dep2 = 0; dep2 != transferMapping.schemas[dep1].specificTables.size(); dep2++) {
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".SpecificTables." + std::to_string(dep2 + 1) + ".MappedName", transferMapping.schemas[dep1].specificTables[dep2].mappedName);
for(int dep3 = 0; dep3 != transferMapping.schemas[dep1].specificTables[dep2].filterColumns.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".SpecificTables." + std::to_string(dep2 + 1) + ".FilterColumns." + std::to_string(dep3 + 1), transferMapping.schemas[dep1].specificTables[dep2].filterColumns[dep3]);
}
for(int dep3 = 0; dep3 != transferMapping.schemas[dep1].specificTables[dep2].adbTableSchema.primaryKeys.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".SpecificTables." + std::to_string(dep2 + 1) + ".AdbTableSchema.PrimaryKeys." + std::to_string(dep3 + 1), transferMapping.schemas[dep1].specificTables[dep2].adbTableSchema.primaryKeys[dep3]);
}
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".SpecificTables." + std::to_string(dep2 + 1) + ".AdbTableSchema.PartitionStatement", transferMapping.schemas[dep1].specificTables[dep2].adbTableSchema.partitionStatement);
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".SpecificTables." + std::to_string(dep2 + 1) + ".AdbTableSchema.PartitionLifeCycle", transferMapping.schemas[dep1].specificTables[dep2].adbTableSchema.partitionLifeCycle);
for(int dep3 = 0; dep3 != transferMapping.schemas[dep1].specificTables[dep2].adbTableSchema.distributedKeys.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".SpecificTables." + std::to_string(dep2 + 1) + ".AdbTableSchema.DistributedKeys." + std::to_string(dep3 + 1), transferMapping.schemas[dep1].specificTables[dep2].adbTableSchema.distributedKeys[dep3]);
}
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".SpecificTables." + std::to_string(dep2 + 1) + ".Name", transferMapping.schemas[dep1].specificTables[dep2].name);
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".SpecificTables." + std::to_string(dep2 + 1) + ".WhereClause", transferMapping.schemas[dep1].specificTables[dep2].whereClause);
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".SpecificTables." + std::to_string(dep2 + 1) + ".Id", transferMapping.schemas[dep1].specificTables[dep2].id);
for(int dep3 = 0; dep3 != transferMapping.schemas[dep1].specificTables[dep2].shardColumns.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".SpecificTables." + std::to_string(dep2 + 1) + ".ShardColumns." + std::to_string(dep3 + 1), transferMapping.schemas[dep1].specificTables[dep2].shardColumns[dep3]);
}
}
for(int dep2 = 0; dep2 != transferMapping.schemas[dep1].views.size(); dep2++) {
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".Views." + std::to_string(dep2 + 1) + ".MappedName", transferMapping.schemas[dep1].views[dep2].mappedName);
for(int dep3 = 0; dep3 != transferMapping.schemas[dep1].views[dep2].filterColumns.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".Views." + std::to_string(dep2 + 1) + ".FilterColumns." + std::to_string(dep3 + 1), transferMapping.schemas[dep1].views[dep2].filterColumns[dep3]);
}
for(int dep3 = 0; dep3 != transferMapping.schemas[dep1].views[dep2].adbTableSchema.primaryKeys.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".Views." + std::to_string(dep2 + 1) + ".AdbTableSchema.PrimaryKeys." + std::to_string(dep3 + 1), transferMapping.schemas[dep1].views[dep2].adbTableSchema.primaryKeys[dep3]);
}
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".Views." + std::to_string(dep2 + 1) + ".AdbTableSchema.PartitionStatement", transferMapping.schemas[dep1].views[dep2].adbTableSchema.partitionStatement);
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".Views." + std::to_string(dep2 + 1) + ".AdbTableSchema.PartitionLifeCycle", transferMapping.schemas[dep1].views[dep2].adbTableSchema.partitionLifeCycle);
for(int dep3 = 0; dep3 != transferMapping.schemas[dep1].views[dep2].adbTableSchema.distributedKeys.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".Views." + std::to_string(dep2 + 1) + ".AdbTableSchema.DistributedKeys." + std::to_string(dep3 + 1), transferMapping.schemas[dep1].views[dep2].adbTableSchema.distributedKeys[dep3]);
}
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".Views." + std::to_string(dep2 + 1) + ".Name", transferMapping.schemas[dep1].views[dep2].name);
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".Views." + std::to_string(dep2 + 1) + ".WhereClause", transferMapping.schemas[dep1].views[dep2].whereClause);
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".Views." + std::to_string(dep2 + 1) + ".Id", transferMapping.schemas[dep1].views[dep2].id);
for(int dep3 = 0; dep3 != transferMapping.schemas[dep1].views[dep2].shardColumns.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".Schemas." + std::to_string(dep1 + 1) + ".Views." + std::to_string(dep2 + 1) + ".ShardColumns." + std::to_string(dep3 + 1), transferMapping.schemas[dep1].views[dep2].shardColumns[dep3]);
}
}
}
for(int dep1 = 0; dep1 != transferMapping.blackViewRules.size(); dep1++) {
setBodyParameter(std::string("TransferMapping") + ".BlackViewRules." + std::to_string(dep1 + 1) + ".ObjectMapping.MappedName", transferMapping.blackViewRules[dep1].objectMapping.mappedName);
setBodyParameter(std::string("TransferMapping") + ".BlackViewRules." + std::to_string(dep1 + 1) + ".ObjectMapping.Name", transferMapping.blackViewRules[dep1].objectMapping.name);
setBodyParameter(std::string("TransferMapping") + ".BlackViewRules." + std::to_string(dep1 + 1) + ".SchemaMapping.MappedName", transferMapping.blackViewRules[dep1].schemaMapping.mappedName);
setBodyParameter(std::string("TransferMapping") + ".BlackViewRules." + std::to_string(dep1 + 1) + ".SchemaMapping.Name", transferMapping.blackViewRules[dep1].schemaMapping.name);
}
for(int dep1 = 0; dep1 != transferMapping.databasesBlack.size(); dep1++) {
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".MappedName", transferMapping.databasesBlack[dep1].mappedName);
for(int dep2 = 0; dep2 != transferMapping.databasesBlack[dep1].specificViews.size(); dep2++) {
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".SpecificViews." + std::to_string(dep2 + 1) + ".MappedName", transferMapping.databasesBlack[dep1].specificViews[dep2].mappedName);
for(int dep3 = 0; dep3 != transferMapping.databasesBlack[dep1].specificViews[dep2].filterColumns.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".SpecificViews." + std::to_string(dep2 + 1) + ".FilterColumns." + std::to_string(dep3 + 1), transferMapping.databasesBlack[dep1].specificViews[dep2].filterColumns[dep3]);
}
for(int dep3 = 0; dep3 != transferMapping.databasesBlack[dep1].specificViews[dep2].adbTableSchema.primaryKeys.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".SpecificViews." + std::to_string(dep2 + 1) + ".AdbTableSchema.PrimaryKeys." + std::to_string(dep3 + 1), transferMapping.databasesBlack[dep1].specificViews[dep2].adbTableSchema.primaryKeys[dep3]);
}
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".SpecificViews." + std::to_string(dep2 + 1) + ".AdbTableSchema.PartitionStatement", transferMapping.databasesBlack[dep1].specificViews[dep2].adbTableSchema.partitionStatement);
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".SpecificViews." + std::to_string(dep2 + 1) + ".AdbTableSchema.PartitionLifeCycle", transferMapping.databasesBlack[dep1].specificViews[dep2].adbTableSchema.partitionLifeCycle);
for(int dep3 = 0; dep3 != transferMapping.databasesBlack[dep1].specificViews[dep2].adbTableSchema.distributedKeys.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".SpecificViews." + std::to_string(dep2 + 1) + ".AdbTableSchema.DistributedKeys." + std::to_string(dep3 + 1), transferMapping.databasesBlack[dep1].specificViews[dep2].adbTableSchema.distributedKeys[dep3]);
}
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".SpecificViews." + std::to_string(dep2 + 1) + ".Name", transferMapping.databasesBlack[dep1].specificViews[dep2].name);
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".SpecificViews." + std::to_string(dep2 + 1) + ".WhereClause", transferMapping.databasesBlack[dep1].specificViews[dep2].whereClause);
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".SpecificViews." + std::to_string(dep2 + 1) + ".Id", transferMapping.databasesBlack[dep1].specificViews[dep2].id);
for(int dep3 = 0; dep3 != transferMapping.databasesBlack[dep1].specificViews[dep2].shardColumns.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".SpecificViews." + std::to_string(dep2 + 1) + ".ShardColumns." + std::to_string(dep3 + 1), transferMapping.databasesBlack[dep1].specificViews[dep2].shardColumns[dep3]);
}
}
for(int dep2 = 0; dep2 != transferMapping.databasesBlack[dep1].tables.size(); dep2++) {
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".MappedName", transferMapping.databasesBlack[dep1].tables[dep2].mappedName);
for(int dep3 = 0; dep3 != transferMapping.databasesBlack[dep1].tables[dep2].filterColumns.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".FilterColumns." + std::to_string(dep3 + 1), transferMapping.databasesBlack[dep1].tables[dep2].filterColumns[dep3]);
}
for(int dep3 = 0; dep3 != transferMapping.databasesBlack[dep1].tables[dep2].adbTableSchema.primaryKeys.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".AdbTableSchema.PrimaryKeys." + std::to_string(dep3 + 1), transferMapping.databasesBlack[dep1].tables[dep2].adbTableSchema.primaryKeys[dep3]);
}
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".AdbTableSchema.PartitionStatement", transferMapping.databasesBlack[dep1].tables[dep2].adbTableSchema.partitionStatement);
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".AdbTableSchema.PartitionLifeCycle", transferMapping.databasesBlack[dep1].tables[dep2].adbTableSchema.partitionLifeCycle);
for(int dep3 = 0; dep3 != transferMapping.databasesBlack[dep1].tables[dep2].adbTableSchema.distributedKeys.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".AdbTableSchema.DistributedKeys." + std::to_string(dep3 + 1), transferMapping.databasesBlack[dep1].tables[dep2].adbTableSchema.distributedKeys[dep3]);
}
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".Name", transferMapping.databasesBlack[dep1].tables[dep2].name);
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".WhereClause", transferMapping.databasesBlack[dep1].tables[dep2].whereClause);
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".Id", transferMapping.databasesBlack[dep1].tables[dep2].id);
for(int dep3 = 0; dep3 != transferMapping.databasesBlack[dep1].tables[dep2].shardColumns.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".ShardColumns." + std::to_string(dep3 + 1), transferMapping.databasesBlack[dep1].tables[dep2].shardColumns[dep3]);
}
}
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".ClusterName", transferMapping.databasesBlack[dep1].clusterName);
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".Name", transferMapping.databasesBlack[dep1].name);
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".TenantName", transferMapping.databasesBlack[dep1].tenantName);
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".Id", transferMapping.databasesBlack[dep1].id);
for(int dep2 = 0; dep2 != transferMapping.databasesBlack[dep1].specificTables.size(); dep2++) {
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".SpecificTables." + std::to_string(dep2 + 1) + ".MappedName", transferMapping.databasesBlack[dep1].specificTables[dep2].mappedName);
for(int dep3 = 0; dep3 != transferMapping.databasesBlack[dep1].specificTables[dep2].filterColumns.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".SpecificTables." + std::to_string(dep2 + 1) + ".FilterColumns." + std::to_string(dep3 + 1), transferMapping.databasesBlack[dep1].specificTables[dep2].filterColumns[dep3]);
}
for(int dep3 = 0; dep3 != transferMapping.databasesBlack[dep1].specificTables[dep2].adbTableSchema.primaryKeys.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".SpecificTables." + std::to_string(dep2 + 1) + ".AdbTableSchema.PrimaryKeys." + std::to_string(dep3 + 1), transferMapping.databasesBlack[dep1].specificTables[dep2].adbTableSchema.primaryKeys[dep3]);
}
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".SpecificTables." + std::to_string(dep2 + 1) + ".AdbTableSchema.PartitionStatement", transferMapping.databasesBlack[dep1].specificTables[dep2].adbTableSchema.partitionStatement);
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".SpecificTables." + std::to_string(dep2 + 1) + ".AdbTableSchema.PartitionLifeCycle", transferMapping.databasesBlack[dep1].specificTables[dep2].adbTableSchema.partitionLifeCycle);
for(int dep3 = 0; dep3 != transferMapping.databasesBlack[dep1].specificTables[dep2].adbTableSchema.distributedKeys.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".SpecificTables." + std::to_string(dep2 + 1) + ".AdbTableSchema.DistributedKeys." + std::to_string(dep3 + 1), transferMapping.databasesBlack[dep1].specificTables[dep2].adbTableSchema.distributedKeys[dep3]);
}
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".SpecificTables." + std::to_string(dep2 + 1) + ".Name", transferMapping.databasesBlack[dep1].specificTables[dep2].name);
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".SpecificTables." + std::to_string(dep2 + 1) + ".WhereClause", transferMapping.databasesBlack[dep1].specificTables[dep2].whereClause);
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".SpecificTables." + std::to_string(dep2 + 1) + ".Id", transferMapping.databasesBlack[dep1].specificTables[dep2].id);
for(int dep3 = 0; dep3 != transferMapping.databasesBlack[dep1].specificTables[dep2].shardColumns.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".SpecificTables." + std::to_string(dep2 + 1) + ".ShardColumns." + std::to_string(dep3 + 1), transferMapping.databasesBlack[dep1].specificTables[dep2].shardColumns[dep3]);
}
}
for(int dep2 = 0; dep2 != transferMapping.databasesBlack[dep1].views.size(); dep2++) {
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".Views." + std::to_string(dep2 + 1) + ".MappedName", transferMapping.databasesBlack[dep1].views[dep2].mappedName);
for(int dep3 = 0; dep3 != transferMapping.databasesBlack[dep1].views[dep2].filterColumns.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".Views." + std::to_string(dep2 + 1) + ".FilterColumns." + std::to_string(dep3 + 1), transferMapping.databasesBlack[dep1].views[dep2].filterColumns[dep3]);
}
for(int dep3 = 0; dep3 != transferMapping.databasesBlack[dep1].views[dep2].adbTableSchema.primaryKeys.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".Views." + std::to_string(dep2 + 1) + ".AdbTableSchema.PrimaryKeys." + std::to_string(dep3 + 1), transferMapping.databasesBlack[dep1].views[dep2].adbTableSchema.primaryKeys[dep3]);
}
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".Views." + std::to_string(dep2 + 1) + ".AdbTableSchema.PartitionStatement", transferMapping.databasesBlack[dep1].views[dep2].adbTableSchema.partitionStatement);
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".Views." + std::to_string(dep2 + 1) + ".AdbTableSchema.PartitionLifeCycle", transferMapping.databasesBlack[dep1].views[dep2].adbTableSchema.partitionLifeCycle);
for(int dep3 = 0; dep3 != transferMapping.databasesBlack[dep1].views[dep2].adbTableSchema.distributedKeys.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".Views." + std::to_string(dep2 + 1) + ".AdbTableSchema.DistributedKeys." + std::to_string(dep3 + 1), transferMapping.databasesBlack[dep1].views[dep2].adbTableSchema.distributedKeys[dep3]);
}
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".Views." + std::to_string(dep2 + 1) + ".Name", transferMapping.databasesBlack[dep1].views[dep2].name);
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".Views." + std::to_string(dep2 + 1) + ".WhereClause", transferMapping.databasesBlack[dep1].views[dep2].whereClause);
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".Views." + std::to_string(dep2 + 1) + ".Id", transferMapping.databasesBlack[dep1].views[dep2].id);
for(int dep3 = 0; dep3 != transferMapping.databasesBlack[dep1].views[dep2].shardColumns.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".DatabasesBlack." + std::to_string(dep1 + 1) + ".Views." + std::to_string(dep2 + 1) + ".ShardColumns." + std::to_string(dep3 + 1), transferMapping.databasesBlack[dep1].views[dep2].shardColumns[dep3]);
}
}
}
for(int dep1 = 0; dep1 != transferMapping.whiteTableRules.size(); dep1++) {
setBodyParameter(std::string("TransferMapping") + ".WhiteTableRules." + std::to_string(dep1 + 1) + ".ObjectMapping.MappedName", transferMapping.whiteTableRules[dep1].objectMapping.mappedName);
setBodyParameter(std::string("TransferMapping") + ".WhiteTableRules." + std::to_string(dep1 + 1) + ".ObjectMapping.Name", transferMapping.whiteTableRules[dep1].objectMapping.name);
setBodyParameter(std::string("TransferMapping") + ".WhiteTableRules." + std::to_string(dep1 + 1) + ".SchemaMapping.MappedName", transferMapping.whiteTableRules[dep1].schemaMapping.mappedName);
setBodyParameter(std::string("TransferMapping") + ".WhiteTableRules." + std::to_string(dep1 + 1) + ".SchemaMapping.Name", transferMapping.whiteTableRules[dep1].schemaMapping.name);
}
for(int dep1 = 0; dep1 != transferMapping.whiteViewRules.size(); dep1++) {
setBodyParameter(std::string("TransferMapping") + ".WhiteViewRules." + std::to_string(dep1 + 1) + ".ObjectMapping.MappedName", transferMapping.whiteViewRules[dep1].objectMapping.mappedName);
setBodyParameter(std::string("TransferMapping") + ".WhiteViewRules." + std::to_string(dep1 + 1) + ".ObjectMapping.Name", transferMapping.whiteViewRules[dep1].objectMapping.name);
setBodyParameter(std::string("TransferMapping") + ".WhiteViewRules." + std::to_string(dep1 + 1) + ".SchemaMapping.MappedName", transferMapping.whiteViewRules[dep1].schemaMapping.mappedName);
setBodyParameter(std::string("TransferMapping") + ".WhiteViewRules." + std::to_string(dep1 + 1) + ".SchemaMapping.Name", transferMapping.whiteViewRules[dep1].schemaMapping.name);
}
for(int dep1 = 0; dep1 != transferMapping.tableAndViewWhiteList.size(); dep1++) {
setBodyParameter(std::string("TransferMapping") + ".TableAndViewWhiteList." + std::to_string(dep1 + 1), transferMapping.tableAndViewWhiteList[dep1]);
}
}
std::string CreateProjectModifyRecordsRequest::getId() const {
return id_;
}

7
oceanbasepro/src/model/CreateProjectRequest.cc
View File

@@ -76,10 +76,14 @@ CreateProjectRequest::FullTransferConfig CreateProjectRequest::getFullTransferCo
void CreateProjectRequest::setFullTransferConfig(const CreateProjectRequest::FullTransferConfig &fullTransferConfig) {
fullTransferConfig_ = fullTransferConfig;
setBodyParameter(std::string("FullTransferConfig") + ".IndexDDLConcurrencyLimit", std::to_string(fullTransferConfig.indexDDLConcurrencyLimit));
setBodyParameter(std::string("FullTransferConfig") + ".HbaseObjMigMode", fullTransferConfig.hbaseObjMigMode);
setBodyParameter(std::string("FullTransferConfig") + ".NonePkUkTruncateDstTable", fullTransferConfig.nonePkUkTruncateDstTable ? "true" : "false");
setBodyParameter(std::string("FullTransferConfig") + ".ThrottleRps", std::to_string(fullTransferConfig.throttleRps));
setBodyParameter(std::string("FullTransferConfig") + ".FullVerifySpeedMode", fullTransferConfig.fullVerifySpeedMode);
setBodyParameter(std::string("FullTransferConfig") + ".WriteWorkerNum", std::to_string(fullTransferConfig.writeWorkerNum));
setBodyParameter(std::string("FullTransferConfig") + ".HbaseObjCheckMode", fullTransferConfig.hbaseObjCheckMode);
setBodyParameter(std::string("FullTransferConfig") + ".MaxConcurrentIndexDDLs", std::to_string(fullTransferConfig.maxConcurrentIndexDDLs));
setBodyParameter(std::string("FullTransferConfig") + ".ReadWorkerNum", std::to_string(fullTransferConfig.readWorkerNum));
setBodyParameter(std::string("FullTransferConfig") + ".FullTransferSpeedMode", fullTransferConfig.fullTransferSpeedMode);
setBodyParameter(std::string("FullTransferConfig") + ".AllowDestTableNotEmpty", fullTransferConfig.allowDestTableNotEmpty ? "true" : "false");
@@ -129,6 +133,9 @@ void CreateProjectRequest::setTransferMapping(const CreateProjectRequest::Transf
for(int dep3 = 0; dep3 != transferMapping.databases[dep1].tables[dep2].filterColumns.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".FilterColumns." + std::to_string(dep3 + 1), transferMapping.databases[dep1].tables[dep2].filterColumns[dep3]);
}
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".ObkvPartitionConfig.VirtualColumn", transferMapping.databases[dep1].tables[dep2].obkvPartitionConfig.virtualColumn);
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".ObkvPartitionConfig.PartitionType", transferMapping.databases[dep1].tables[dep2].obkvPartitionConfig.partitionType);
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".ObkvPartitionConfig.PartitionSize", std::to_string(transferMapping.databases[dep1].tables[dep2].obkvPartitionConfig.partitionSize));
for(int dep3 = 0; dep3 != transferMapping.databases[dep1].tables[dep2].adbTableSchema.primaryKeys.size(); dep3++) {
setBodyParameter(std::string("TransferMapping") + ".Databases." + std::to_string(dep1 + 1) + ".Tables." + std::to_string(dep2 + 1) + ".AdbTableSchema.PrimaryKeys." + std::to_string(dep3 + 1), transferMapping.databases[dep1].tables[dep2].adbTableSchema.primaryKeys[dep3]);
}

9
oceanbasepro/src/model/CreateTenantUserRequest.cc
View File

@@ -52,6 +52,15 @@ void CreateTenantUserRequest::setUserPassword(const std::string &userPassword) {
setBodyParameter(std::string("UserPassword"), userPassword);
}
std::string CreateTenantUserRequest::getGlobalPermissions() const {
return globalPermissions_;
}
void CreateTenantUserRequest::setGlobalPermissions(const std::string &globalPermissions) {
globalPermissions_ = globalPermissions;
setBodyParameter(std::string("GlobalPermissions"), globalPermissions);
}
std::string CreateTenantUserRequest::getTenantId() const {
return tenantId_;
}

2
oceanbasepro/src/model/CreateTenantUserResult.cc
View File

@@ -46,6 +46,8 @@ void CreateTenantUserResult::parse(const std::string &payload)
tenantUser_.userStatus = tenantUserNode["UserStatus"].asString();
if(!tenantUserNode["UserName"].isNull())
tenantUser_.userName = tenantUserNode["UserName"].asString();
if(!tenantUserNode["GlobalPermissions"].isNull())
tenantUser_.globalPermissions = tenantUserNode["GlobalPermissions"].asString();
auto allRolesNode = tenantUserNode["Roles"]["RolesItem"];
for (auto tenantUserNodeRolesRolesItem : allRolesNode)
{

2
oceanbasepro/src/model/DescribeDataBackupSetResult.cc
View File

@@ -56,7 +56,7 @@ void DescribeDataBackupSetResult::parse(const std::string &payload)
if(!valueDataDataItem["Policy"].isNull())
dataObject.policy = valueDataDataItem["Policy"].asString();
if(!valueDataDataItem["SetId"].isNull())
dataObject.setId = std::stoi(valueDataDataItem["SetId"].asString());
dataObject.setId = valueDataDataItem["SetId"].asString();
if(!valueDataDataItem["Method"].isNull())
dataObject.method = valueDataDataItem["Method"].asString();
if(!valueDataDataItem["Checkpoint"].isNull())

36
oceanbasepro/src/model/DescribeInstanceAvailableZonesRequest.cc Normal file
View File

@@ -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 <alibabacloud/oceanbasepro/model/DescribeInstanceAvailableZonesRequest.h>
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);
}

63
oceanbasepro/src/model/DescribeInstanceAvailableZonesResult.cc Normal file
View File

@@ -0,0 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/oceanbasepro/model/DescribeInstanceAvailableZonesResult.h>
#include <json/json.h>
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::ZoneListItem> DescribeInstanceAvailableZonesResult::getZoneList()const
{
return zoneList_;
}

6
oceanbasepro/src/model/DescribeInstanceCreatableZoneResult.cc
View File

@@ -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);
}

9
oceanbasepro/src/model/DescribeInstanceRequest.cc
View File

@@ -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_;
}

9
oceanbasepro/src/model/DescribeInstanceSSLRequest.cc
View File

@@ -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);
}

4
oceanbasepro/src/model/DescribeInstanceSSLResult.cc
View File

@@ -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();
}

10
oceanbasepro/src/model/DescribeInstanceSummaryResult.cc
View File

@@ -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);
}

8
oceanbasepro/src/model/DescribeInstanceTopologyResult.cc
View File

@@ -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())

19
oceanbasepro/src/model/DescribeInstancesRequest.cc
View File

@@ -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");
}

24
oceanbasepro/src/model/DescribeInstancesResult.cc
View File

@@ -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());

2
oceanbasepro/src/model/DescribeOasSQLHistoryListResult.cc
View File

@@ -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);
}

2
oceanbasepro/src/model/DescribeOasSQLPlansResult.cc
View File

@@ -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"];

9
oceanbasepro/src/model/DescribeOasTopSQLListRequest.cc
View File

@@ -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_;
}

7
oceanbasepro/src/model/DescribeOasTopSQLListResult.cc
View File

@@ -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);
}

4
oceanbasepro/src/model/DescribeOutlineBindingResult.cc
View File

@@ -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());
}

53
oceanbasepro/src/model/DescribeParametersHistoryResult.cc
View File

@@ -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::Data> DescribeParametersHistoryResult::getRespond()const
DescribeParametersHistoryResult::Respond DescribeParametersHistoryResult::getRespond()const
{
return respond_;
}

9
oceanbasepro/src/model/DescribeProcessStatsCompositionRequest.cc
View File

@@ -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_;
}

80
oceanbasepro/src/model/DescribeProcessStatsCompositionResult.cc
View File

@@ -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"];

36
oceanbasepro/src/model/DescribeProxyServiceRequest.cc Normal file
View File

@@ -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 <alibabacloud/oceanbasepro/model/DescribeProxyServiceRequest.h>
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);
}

76
oceanbasepro/src/model/DescribeProxyServiceResult.cc Normal file
View File

@@ -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 <alibabacloud/oceanbasepro/model/DescribeProxyServiceResult.h>
#include <json/json.h>
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_;
}

9
oceanbasepro/src/model/DescribeSampleSqlRawTextsRequest.cc
View File

@@ -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_;
}

81
oceanbasepro/src/model/DescribeSqlAuditStatRequest.cc Normal file
View File

@@ -0,0 +1,81 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/oceanbasepro/model/DescribeSqlAuditStatRequest.h>
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);
}

89
oceanbasepro/src/model/DescribeSqlAuditStatResult.cc Normal file
View File

@@ -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 <alibabacloud/oceanbasepro/model/DescribeSqlAuditStatResult.h>
#include <json/json.h>
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::DataItem> DescribeSqlAuditStatResult::getData()const
{
return data_;
}

10
oceanbasepro/src/model/DescribeTenantResult.cc
View File

@@ -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);

9
oceanbasepro/src/model/DescribeTenantUserRolesRequest.cc
View File

@@ -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_;
}

2
oceanbasepro/src/model/DescribeTenantUsersResult.cc
View File

@@ -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)
{

2
oceanbasepro/src/model/DescribeTenantsResult.cc
View File

@@ -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())

9
oceanbasepro/src/model/ModifyInstanceSSLRequest.cc
View File

@@ -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);
}

2
oceanbasepro/src/model/ModifyInstanceSSLResult.cc
View File

@@ -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();
}

18
oceanbasepro/src/model/ModifyTenantUserRolesRequest.cc
View File

@@ -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_;
}

54
oceanbasepro/src/model/RemoveStandbyInstanceRequest.cc Normal file
View File

@@ -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 <alibabacloud/oceanbasepro/model/RemoveStandbyInstanceRequest.h>
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);
}

44
oceanbasepro/src/model/RemoveStandbyInstanceResult.cc Normal file
View File

@@ -0,0 +1,44 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <alibabacloud/oceanbasepro/model/RemoveStandbyInstanceResult.h>
#include <json/json.h>
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());
}

2
oceanbasepro/src/model/UpdateProjectConfigRequest.cc
View File

@@ -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));
}