Generated 2019-09-01 for OceanBasePro.

VERSION

@@ -1 +1 @@
-1.36.2075
+1.36.2076

oceanbasepro/CMakeLists.txt

@@ -37,6 +37,8 @@ set(oceanbasepro_public_header_model
 	include/alibabacloud/oceanbasepro/model/CreateLabelResult.h
 	include/alibabacloud/oceanbasepro/model/CreateMySqlDataSourceRequest.h
 	include/alibabacloud/oceanbasepro/model/CreateMySqlDataSourceResult.h
+	include/alibabacloud/oceanbasepro/model/CreateOasOutlineTaskRequest.h
+	include/alibabacloud/oceanbasepro/model/CreateOasOutlineTaskResult.h
 	include/alibabacloud/oceanbasepro/model/CreateOceanBaseDataSourceRequest.h
 	include/alibabacloud/oceanbasepro/model/CreateOceanBaseDataSourceResult.h
 	include/alibabacloud/oceanbasepro/model/CreateOmsMysqlDataSourceRequest.h
@@ -103,6 +105,8 @@ set(oceanbasepro_public_header_model
 	include/alibabacloud/oceanbasepro/model/DescribeDatabasesResult.h
 	include/alibabacloud/oceanbasepro/model/DescribeInstanceRequest.h
 	include/alibabacloud/oceanbasepro/model/DescribeInstanceResult.h
+	include/alibabacloud/oceanbasepro/model/DescribeInstanceAvailableZonesRequest.h
+	include/alibabacloud/oceanbasepro/model/DescribeInstanceAvailableZonesResult.h
 	include/alibabacloud/oceanbasepro/model/DescribeInstanceCreatableZoneRequest.h
 	include/alibabacloud/oceanbasepro/model/DescribeInstanceCreatableZoneResult.h
 	include/alibabacloud/oceanbasepro/model/DescribeInstanceSSLRequest.h
@@ -153,6 +157,8 @@ set(oceanbasepro_public_header_model
 	include/alibabacloud/oceanbasepro/model/DescribeProjectStepMetricResult.h
 	include/alibabacloud/oceanbasepro/model/DescribeProjectStepsRequest.h
 	include/alibabacloud/oceanbasepro/model/DescribeProjectStepsResult.h
+	include/alibabacloud/oceanbasepro/model/DescribeProxyServiceRequest.h
+	include/alibabacloud/oceanbasepro/model/DescribeProxyServiceResult.h
 	include/alibabacloud/oceanbasepro/model/DescribeRecommendIndexRequest.h
 	include/alibabacloud/oceanbasepro/model/DescribeRecommendIndexResult.h
 	include/alibabacloud/oceanbasepro/model/DescribeRestorableTenantsRequest.h
@@ -177,6 +183,8 @@ set(oceanbasepro_public_header_model
 	include/alibabacloud/oceanbasepro/model/DescribeSlowSQLHistoryListResult.h
 	include/alibabacloud/oceanbasepro/model/DescribeSlowSQLListRequest.h
 	include/alibabacloud/oceanbasepro/model/DescribeSlowSQLListResult.h
+	include/alibabacloud/oceanbasepro/model/DescribeSqlAuditStatRequest.h
+	include/alibabacloud/oceanbasepro/model/DescribeSqlAuditStatResult.h
 	include/alibabacloud/oceanbasepro/model/DescribeStandbyCreateModeRequest.h
 	include/alibabacloud/oceanbasepro/model/DescribeStandbyCreateModeResult.h
 	include/alibabacloud/oceanbasepro/model/DescribeTagValuesRequest.h
@@ -271,6 +279,8 @@ set(oceanbasepro_public_header_model
 	include/alibabacloud/oceanbasepro/model/ReleaseProjectResult.h
 	include/alibabacloud/oceanbasepro/model/ReleaseWorkerInstanceRequest.h
 	include/alibabacloud/oceanbasepro/model/ReleaseWorkerInstanceResult.h
+	include/alibabacloud/oceanbasepro/model/RemoveStandbyInstanceRequest.h
+	include/alibabacloud/oceanbasepro/model/RemoveStandbyInstanceResult.h
 	include/alibabacloud/oceanbasepro/model/ResumeProjectRequest.h
 	include/alibabacloud/oceanbasepro/model/ResumeProjectResult.h
 	include/alibabacloud/oceanbasepro/model/RetryProjectModifyRecordsRequest.h
@@ -308,6 +318,8 @@ set(oceanbasepro_src
 	src/model/CreateLabelResult.cc
 	src/model/CreateMySqlDataSourceRequest.cc
 	src/model/CreateMySqlDataSourceResult.cc
+	src/model/CreateOasOutlineTaskRequest.cc
+	src/model/CreateOasOutlineTaskResult.cc
 	src/model/CreateOceanBaseDataSourceRequest.cc
 	src/model/CreateOceanBaseDataSourceResult.cc
 	src/model/CreateOmsMysqlDataSourceRequest.cc
@@ -374,6 +386,8 @@ set(oceanbasepro_src
 	src/model/DescribeDatabasesResult.cc
 	src/model/DescribeInstanceRequest.cc
 	src/model/DescribeInstanceResult.cc
+	src/model/DescribeInstanceAvailableZonesRequest.cc
+	src/model/DescribeInstanceAvailableZonesResult.cc
 	src/model/DescribeInstanceCreatableZoneRequest.cc
 	src/model/DescribeInstanceCreatableZoneResult.cc
 	src/model/DescribeInstanceSSLRequest.cc
@@ -424,6 +438,8 @@ set(oceanbasepro_src
 	src/model/DescribeProjectStepMetricResult.cc
 	src/model/DescribeProjectStepsRequest.cc
 	src/model/DescribeProjectStepsResult.cc
+	src/model/DescribeProxyServiceRequest.cc
+	src/model/DescribeProxyServiceResult.cc
 	src/model/DescribeRecommendIndexRequest.cc
 	src/model/DescribeRecommendIndexResult.cc
 	src/model/DescribeRestorableTenantsRequest.cc
@@ -448,6 +464,8 @@ set(oceanbasepro_src
 	src/model/DescribeSlowSQLHistoryListResult.cc
 	src/model/DescribeSlowSQLListRequest.cc
 	src/model/DescribeSlowSQLListResult.cc
+	src/model/DescribeSqlAuditStatRequest.cc
+	src/model/DescribeSqlAuditStatResult.cc
 	src/model/DescribeStandbyCreateModeRequest.cc
 	src/model/DescribeStandbyCreateModeResult.cc
 	src/model/DescribeTagValuesRequest.cc
@@ -542,6 +560,8 @@ set(oceanbasepro_src
 	src/model/ReleaseProjectResult.cc
 	src/model/ReleaseWorkerInstanceRequest.cc
 	src/model/ReleaseWorkerInstanceResult.cc
+	src/model/RemoveStandbyInstanceRequest.cc
+	src/model/RemoveStandbyInstanceResult.cc
 	src/model/ResumeProjectRequest.cc
 	src/model/ResumeProjectResult.cc
 	src/model/RetryProjectModifyRecordsRequest.cc

oceanbasepro/include/alibabacloud/oceanbasepro/OceanBaseProClient.h

@@ -38,6 +38,8 @@
 #include "model/CreateLabelResult.h"
 #include "model/CreateMySqlDataSourceRequest.h"
 #include "model/CreateMySqlDataSourceResult.h"
+#include "model/CreateOasOutlineTaskRequest.h"
+#include "model/CreateOasOutlineTaskResult.h"
 #include "model/CreateOceanBaseDataSourceRequest.h"
 #include "model/CreateOceanBaseDataSourceResult.h"
 #include "model/CreateOmsMysqlDataSourceRequest.h"
@@ -104,6 +106,8 @@
 #include "model/DescribeDatabasesResult.h"
 #include "model/DescribeInstanceRequest.h"
 #include "model/DescribeInstanceResult.h"
+#include "model/DescribeInstanceAvailableZonesRequest.h"
+#include "model/DescribeInstanceAvailableZonesResult.h"
 #include "model/DescribeInstanceCreatableZoneRequest.h"
 #include "model/DescribeInstanceCreatableZoneResult.h"
 #include "model/DescribeInstanceSSLRequest.h"
@@ -154,6 +158,8 @@
 #include "model/DescribeProjectStepMetricResult.h"
 #include "model/DescribeProjectStepsRequest.h"
 #include "model/DescribeProjectStepsResult.h"
+#include "model/DescribeProxyServiceRequest.h"
+#include "model/DescribeProxyServiceResult.h"
 #include "model/DescribeRecommendIndexRequest.h"
 #include "model/DescribeRecommendIndexResult.h"
 #include "model/DescribeRestorableTenantsRequest.h"
@@ -178,6 +184,8 @@
 #include "model/DescribeSlowSQLHistoryListResult.h"
 #include "model/DescribeSlowSQLListRequest.h"
 #include "model/DescribeSlowSQLListResult.h"
+#include "model/DescribeSqlAuditStatRequest.h"
+#include "model/DescribeSqlAuditStatResult.h"
 #include "model/DescribeStandbyCreateModeRequest.h"
 #include "model/DescribeStandbyCreateModeResult.h"
 #include "model/DescribeTagValuesRequest.h"
@@ -272,6 +280,8 @@
 #include "model/ReleaseProjectResult.h"
 #include "model/ReleaseWorkerInstanceRequest.h"
 #include "model/ReleaseWorkerInstanceResult.h"
+#include "model/RemoveStandbyInstanceRequest.h"
+#include "model/RemoveStandbyInstanceResult.h"
 #include "model/ResumeProjectRequest.h"
 #include "model/ResumeProjectResult.h"
 #include "model/RetryProjectModifyRecordsRequest.h"
@@ -323,6 +333,9 @@ namespace AlibabaCloud
 			typedef Outcome<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;

oceanbasepro/include/alibabacloud/oceanbasepro/model/BatchKillProcessListRequest.h

@@ -32,6 +32,8 @@ public:
 	~BatchKillProcessListRequest();
 	std::string getSessionList() const;
 	void setSessionList(const std::string &sessionList);
+	bool getByObSessionId() const;
+	void setByObSessionId(bool byObSessionId);
 	std::string getInstanceId() const;
 	void setInstanceId(const std::string &instanceId);
 	std::string getTenantId() const;
@@ -39,6 +41,7 @@ public:
 
 private:
 	std::string sessionList_;
+	bool byObSessionId_;
 	std::string instanceId_;
 	std::string tenantId_;
 };

oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateOasOutlineTaskRequest.h

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

oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateOasOutlineTaskResult.h

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

oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateProjectModifyRecordsRequest.h

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

oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateProjectRequest.h

@@ -29,10 +29,14 @@ namespace Model {
 class ALIBABACLOUD_OCEANBASEPRO_EXPORT CreateProjectRequest : public RpcServiceRequest {
 public:
 	struct FullTransferConfig {
+		int indexDDLConcurrencyLimit;
+		std::string hbaseObjMigMode;
 		bool nonePkUkTruncateDstTable;
 		int throttleRps;
 		std::string fullVerifySpeedMode;
 		int writeWorkerNum;
+		std::string hbaseObjCheckMode;
+		int maxConcurrentIndexDDLs;
 		int readWorkerNum;
 		std::string fullTransferSpeedMode;
 		bool allowDestTableNotEmpty;
@@ -67,6 +71,12 @@ public:
 				std::string mappedName;
 				std::string string;
 				std::vector<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;

oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateTenantUserRequest.h

@@ -36,6 +36,8 @@ public:
 	void setDescription(const std::string &description);
 	std::string getUserPassword() const;
 	void setUserPassword(const std::string &userPassword);
+	std::string getGlobalPermissions() const;
+	void setGlobalPermissions(const std::string &globalPermissions);
 	std::string getTenantId() const;
 	void setTenantId(const std::string &tenantId);
 	std::string getEncryptionType() const;
@@ -51,6 +53,7 @@ private:
 	std::string roles_;
 	std::string description_;
 	std::string userPassword_;
+	std::string globalPermissions_;
 	std::string tenantId_;
 	std::string encryptionType_;
 	std::string userType_;

oceanbasepro/include/alibabacloud/oceanbasepro/model/CreateTenantUserResult.h

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

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeDataBackupSetResult.h

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

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceAvailableZonesRequest.h

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

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceAvailableZonesResult.h

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

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceCreatableZoneResult.h

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

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceRequest.h

@@ -32,14 +32,11 @@ public:
 	~DescribeInstanceRequest();
 	int getPageNumber() const;
 	void setPageNumber(int pageNumber);
-	std::string getMaxConnectionLimit() const;
-	void setMaxConnectionLimit(const std::string &maxConnectionLimit);
 	std::string getInstanceId() const;
 	void setInstanceId(const std::string &instanceId);
 
 private:
 	int pageNumber_;
-	std::string maxConnectionLimit_;
 	std::string instanceId_;
 };
 } // namespace Model

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceSSLRequest.h

@@ -32,9 +32,12 @@ public:
 	~DescribeInstanceSSLRequest();
 	std::string getInstanceId() const;
 	void setInstanceId(const std::string &instanceId);
+	std::string getTenantId() const;
+	void setTenantId(const std::string &tenantId);
 
 private:
 	std::string instanceId_;
+	std::string tenantId_;
 };
 } // namespace Model
 } // namespace OceanBasePro

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceSSLResult.h

@@ -37,8 +37,10 @@ namespace AlibabaCloud
 					std::string status;
 					std::string forceSSL;
 					std::string enableSSL;
+					std::string tenantId;
 					std::string validPeriod;
 					std::string instanceId;
+					std::string autoUpdate;
 					std::string caUrl;
 					bool forceSSLSupport;
 				};

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceSummaryResult.h

@@ -36,12 +36,12 @@ namespace AlibabaCloud
 				{
 					struct RegionalInstanceSummaryLis
 					{
-						std::string immediatelyExpiredInstancesCount;
-						std::string recentCreatedInstancesCount;
-						std::string expiredInstancesCount;
+						long immediatelyExpiredInstancesCount;
+						long recentCreatedInstancesCount;
+						long expiredInstancesCount;
 						std::string region;
-						std::string runningInstancesCount;
-						std::string totalInstancesCount;
+						long runningInstancesCount;
+						long totalInstancesCount;
 					};
 					long immediatelyExpiredInstancesCount;
 					long tenantInstancesCount;

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstanceTopologyResult.h

@@ -51,6 +51,7 @@ namespace AlibabaCloud
 								std::string unitStatus;
 								bool manualMigrate;
 							};
+							std::string readOnlyReplicaType;
 							std::string tenantZoneRole;
 							std::string replicaType;
 							bool isPrimaryTenantZone;
@@ -107,6 +108,7 @@ namespace AlibabaCloud
 								Cpu cpu;
 							};
 							NodeResource nodeResource;
+							std::string readOnlyReplicaType;
 							std::string replicaType;
 							std::string nodeId;
 							std::string logicalZone;
@@ -146,11 +148,13 @@ namespace AlibabaCloud
 						};
 						int zoneLogicalId;
 						std::string status;
+						std::string readOnlyReplicaType;
 						ReplicaResource replicaResource;
 						int nodeNum;
 						std::string replicaType;
 						std::string logicalZone;
 						std::string zoneRegionName;
+						long onlineNodeNum;
 						std::string zoneLogicalName;
 					};
 					std::vector<TenantsItem> tenants;

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstancesRequest.h

@@ -36,20 +36,23 @@ public:
 	void setPageNumber(int pageNumber);
 	std::string getResourceGroupId() const;
 	void setResourceGroupId(const std::string &resourceGroupId);
+	int getPageSize() const;
+	void setPageSize(int pageSize);
 	std::string getInstanceId() const;
 	void setInstanceId(const std::string &instanceId);
 	std::string getInstanceName() const;
 	void setInstanceName(const std::string &instanceName);
-	int getPageSize() const;
-	void setPageSize(int pageSize);
+	bool getWithOBCloudInstances() const;
+	void setWithOBCloudInstances(bool withOBCloudInstances);
 
 private:
 	std::string searchKey_;
 	int pageNumber_;
 	std::string resourceGroupId_;
+	int pageSize_;
 	std::string instanceId_;
 	std::string instanceName_;
-	int pageSize_;
+	bool withOBCloudInstances_;
 };
 } // namespace Model
 } // namespace OceanBasePro

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeInstancesResult.h

@@ -80,7 +80,23 @@ namespace AlibabaCloud
 						double upperThreshold;
 						bool autoScale;
 					};
+					struct MigrationInfo
+					{
+						struct CheckResult
+						{
+							std::string subModule;
+							std::string codeName;
+							std::string moduleName;
+							std::string level;
+							std::string module;
+							std::string code;
+							std::string subModuleName;
+						};
+						CheckResult checkResult;
+						bool migratable;
+					};
 					std::string deployType;
+					MigrationInfo migrationInfo;
 					std::string resourceGroupId;
 					std::string specType;
 					bool enableUpgradeNodes;
@@ -93,15 +109,17 @@ namespace AlibabaCloud
 					std::string cpuArchitecture;
 					std::string version;
 					std::string commodityCode;
-					std::string diskSize;
+					long diskSize;
 					std::string instanceRole;
 					std::string instanceType;
 					std::string maintainTime;
 					std::string obRpmVersion;
+					std::string replicaMode;
 					std::string instanceId;
 					std::string createTime;
 					Resource resource;
 					std::string instanceClass;
+					bool migratable;
 					std::string payType;
 					std::string instanceName;
 					std::string series;

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeOasAnomalySQLListResult.h

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

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeOasSQLHistoryListResult.h

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

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeOasSQLPlansResult.h

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

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeOasTopSQLListRequest.h

@@ -32,6 +32,8 @@ public:
 	~DescribeOasTopSQLListRequest();
 	std::string getStartTime() const;
 	void setStartTime(const std::string &startTime);
+	std::string getCustomColumns() const;
+	void setCustomColumns(const std::string &customColumns);
 	std::string getSearchRule() const;
 	void setSearchRule(const std::string &searchRule);
 	bool getMergeDynamicSql() const;
@@ -65,6 +67,7 @@ public:
 
 private:
 	std::string startTime_;
+	std::string customColumns_;
 	std::string searchRule_;
 	bool mergeDynamicSql_;
 	bool dynamicSql_;

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeOasTopSQLListResult.h

@@ -34,6 +34,11 @@ namespace AlibabaCloud
 			public:
 				struct DataItem
 				{
+					struct CustomColumns
+					{
+						std::string expression;
+						std::string value;
+					};
 					struct SqlListItem
 					{
 						long executions;
@@ -126,6 +131,7 @@ namespace AlibabaCloud
 					double avgUserIoWaitTime;
 					double retryCount;
 					long retCode6002Count;
+					std::string obDbId;
 					double missPlans;
 					long retCode5167Count;
 					std::string sqlType;
@@ -161,6 +167,7 @@ namespace AlibabaCloud
 					double avgBlockIndexCacheHit;
 					double sumElapsedTime;
 					double avgBloomFilterCacheHit;
+					CustomColumns customColumns;
 					double avgReturnRows;
 					double avgPartitionCount;
 					double failCount;

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeOutlineBindingResult.h

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

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeParametersHistoryResult.h

@@ -32,7 +32,7 @@ namespace AlibabaCloud
 			class ALIBABACLOUD_OCEANBASEPRO_EXPORT DescribeParametersHistoryResult : public ServiceResult
 			{
 			public:
-				struct Data
+				struct Respond
 				{
 					struct ParametersItem
 					{
@@ -45,7 +45,7 @@ namespace AlibabaCloud
 						std::string name;
 					};
 					int totalCount;
-					std::vector<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_;
 
 			};
 		}

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeProcessStatsCompositionRequest.h

@@ -32,6 +32,8 @@ public:
 	~DescribeProcessStatsCompositionRequest();
 	std::string getUId() const;
 	void setUId(const std::string &uId);
+	bool getMergeDynamicSql() const;
+	void setMergeDynamicSql(bool mergeDynamicSql);
 	std::string getSqlText() const;
 	void setSqlText(const std::string &sqlText);
 	std::string getClientIp() const;
@@ -49,6 +51,7 @@ public:
 
 private:
 	std::string uId_;
+	bool mergeDynamicSql_;
 	std::string sqlText_;
 	std::string clientIp_;
 	std::string tenantId_;

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeProcessStatsCompositionResult.h

@@ -63,17 +63,59 @@ namespace AlibabaCloud
 					};
 					struct AllProcessListItem
 					{
+						struct ProcessSqlListsItem
+						{
+							struct ProcessSqlListItem
+							{
+								std::string status;
+								std::string dynamicSql;
+								std::string user;
+								long executeTime;
+								std::string proxySessId;
+								std::string serverIp;
+								std::string planId;
+								std::string sqlText;
+								long cpuTime;
+								std::string clientIp;
+								std::string sqlId;
+								std::string tenantId;
+								std::string command;
+								std::string database;
+								std::string traceId;
+								long sessionId;
+							};
+							std::string status;
+							std::string dynamicSql;
+							std::string user;
+							long executeTime;
+							std::string proxySessId;
+							std::string serverIp;
+							std::string planId;
+							std::string sqlText;
+							long cpuTime;
+							std::string clientIp;
+							std::string sqlId;
+							std::vector<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;

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeProxyServiceRequest.h

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

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeProxyServiceResult.h

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

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeSampleSqlRawTextsRequest.h

@@ -34,6 +34,8 @@ public:
 	void setTraceId(const std::string &traceId);
 	std::string getStartTime() const;
 	void setStartTime(const std::string &startTime);
+	bool getDynamicSql() const;
+	void setDynamicSql(bool dynamicSql);
 	std::string getTenantId() const;
 	void setTenantId(const std::string &tenantId);
 	std::string getLimit() const;
@@ -50,6 +52,7 @@ public:
 private:
 	std::string traceId_;
 	std::string startTime_;
+	bool dynamicSql_;
 	std::string tenantId_;
 	std::string limit_;
 	std::string sqlId_;

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeSqlAuditStatRequest.h

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

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeSqlAuditStatResult.h

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

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantResult.h

@@ -119,6 +119,7 @@ namespace AlibabaCloud
 						std::string proxyClusterId;
 						int intranetPort;
 						long parallelQueryDegree;
+						int internetSqlPort;
 						int internetRpcPort;
 						std::string connectionReplicaType;
 						std::string internetAddressStatus;
@@ -140,7 +141,8 @@ namespace AlibabaCloud
 					{
 						struct TenantZoneReplicasItem
 						{
-							std::string zoneNodes;
+							std::string readOnlyReplicaType;
+							long zoneNodes;
 							int zoneCopyId;
 							std::string logicZoneName;
 							std::string readOnlyCopyId;
@@ -153,6 +155,7 @@ namespace AlibabaCloud
 						std::string region;
 					};
 					std::string deployType;
+					std::string parameterTemplate;
 					ReadOnlyResource readOnlyResource;
 					std::string description;
 					long maxParallelQueryDegree;
@@ -189,6 +192,7 @@ namespace AlibabaCloud
 					std::string timeZone;
 					TenantResource tenantResource;
 					std::string vpcId;
+					std::string tenantMaxConnections;
 				};
 
 

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantUserRolesRequest.h

@@ -30,10 +30,13 @@ class ALIBABACLOUD_OCEANBASEPRO_EXPORT DescribeTenantUserRolesRequest : public R
 public:
 	DescribeTenantUserRolesRequest();
 	~DescribeTenantUserRolesRequest();
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
 	std::string getTenantId() const;
 	void setTenantId(const std::string &tenantId);
 
 private:
+	std::string instanceId_;
 	std::string tenantId_;
 };
 } // namespace Model

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantUsersResult.h

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

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeTenantsResult.h

@@ -37,6 +37,7 @@ namespace AlibabaCloud
 					std::string status;
 					std::string deployType;
 					int unitCpu;
+					std::string parameterTemplate;
 					std::string description;
 					std::string tenantName;
 					int unitNum;

oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceSSLRequest.h

@@ -34,10 +34,13 @@ public:
 	void setInstanceId(const std::string &instanceId);
 	std::string getEnableSSL() const;
 	void setEnableSSL(const std::string &enableSSL);
+	std::string getTenantId() const;
+	void setTenantId(const std::string &tenantId);
 
 private:
 	std::string instanceId_;
 	std::string enableSSL_;
+	std::string tenantId_;
 };
 } // namespace Model
 } // namespace OceanBasePro

oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyInstanceSSLResult.h

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

oceanbasepro/include/alibabacloud/oceanbasepro/model/ModifyTenantUserRolesRequest.h

@@ -30,21 +30,27 @@ class ALIBABACLOUD_OCEANBASEPRO_EXPORT ModifyTenantUserRolesRequest : public Rpc
 public:
 	ModifyTenantUserRolesRequest();
 	~ModifyTenantUserRolesRequest();
+	std::string getUserType() const;
+	void setUserType(const std::string &userType);
 	std::string getUserRole() const;
 	void setUserRole(const std::string &userRole);
 	std::string getInstanceId() const;
 	void setInstanceId(const std::string &instanceId);
 	std::string getModifyType() const;
 	void setModifyType(const std::string &modifyType);
+	std::string getGlobalPermissions() const;
+	void setGlobalPermissions(const std::string &globalPermissions);
 	std::string getTenantId() const;
 	void setTenantId(const std::string &tenantId);
 	std::string getUserName() const;
 	void setUserName(const std::string &userName);
 
 private:
+	std::string userType_;
 	std::string userRole_;
 	std::string instanceId_;
 	std::string modifyType_;
+	std::string globalPermissions_;
 	std::string tenantId_;
 	std::string userName_;
 };

oceanbasepro/include/alibabacloud/oceanbasepro/model/RemoveStandbyInstanceRequest.h

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

oceanbasepro/include/alibabacloud/oceanbasepro/model/RemoveStandbyInstanceResult.h

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

oceanbasepro/include/alibabacloud/oceanbasepro/model/UpdateProjectConfigRequest.h

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

oceanbasepro/src/OceanBaseProClient.cc

@@ -339,6 +339,42 @@ OceanBaseProClient::CreateMySqlDataSourceOutcomeCallable OceanBaseProClient::cre
 	return task->get_future();
 }
 
+OceanBaseProClient::CreateOasOutlineTaskOutcome OceanBaseProClient::createOasOutlineTask(const CreateOasOutlineTaskRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateOasOutlineTaskOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateOasOutlineTaskOutcome(CreateOasOutlineTaskResult(outcome.result()));
+	else
+		return CreateOasOutlineTaskOutcome(outcome.error());
+}
+
+void OceanBaseProClient::createOasOutlineTaskAsync(const CreateOasOutlineTaskRequest& request, const CreateOasOutlineTaskAsyncHandler& handler, const std::shared_ptr<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();

oceanbasepro/src/model/BatchKillProcessListRequest.cc

@@ -34,6 +34,15 @@ void BatchKillProcessListRequest::setSessionList(const std::string &sessionList)
   setBodyParameter(std::string("SessionList"), sessionList);
 }
 
+bool BatchKillProcessListRequest::getByObSessionId() const {
+  return byObSessionId_;
+}
+
+void BatchKillProcessListRequest::setByObSessionId(bool byObSessionId) {
+  byObSessionId_ = byObSessionId;
+  setBodyParameter(std::string("ByObSessionId"), byObSessionId ? "true" : "false");
+}
+
 std::string BatchKillProcessListRequest::getInstanceId() const {
   return instanceId_;
 }

oceanbasepro/src/model/CreateOasOutlineTaskRequest.cc

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

oceanbasepro/src/model/CreateOasOutlineTaskResult.cc

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

oceanbasepro/src/model/CreateProjectModifyRecordsRequest.cc

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

oceanbasepro/src/model/CreateProjectRequest.cc

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

oceanbasepro/src/model/CreateTenantUserRequest.cc

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

oceanbasepro/src/model/CreateTenantUserResult.cc

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

oceanbasepro/src/model/DescribeDataBackupSetResult.cc

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

oceanbasepro/src/model/DescribeInstanceAvailableZonesRequest.cc

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

oceanbasepro/src/model/DescribeInstanceAvailableZonesResult.cc

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

oceanbasepro/src/model/DescribeInstanceCreatableZoneResult.cc

@@ -47,6 +47,12 @@ void DescribeInstanceCreatableZoneResult::parse(const std::string &payload)
 			zoneListObject.isInCluster = valueZoneListZoneListItem["IsInCluster"].asString() == "true";
 		if(!valueZoneListZoneListItem["Zone"].isNull())
 			zoneListObject.zone = valueZoneListZoneListItem["Zone"].asString();
+		if(!valueZoneListZoneListItem["FullCopyId"].isNull())
+			zoneListObject.fullCopyId = valueZoneListZoneListItem["FullCopyId"].asString();
+		if(!valueZoneListZoneListItem["LogicalZoneName"].isNull())
+			zoneListObject.logicalZoneName = valueZoneListZoneListItem["LogicalZoneName"].asString();
+		if(!valueZoneListZoneListItem["ReplicateZoneIndex"].isNull())
+			zoneListObject.replicateZoneIndex = std::stol(valueZoneListZoneListItem["ReplicateZoneIndex"].asString());
 		zoneList_.push_back(zoneListObject);
 	}
 

oceanbasepro/src/model/DescribeInstanceRequest.cc

@@ -34,15 +34,6 @@ void DescribeInstanceRequest::setPageNumber(int pageNumber) {
   setBodyParameter(std::string("PageNumber"), std::to_string(pageNumber));
 }
 
-std::string DescribeInstanceRequest::getMaxConnectionLimit() const {
-  return maxConnectionLimit_;
-}
-
-void DescribeInstanceRequest::setMaxConnectionLimit(const std::string &maxConnectionLimit) {
-  maxConnectionLimit_ = maxConnectionLimit;
-  setBodyParameter(std::string("MaxConnectionLimit"), maxConnectionLimit);
-}
-
 std::string DescribeInstanceRequest::getInstanceId() const {
   return instanceId_;
 }

oceanbasepro/src/model/DescribeInstanceSSLRequest.cc

@@ -34,3 +34,12 @@ void DescribeInstanceSSLRequest::setInstanceId(const std::string &instanceId) {
   setBodyParameter(std::string("InstanceId"), instanceId);
 }
 
+std::string DescribeInstanceSSLRequest::getTenantId() const {
+  return tenantId_;
+}
+
+void DescribeInstanceSSLRequest::setTenantId(const std::string &tenantId) {
+  tenantId_ = tenantId;
+  setBodyParameter(std::string("TenantId"), tenantId);
+}
+

oceanbasepro/src/model/DescribeInstanceSSLResult.cc

@@ -54,6 +54,10 @@ void DescribeInstanceSSLResult::parse(const std::string &payload)
 		instanceSSL_.forceSSLSupport = instanceSSLNode["ForceSSLSupport"].asString() == "true";
 	if(!instanceSSLNode["ForceSSL"].isNull())
 		instanceSSL_.forceSSL = instanceSSLNode["ForceSSL"].asString();
+	if(!instanceSSLNode["AutoUpdate"].isNull())
+		instanceSSL_.autoUpdate = instanceSSLNode["AutoUpdate"].asString();
+	if(!instanceSSLNode["TenantId"].isNull())
+		instanceSSL_.tenantId = instanceSSLNode["TenantId"].asString();
 
 }
 

oceanbasepro/src/model/DescribeInstanceSummaryResult.cc

@@ -69,15 +69,15 @@ void DescribeInstanceSummaryResult::parse(const std::string &payload)
 		if(!instanceSummaryNodeRegionalInstanceSummaryListRegionalInstanceSummaryLis["Region"].isNull())
 			regionalInstanceSummaryLisObject.region = instanceSummaryNodeRegionalInstanceSummaryListRegionalInstanceSummaryLis["Region"].asString();
 		if(!instanceSummaryNodeRegionalInstanceSummaryListRegionalInstanceSummaryLis["TotalInstancesCount"].isNull())
-			regionalInstanceSummaryLisObject.totalInstancesCount = instanceSummaryNodeRegionalInstanceSummaryListRegionalInstanceSummaryLis["TotalInstancesCount"].asString();
+			regionalInstanceSummaryLisObject.totalInstancesCount = std::stol(instanceSummaryNodeRegionalInstanceSummaryListRegionalInstanceSummaryLis["TotalInstancesCount"].asString());
 		if(!instanceSummaryNodeRegionalInstanceSummaryListRegionalInstanceSummaryLis["ImmediatelyExpiredInstancesCount"].isNull())
-			regionalInstanceSummaryLisObject.immediatelyExpiredInstancesCount = instanceSummaryNodeRegionalInstanceSummaryListRegionalInstanceSummaryLis["ImmediatelyExpiredInstancesCount"].asString();
+			regionalInstanceSummaryLisObject.immediatelyExpiredInstancesCount = std::stol(instanceSummaryNodeRegionalInstanceSummaryListRegionalInstanceSummaryLis["ImmediatelyExpiredInstancesCount"].asString());
 		if(!instanceSummaryNodeRegionalInstanceSummaryListRegionalInstanceSummaryLis["RunningInstancesCount"].isNull())
-			regionalInstanceSummaryLisObject.runningInstancesCount = instanceSummaryNodeRegionalInstanceSummaryListRegionalInstanceSummaryLis["RunningInstancesCount"].asString();
+			regionalInstanceSummaryLisObject.runningInstancesCount = std::stol(instanceSummaryNodeRegionalInstanceSummaryListRegionalInstanceSummaryLis["RunningInstancesCount"].asString());
 		if(!instanceSummaryNodeRegionalInstanceSummaryListRegionalInstanceSummaryLis["ExpiredInstancesCount"].isNull())
-			regionalInstanceSummaryLisObject.expiredInstancesCount = instanceSummaryNodeRegionalInstanceSummaryListRegionalInstanceSummaryLis["ExpiredInstancesCount"].asString();
+			regionalInstanceSummaryLisObject.expiredInstancesCount = std::stol(instanceSummaryNodeRegionalInstanceSummaryListRegionalInstanceSummaryLis["ExpiredInstancesCount"].asString());
 		if(!instanceSummaryNodeRegionalInstanceSummaryListRegionalInstanceSummaryLis["RecentCreatedInstancesCount"].isNull())
-			regionalInstanceSummaryLisObject.recentCreatedInstancesCount = instanceSummaryNodeRegionalInstanceSummaryListRegionalInstanceSummaryLis["RecentCreatedInstancesCount"].asString();
+			regionalInstanceSummaryLisObject.recentCreatedInstancesCount = std::stol(instanceSummaryNodeRegionalInstanceSummaryListRegionalInstanceSummaryLis["RecentCreatedInstancesCount"].asString());
 		instanceSummary_.regionalInstanceSummaryList.push_back(regionalInstanceSummaryLisObject);
 	}
 

oceanbasepro/src/model/DescribeInstanceTopologyResult.cc

@@ -82,6 +82,8 @@ void DescribeInstanceTopologyResult::parse(const std::string &payload)
 				tenantZonesObject.logicalZone = instanceTopologyNodeTenantsTenantsItemTenantZonesTenantZonesItem["LogicalZone"].asString();
 			if(!instanceTopologyNodeTenantsTenantsItemTenantZonesTenantZonesItem["ReplicaType"].isNull())
 				tenantZonesObject.replicaType = instanceTopologyNodeTenantsTenantsItemTenantZonesTenantZonesItem["ReplicaType"].asString();
+			if(!instanceTopologyNodeTenantsTenantsItemTenantZonesTenantZonesItem["ReadOnlyReplicaType"].isNull())
+				tenantZonesObject.readOnlyReplicaType = instanceTopologyNodeTenantsTenantsItemTenantZonesTenantZonesItem["ReadOnlyReplicaType"].asString();
 			auto allUnitsNode = instanceTopologyNodeTenantsTenantsItemTenantZonesTenantZonesItem["Units"]["UnitsItem"];
 			for (auto instanceTopologyNodeTenantsTenantsItemTenantZonesTenantZonesItemUnitsUnitsItem : allUnitsNode)
 			{
@@ -140,6 +142,8 @@ void DescribeInstanceTopologyResult::parse(const std::string &payload)
 				nodesObject.readOnlyCopyId = std::stol(instanceTopologyNodeZonesZonesItemNodesNodesItem["ReadOnlyCopyId"].asString());
 			if(!instanceTopologyNodeZonesZonesItemNodesNodesItem["LogicalZone"].isNull())
 				nodesObject.logicalZone = instanceTopologyNodeZonesZonesItemNodesNodesItem["LogicalZone"].asString();
+			if(!instanceTopologyNodeZonesZonesItemNodesNodesItem["ReadOnlyReplicaType"].isNull())
+				nodesObject.readOnlyReplicaType = instanceTopologyNodeZonesZonesItemNodesNodesItem["ReadOnlyReplicaType"].asString();
 			auto nodeResourceNode = value["NodeResource"];
 			auto cpuNode = nodeResourceNode["Cpu"];
 			if(!cpuNode["UsedCpu"].isNull())
@@ -185,6 +189,10 @@ void DescribeInstanceTopologyResult::parse(const std::string &payload)
 			replicasItemObject.replicaType = instanceTopologyNodeReplicasReplicasItem["ReplicaType"].asString();
 		if(!instanceTopologyNodeReplicasReplicasItem["Status"].isNull())
 			replicasItemObject.status = instanceTopologyNodeReplicasReplicasItem["Status"].asString();
+		if(!instanceTopologyNodeReplicasReplicasItem["ReadOnlyReplicaType"].isNull())
+			replicasItemObject.readOnlyReplicaType = instanceTopologyNodeReplicasReplicasItem["ReadOnlyReplicaType"].asString();
+		if(!instanceTopologyNodeReplicasReplicasItem["OnlineNodeNum"].isNull())
+			replicasItemObject.onlineNodeNum = std::stol(instanceTopologyNodeReplicasReplicasItem["OnlineNodeNum"].asString());
 		auto replicaResourceNode = value["ReplicaResource"];
 		auto memory2Node = replicaResourceNode["Memory"];
 		if(!memory2Node["UsedMemory"].isNull())

oceanbasepro/src/model/DescribeInstancesRequest.cc

@@ -52,6 +52,15 @@ void DescribeInstancesRequest::setResourceGroupId(const std::string &resourceGro
   setBodyParameter(std::string("ResourceGroupId"), resourceGroupId);
 }
 
+int DescribeInstancesRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void DescribeInstancesRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setBodyParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+
 std::string DescribeInstancesRequest::getInstanceId() const {
   return instanceId_;
 }
@@ -70,12 +79,12 @@ void DescribeInstancesRequest::setInstanceName(const std::string &instanceName)
   setBodyParameter(std::string("InstanceName"), instanceName);
 }
 
-int DescribeInstancesRequest::getPageSize() const {
-  return pageSize_;
+bool DescribeInstancesRequest::getWithOBCloudInstances() const {
+  return withOBCloudInstances_;
 }
 
-void DescribeInstancesRequest::setPageSize(int pageSize) {
-  pageSize_ = pageSize;
-  setBodyParameter(std::string("PageSize"), std::to_string(pageSize));
+void DescribeInstancesRequest::setWithOBCloudInstances(bool withOBCloudInstances) {
+  withOBCloudInstances_ = withOBCloudInstances;
+  setBodyParameter(std::string("WithOBCloudInstances"), withOBCloudInstances ? "true" : "false");
 }
 

oceanbasepro/src/model/DescribeInstancesResult.cc

@@ -66,7 +66,7 @@ void DescribeInstancesResult::parse(const std::string &payload)
 		if(!valueInstancesData["PayType"].isNull())
 			instancesObject.payType = valueInstancesData["PayType"].asString();
 		if(!valueInstancesData["DiskSize"].isNull())
-			instancesObject.diskSize = valueInstancesData["DiskSize"].asString();
+			instancesObject.diskSize = std::stol(valueInstancesData["DiskSize"].asString());
 		if(!valueInstancesData["DiskType"].isNull())
 			instancesObject.diskType = valueInstancesData["DiskType"].asString();
 		if(!valueInstancesData["InstanceId"].isNull())
@@ -101,6 +101,10 @@ void DescribeInstancesResult::parse(const std::string &payload)
 			instancesObject.specType = valueInstancesData["SpecType"].asString();
 		if(!valueInstancesData["ObRpmVersion"].isNull())
 			instancesObject.obRpmVersion = valueInstancesData["ObRpmVersion"].asString();
+		if(!valueInstancesData["ReplicaMode"].isNull())
+			instancesObject.replicaMode = valueInstancesData["ReplicaMode"].asString();
+		if(!valueInstancesData["Migratable"].isNull())
+			instancesObject.migratable = valueInstancesData["Migratable"].asString() == "true";
 		auto resourceNode = value["Resource"];
 		if(!resourceNode["UnitCount"].isNull())
 			instancesObject.resource.unitCount = std::stol(resourceNode["UnitCount"].asString());
@@ -155,6 +159,24 @@ void DescribeInstancesResult::parse(const std::string &payload)
 			instancesObject.dataDiskAutoScaleConfig.scaleStepInMerge = dataDiskAutoScaleConfigNode["ScaleStepInMerge"].asString();
 		if(!dataDiskAutoScaleConfigNode["UpperScaleStrategy"].isNull())
 			instancesObject.dataDiskAutoScaleConfig.upperScaleStrategy = dataDiskAutoScaleConfigNode["UpperScaleStrategy"].asString();
+		auto migrationInfoNode = value["MigrationInfo"];
+		if(!migrationInfoNode["Migratable"].isNull())
+			instancesObject.migrationInfo.migratable = migrationInfoNode["Migratable"].asString() == "true";
+		auto checkResultNode = migrationInfoNode["CheckResult"];
+		if(!checkResultNode["Level"].isNull())
+			instancesObject.migrationInfo.checkResult.level = checkResultNode["Level"].asString();
+		if(!checkResultNode["Code"].isNull())
+			instancesObject.migrationInfo.checkResult.code = checkResultNode["Code"].asString();
+		if(!checkResultNode["CodeName"].isNull())
+			instancesObject.migrationInfo.checkResult.codeName = checkResultNode["CodeName"].asString();
+		if(!checkResultNode["Module"].isNull())
+			instancesObject.migrationInfo.checkResult.module = checkResultNode["Module"].asString();
+		if(!checkResultNode["ModuleName"].isNull())
+			instancesObject.migrationInfo.checkResult.moduleName = checkResultNode["ModuleName"].asString();
+		if(!checkResultNode["SubModule"].isNull())
+			instancesObject.migrationInfo.checkResult.subModule = checkResultNode["SubModule"].asString();
+		if(!checkResultNode["SubModuleName"].isNull())
+			instancesObject.migrationInfo.checkResult.subModuleName = checkResultNode["SubModuleName"].asString();
 		auto allAvailableZones = value["AvailableZones"]["AvailableZones"];
 		for (auto value : allAvailableZones)
 			instancesObject.availableZones.push_back(value.asString());

oceanbasepro/src/model/DescribeOasSQLHistoryListResult.cc

@@ -181,6 +181,8 @@ void DescribeOasSQLHistoryListResult::parse(const std::string &payload)
 			dataObject.avgDbTime = valueDataDataItem["AvgDbTime"].asString();
 		if(!valueDataDataItem["SumDbTime"].isNull())
 			dataObject.sumDbTime = valueDataDataItem["SumDbTime"].asString();
+		if(!valueDataDataItem["WaitEvent"].isNull())
+			dataObject.waitEvent = valueDataDataItem["WaitEvent"].asString();
 		data_.push_back(dataObject);
 	}
 

oceanbasepro/src/model/DescribeOasSQLPlansResult.cc

@@ -145,6 +145,8 @@ void DescribeOasSQLPlansResult::parse(const std::string &payload)
 				plansObject.planUnionHash = valueDataDataItemPlansPlansItem["PlanUnionHash"].asString();
 			if(!valueDataDataItemPlansPlansItem["SqlId"].isNull())
 				plansObject.sqlId = valueDataDataItemPlansPlansItem["SqlId"].asString();
+			if(!valueDataDataItemPlansPlansItem["SqlText"].isNull())
+				plansObject.sqlText = valueDataDataItemPlansPlansItem["SqlText"].asString();
 			dataObject.plans.push_back(plansObject);
 		}
 		auto planExplainNode = value["PlanExplain"];

oceanbasepro/src/model/DescribeOasTopSQLListRequest.cc

@@ -34,6 +34,15 @@ void DescribeOasTopSQLListRequest::setStartTime(const std::string &startTime) {
   setBodyParameter(std::string("StartTime"), startTime);
 }
 
+std::string DescribeOasTopSQLListRequest::getCustomColumns() const {
+  return customColumns_;
+}
+
+void DescribeOasTopSQLListRequest::setCustomColumns(const std::string &customColumns) {
+  customColumns_ = customColumns;
+  setBodyParameter(std::string("CustomColumns"), customColumns);
+}
+
 std::string DescribeOasTopSQLListRequest::getSearchRule() const {
   return searchRule_;
 }

oceanbasepro/src/model/DescribeOasTopSQLListResult.cc

@@ -203,6 +203,8 @@ void DescribeOasTopSQLListResult::parse(const std::string &payload)
 			dataObject.avgDbTime = valueDataDataItem["AvgDbTime"].asString();
 		if(!valueDataDataItem["SumDbTime"].isNull())
 			dataObject.sumDbTime = valueDataDataItem["SumDbTime"].asString();
+		if(!valueDataDataItem["ObDbId"].isNull())
+			dataObject.obDbId = valueDataDataItem["ObDbId"].asString();
 		auto allSqlListNode = valueDataDataItem["SqlList"]["SqlListItem"];
 		for (auto valueDataDataItemSqlListSqlListItem : allSqlListNode)
 		{
@@ -365,6 +367,11 @@ void DescribeOasTopSQLListResult::parse(const std::string &payload)
 				sqlListObject.sumDbTime = valueDataDataItemSqlListSqlListItem["SumDbTime"].asString();
 			dataObject.sqlList.push_back(sqlListObject);
 		}
+		auto customColumnsNode = value["CustomColumns"];
+		if(!customColumnsNode["Expression"].isNull())
+			dataObject.customColumns.expression = customColumnsNode["Expression"].asString();
+		if(!customColumnsNode["Value"].isNull())
+			dataObject.customColumns.value = customColumnsNode["Value"].asString();
 		data_.push_back(dataObject);
 	}
 

oceanbasepro/src/model/DescribeOutlineBindingResult.cc

@@ -50,6 +50,10 @@ void DescribeOutlineBindingResult::parse(const std::string &payload)
 		outlineBinding_.maxConcurrent = std::stoi(outlineBindingNode["MaxConcurrent"].asString());
 	if(!outlineBindingNode["TableName"].isNull())
 		outlineBinding_.tableName = outlineBindingNode["TableName"].asString();
+	if(!outlineBindingNode["SqlText"].isNull())
+		outlineBinding_.sqlText = outlineBindingNode["SqlText"].asString();
+	if(!outlineBindingNode["SqlTextConcurrentNum"].isNull())
+		outlineBinding_.sqlTextConcurrentNum = std::stol(outlineBindingNode["SqlTextConcurrentNum"].asString());
 
 }
 

oceanbasepro/src/model/DescribeParametersHistoryResult.cc

@@ -39,40 +39,35 @@ void DescribeParametersHistoryResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	auto allRespondNode = value["Respond"]["Data"];
-	for (auto valueRespondData : allRespondNode)
+	auto respondNode = value["Respond"];
+	if(!respondNode["TotalCount"].isNull())
+		respond_.totalCount = std::stoi(respondNode["TotalCount"].asString());
+	if(!respondNode["PageNumber"].isNull())
+		respond_.pageNumber = std::stoi(respondNode["PageNumber"].asString());
+	auto allParametersNode = respondNode["Parameters"]["ParametersItem"];
+	for (auto respondNodeParametersParametersItem : allParametersNode)
 	{
-		Data respondObject;
-		if(!valueRespondData["TotalCount"].isNull())
-			respondObject.totalCount = std::stoi(valueRespondData["TotalCount"].asString());
-		if(!valueRespondData["PageNumber"].isNull())
-			respondObject.pageNumber = std::stoi(valueRespondData["PageNumber"].asString());
-		auto allParametersNode = valueRespondData["Parameters"]["ParametersItem"];
-		for (auto valueRespondDataParametersParametersItem : allParametersNode)
-		{
-			Data::ParametersItem parametersObject;
-			if(!valueRespondDataParametersParametersItem["Status"].isNull())
-				parametersObject.status = valueRespondDataParametersParametersItem["Status"].asString();
-			if(!valueRespondDataParametersParametersItem["OldValue"].isNull())
-				parametersObject.oldValue = valueRespondDataParametersParametersItem["OldValue"].asString();
-			if(!valueRespondDataParametersParametersItem["UpdateTime"].isNull())
-				parametersObject.updateTime = valueRespondDataParametersParametersItem["UpdateTime"].asString();
-			if(!valueRespondDataParametersParametersItem["CreateTime"].isNull())
-				parametersObject.createTime = valueRespondDataParametersParametersItem["CreateTime"].asString();
-			if(!valueRespondDataParametersParametersItem["DimensionValue"].isNull())
-				parametersObject.dimensionValue = valueRespondDataParametersParametersItem["DimensionValue"].asString();
-			if(!valueRespondDataParametersParametersItem["Name"].isNull())
-				parametersObject.name = valueRespondDataParametersParametersItem["Name"].asString();
-			if(!valueRespondDataParametersParametersItem["NewValue"].isNull())
-				parametersObject.newValue = valueRespondDataParametersParametersItem["NewValue"].asString();
-			respondObject.parameters.push_back(parametersObject);
-		}
-		respond_.push_back(respondObject);
+		Respond::ParametersItem parametersItemObject;
+		if(!respondNodeParametersParametersItem["Status"].isNull())
+			parametersItemObject.status = respondNodeParametersParametersItem["Status"].asString();
+		if(!respondNodeParametersParametersItem["OldValue"].isNull())
+			parametersItemObject.oldValue = respondNodeParametersParametersItem["OldValue"].asString();
+		if(!respondNodeParametersParametersItem["UpdateTime"].isNull())
+			parametersItemObject.updateTime = respondNodeParametersParametersItem["UpdateTime"].asString();
+		if(!respondNodeParametersParametersItem["CreateTime"].isNull())
+			parametersItemObject.createTime = respondNodeParametersParametersItem["CreateTime"].asString();
+		if(!respondNodeParametersParametersItem["DimensionValue"].isNull())
+			parametersItemObject.dimensionValue = respondNodeParametersParametersItem["DimensionValue"].asString();
+		if(!respondNodeParametersParametersItem["Name"].isNull())
+			parametersItemObject.name = respondNodeParametersParametersItem["Name"].asString();
+		if(!respondNodeParametersParametersItem["NewValue"].isNull())
+			parametersItemObject.newValue = respondNodeParametersParametersItem["NewValue"].asString();
+		respond_.parameters.push_back(parametersItemObject);
 	}
 
 }
 
-std::vector<DescribeParametersHistoryResult::Data> DescribeParametersHistoryResult::getRespond()const
+DescribeParametersHistoryResult::Respond DescribeParametersHistoryResult::getRespond()const
 {
 	return respond_;
 }

oceanbasepro/src/model/DescribeProcessStatsCompositionRequest.cc

@@ -34,6 +34,15 @@ void DescribeProcessStatsCompositionRequest::setUId(const std::string &uId) {
   setBodyParameter(std::string("UId"), uId);
 }
 
+bool DescribeProcessStatsCompositionRequest::getMergeDynamicSql() const {
+  return mergeDynamicSql_;
+}
+
+void DescribeProcessStatsCompositionRequest::setMergeDynamicSql(bool mergeDynamicSql) {
+  mergeDynamicSql_ = mergeDynamicSql;
+  setBodyParameter(std::string("MergeDynamicSql"), mergeDynamicSql ? "true" : "false");
+}
+
 std::string DescribeProcessStatsCompositionRequest::getSqlText() const {
   return sqlText_;
 }

oceanbasepro/src/model/DescribeProcessStatsCompositionResult.cc

@@ -82,6 +82,86 @@ void DescribeProcessStatsCompositionResult::parse(const std::string &payload)
 			allProcessListItemObject.traceId = dataNodeAllProcessListAllProcessListItem["TraceId"].asString();
 		if(!dataNodeAllProcessListAllProcessListItem["PlanId"].isNull())
 			allProcessListItemObject.planId = dataNodeAllProcessListAllProcessListItem["PlanId"].asString();
+		if(!dataNodeAllProcessListAllProcessListItem["DynamicSql"].isNull())
+			allProcessListItemObject.dynamicSql = dataNodeAllProcessListAllProcessListItem["DynamicSql"].asString();
+		if(!dataNodeAllProcessListAllProcessListItem["ServerSn"].isNull())
+			allProcessListItemObject.serverSn = dataNodeAllProcessListAllProcessListItem["ServerSn"].asString();
+		auto allProcessSqlListsNode = dataNodeAllProcessListAllProcessListItem["ProcessSqlLists"]["ProcessSqlListsItem"];
+		for (auto dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem : allProcessSqlListsNode)
+		{
+			Data::AllProcessListItem::ProcessSqlListsItem processSqlListsObject;
+			if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["SqlText"].isNull())
+				processSqlListsObject.sqlText = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["SqlText"].asString();
+			if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["TenantId"].isNull())
+				processSqlListsObject.tenantId = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["TenantId"].asString();
+			if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["Database"].isNull())
+				processSqlListsObject.database = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["Database"].asString();
+			if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["User"].isNull())
+				processSqlListsObject.user = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["User"].asString();
+			if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["ExecuteTime"].isNull())
+				processSqlListsObject.executeTime = std::stol(dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["ExecuteTime"].asString());
+			if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["CpuTime"].isNull())
+				processSqlListsObject.cpuTime = std::stol(dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["CpuTime"].asString());
+			if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["ServerIp"].isNull())
+				processSqlListsObject.serverIp = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["ServerIp"].asString();
+			if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["ClientIp"].isNull())
+				processSqlListsObject.clientIp = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["ClientIp"].asString();
+			if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["SessionId"].isNull())
+				processSqlListsObject.sessionId = std::stol(dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["SessionId"].asString());
+			if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["ProxySessId"].isNull())
+				processSqlListsObject.proxySessId = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["ProxySessId"].asString();
+			if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["Command"].isNull())
+				processSqlListsObject.command = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["Command"].asString();
+			if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["Status"].isNull())
+				processSqlListsObject.status = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["Status"].asString();
+			if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["SqlId"].isNull())
+				processSqlListsObject.sqlId = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["SqlId"].asString();
+			if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["TraceId"].isNull())
+				processSqlListsObject.traceId = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["TraceId"].asString();
+			if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["PlanId"].isNull())
+				processSqlListsObject.planId = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["PlanId"].asString();
+			if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["DynamicSql"].isNull())
+				processSqlListsObject.dynamicSql = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["DynamicSql"].asString();
+			auto allProcessSqlListNode = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItem["ProcessSqlList"]["ProcessSqlListItem"];
+			for (auto dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem : allProcessSqlListNode)
+			{
+				Data::AllProcessListItem::ProcessSqlListsItem::ProcessSqlListItem processSqlListObject;
+				if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["SqlText"].isNull())
+					processSqlListObject.sqlText = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["SqlText"].asString();
+				if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["TenantId"].isNull())
+					processSqlListObject.tenantId = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["TenantId"].asString();
+				if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["Database"].isNull())
+					processSqlListObject.database = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["Database"].asString();
+				if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["User"].isNull())
+					processSqlListObject.user = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["User"].asString();
+				if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["ExecuteTime"].isNull())
+					processSqlListObject.executeTime = std::stol(dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["ExecuteTime"].asString());
+				if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["CpuTime"].isNull())
+					processSqlListObject.cpuTime = std::stol(dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["CpuTime"].asString());
+				if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["ServerIp"].isNull())
+					processSqlListObject.serverIp = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["ServerIp"].asString();
+				if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["ClientIp"].isNull())
+					processSqlListObject.clientIp = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["ClientIp"].asString();
+				if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["SessionId"].isNull())
+					processSqlListObject.sessionId = std::stol(dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["SessionId"].asString());
+				if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["ProxySessId"].isNull())
+					processSqlListObject.proxySessId = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["ProxySessId"].asString();
+				if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["Command"].isNull())
+					processSqlListObject.command = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["Command"].asString();
+				if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["Status"].isNull())
+					processSqlListObject.status = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["Status"].asString();
+				if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["SqlId"].isNull())
+					processSqlListObject.sqlId = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["SqlId"].asString();
+				if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["TraceId"].isNull())
+					processSqlListObject.traceId = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["TraceId"].asString();
+				if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["PlanId"].isNull())
+					processSqlListObject.planId = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["PlanId"].asString();
+				if(!dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["DynamicSql"].isNull())
+					processSqlListObject.dynamicSql = dataNodeAllProcessListAllProcessListItemProcessSqlListsProcessSqlListsItemProcessSqlListProcessSqlListItem["DynamicSql"].asString();
+				processSqlListsObject.processSqlList.push_back(processSqlListObject);
+			}
+			allProcessListItemObject.processSqlLists.push_back(processSqlListsObject);
+		}
 		data_.allProcessList.push_back(allProcessListItemObject);
 	}
 	auto sessionStatisticsNode = dataNode["SessionStatistics"];

oceanbasepro/src/model/DescribeProxyServiceRequest.cc

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

oceanbasepro/src/model/DescribeProxyServiceResult.cc

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

oceanbasepro/src/model/DescribeSampleSqlRawTextsRequest.cc

@@ -43,6 +43,15 @@ void DescribeSampleSqlRawTextsRequest::setStartTime(const std::string &startTime
   setBodyParameter(std::string("StartTime"), startTime);
 }
 
+bool DescribeSampleSqlRawTextsRequest::getDynamicSql() const {
+  return dynamicSql_;
+}
+
+void DescribeSampleSqlRawTextsRequest::setDynamicSql(bool dynamicSql) {
+  dynamicSql_ = dynamicSql;
+  setBodyParameter(std::string("DynamicSql"), dynamicSql ? "true" : "false");
+}
+
 std::string DescribeSampleSqlRawTextsRequest::getTenantId() const {
   return tenantId_;
 }

oceanbasepro/src/model/DescribeSqlAuditStatRequest.cc

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

oceanbasepro/src/model/DescribeSqlAuditStatResult.cc

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

oceanbasepro/src/model/DescribeTenantResult.cc

@@ -104,6 +104,10 @@ void DescribeTenantResult::parse(const std::string &payload)
 		tenant_.version = tenantNode["Version"].asString();
 	if(!tenantNode["OdpVersion"].isNull())
 		tenant_.odpVersion = tenantNode["OdpVersion"].asString();
+	if(!tenantNode["TenantMaxConnections"].isNull())
+		tenant_.tenantMaxConnections = tenantNode["TenantMaxConnections"].asString();
+	if(!tenantNode["ParameterTemplate"].isNull())
+		tenant_.parameterTemplate = tenantNode["ParameterTemplate"].asString();
 	auto allTenantConnectionsNode = tenantNode["TenantConnections"]["TenantConnectionsItem"];
 	for (auto tenantNodeTenantConnectionsTenantConnectionsItem : allTenantConnectionsNode)
 	{
@@ -158,6 +162,8 @@ void DescribeTenantResult::parse(const std::string &payload)
 			tenantConnectionsItemObject.intranetSqlPort = std::stoi(tenantNodeTenantConnectionsTenantConnectionsItem["IntranetSqlPort"].asString());
 		if(!tenantNodeTenantConnectionsTenantConnectionsItem["OdpVersion"].isNull())
 			tenantConnectionsItemObject.odpVersion = tenantNodeTenantConnectionsTenantConnectionsItem["OdpVersion"].asString();
+		if(!tenantNodeTenantConnectionsTenantConnectionsItem["InternetSqlPort"].isNull())
+			tenantConnectionsItemObject.internetSqlPort = std::stoi(tenantNodeTenantConnectionsTenantConnectionsItem["InternetSqlPort"].asString());
 		auto allConnectionZones = value["ConnectionZones"]["ConnectionZones"];
 		for (auto value : allConnectionZones)
 			tenantConnectionsItemObject.connectionZones.push_back(value.asString());
@@ -183,7 +189,7 @@ void DescribeTenantResult::parse(const std::string &payload)
 			if(!tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["ZoneReplicaType"].isNull())
 				tenantZoneReplicasObject.zoneReplicaType = tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["ZoneReplicaType"].asString();
 			if(!tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["ZoneNodes"].isNull())
-				tenantZoneReplicasObject.zoneNodes = tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["ZoneNodes"].asString();
+				tenantZoneReplicasObject.zoneNodes = std::stol(tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["ZoneNodes"].asString());
 			if(!tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["LogicZoneName"].isNull())
 				tenantZoneReplicasObject.logicZoneName = tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["LogicZoneName"].asString();
 			if(!tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["ZoneCopyId"].isNull())
@@ -192,6 +198,8 @@ void DescribeTenantResult::parse(const std::string &payload)
 				tenantZoneReplicasObject.fullCopyId = std::stoi(tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["FullCopyId"].asString());
 			if(!tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["ReadOnlyCopyId"].isNull())
 				tenantZoneReplicasObject.readOnlyCopyId = tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["ReadOnlyCopyId"].asString();
+			if(!tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["ReadOnlyReplicaType"].isNull())
+				tenantZoneReplicasObject.readOnlyReplicaType = tenantNodeTenantZonesTenantZonesItemTenantZoneReplicasTenantZoneReplicasItem["ReadOnlyReplicaType"].asString();
 			tenantZonesItemObject.tenantZoneReplicas.push_back(tenantZoneReplicasObject);
 		}
 		tenant_.tenantZones.push_back(tenantZonesItemObject);

oceanbasepro/src/model/DescribeTenantUserRolesRequest.cc

@@ -25,6 +25,15 @@ DescribeTenantUserRolesRequest::DescribeTenantUserRolesRequest()
 
 DescribeTenantUserRolesRequest::~DescribeTenantUserRolesRequest() {}
 
+std::string DescribeTenantUserRolesRequest::getInstanceId() const {
+  return instanceId_;
+}
+
+void DescribeTenantUserRolesRequest::setInstanceId(const std::string &instanceId) {
+  instanceId_ = instanceId;
+  setBodyParameter(std::string("InstanceId"), instanceId);
+}
+
 std::string DescribeTenantUserRolesRequest::getTenantId() const {
   return tenantId_;
 }

oceanbasepro/src/model/DescribeTenantUsersResult.cc

@@ -55,6 +55,8 @@ void DescribeTenantUsersResult::parse(const std::string &payload)
 			tenantUsersObject.tenantId = valueTenantUsersTenantUsersItem["TenantId"].asString();
 		if(!valueTenantUsersTenantUsersItem["InstanceId"].isNull())
 			tenantUsersObject.instanceId = valueTenantUsersTenantUsersItem["InstanceId"].asString();
+		if(!valueTenantUsersTenantUsersItem["GlobalPermissions"].isNull())
+			tenantUsersObject.globalPermissions = valueTenantUsersTenantUsersItem["GlobalPermissions"].asString();
 		auto allDatabasesNode = valueTenantUsersTenantUsersItem["Databases"]["DatabasesItem"];
 		for (auto valueTenantUsersTenantUsersItemDatabasesDatabasesItem : allDatabasesNode)
 		{

oceanbasepro/src/model/DescribeTenantsResult.cc

@@ -81,6 +81,8 @@ void DescribeTenantsResult::parse(const std::string &payload)
 			tenantsObject.collation = valueTenantsData["Collation"].asString();
 		if(!valueTenantsData["EnableReadOnlyReplica"].isNull())
 			tenantsObject.enableReadOnlyReplica = valueTenantsData["EnableReadOnlyReplica"].asString() == "true";
+		if(!valueTenantsData["ParameterTemplate"].isNull())
+			tenantsObject.parameterTemplate = valueTenantsData["ParameterTemplate"].asString();
 		tenants_.push_back(tenantsObject);
 	}
 	if(!value["TotalCount"].isNull())

oceanbasepro/src/model/ModifyInstanceSSLRequest.cc

@@ -43,3 +43,12 @@ void ModifyInstanceSSLRequest::setEnableSSL(const std::string &enableSSL) {
   setBodyParameter(std::string("EnableSSL"), enableSSL);
 }
 
+std::string ModifyInstanceSSLRequest::getTenantId() const {
+  return tenantId_;
+}
+
+void ModifyInstanceSSLRequest::setTenantId(const std::string &tenantId) {
+  tenantId_ = tenantId;
+  setBodyParameter(std::string("TenantId"), tenantId);
+}
+

oceanbasepro/src/model/ModifyInstanceSSLResult.cc

@@ -44,6 +44,8 @@ void ModifyInstanceSSLResult::parse(const std::string &payload)
 		instanceSSL_.instanceId = instanceSSLNode["InstanceId"].asString();
 	if(!instanceSSLNode["EnableSSL"].isNull())
 		instanceSSL_.enableSSL = instanceSSLNode["EnableSSL"].asString();
+	if(!instanceSSLNode["TenantId"].isNull())
+		instanceSSL_.tenantId = instanceSSLNode["TenantId"].asString();
 
 }
 

oceanbasepro/src/model/ModifyTenantUserRolesRequest.cc

@@ -25,6 +25,15 @@ ModifyTenantUserRolesRequest::ModifyTenantUserRolesRequest()
 
 ModifyTenantUserRolesRequest::~ModifyTenantUserRolesRequest() {}
 
+std::string ModifyTenantUserRolesRequest::getUserType() const {
+  return userType_;
+}
+
+void ModifyTenantUserRolesRequest::setUserType(const std::string &userType) {
+  userType_ = userType;
+  setBodyParameter(std::string("UserType"), userType);
+}
+
 std::string ModifyTenantUserRolesRequest::getUserRole() const {
   return userRole_;
 }
@@ -52,6 +61,15 @@ void ModifyTenantUserRolesRequest::setModifyType(const std::string &modifyType)
   setBodyParameter(std::string("ModifyType"), modifyType);
 }
 
+std::string ModifyTenantUserRolesRequest::getGlobalPermissions() const {
+  return globalPermissions_;
+}
+
+void ModifyTenantUserRolesRequest::setGlobalPermissions(const std::string &globalPermissions) {
+  globalPermissions_ = globalPermissions;
+  setBodyParameter(std::string("GlobalPermissions"), globalPermissions);
+}
+
 std::string ModifyTenantUserRolesRequest::getTenantId() const {
   return tenantId_;
 }

oceanbasepro/src/model/RemoveStandbyInstanceRequest.cc

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

oceanbasepro/src/model/RemoveStandbyInstanceResult.cc

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

oceanbasepro/src/model/UpdateProjectConfigRequest.cc

@@ -58,8 +58,10 @@ UpdateProjectConfigRequest::FullTransferConfig UpdateProjectConfigRequest::getFu
 
 void UpdateProjectConfigRequest::setFullTransferConfig(const UpdateProjectConfigRequest::FullTransferConfig &fullTransferConfig) {
   fullTransferConfig_ = fullTransferConfig;
+  setBodyParameter(std::string("FullTransferConfig") + ".IndexDDLConcurrencyLimit", std::to_string(fullTransferConfig.indexDDLConcurrencyLimit));
   setBodyParameter(std::string("FullTransferConfig") + ".ThrottleRps", std::to_string(fullTransferConfig.throttleRps));
   setBodyParameter(std::string("FullTransferConfig") + ".WriteWorkerNum", std::to_string(fullTransferConfig.writeWorkerNum));
+  setBodyParameter(std::string("FullTransferConfig") + ".MaxConcurrentIndexDDLs", std::to_string(fullTransferConfig.maxConcurrentIndexDDLs));
   setBodyParameter(std::string("FullTransferConfig") + ".ReadWorkerNum", std::to_string(fullTransferConfig.readWorkerNum));
   setBodyParameter(std::string("FullTransferConfig") + ".ThrottleIOPS", std::to_string(fullTransferConfig.throttleIOPS));
 }