Support ModifyDBClusterPayType.

adb/src/AdbClient.cc

@@ -87,6 +87,42 @@ AdbClient::AllocateClusterPublicConnectionOutcomeCallable AdbClient::allocateClu
 	return task->get_future();
 }
 
+AdbClient::BindDBResourceGroupWithUserOutcome AdbClient::bindDBResourceGroupWithUser(const BindDBResourceGroupWithUserRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return BindDBResourceGroupWithUserOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return BindDBResourceGroupWithUserOutcome(BindDBResourceGroupWithUserResult(outcome.result()));
+	else
+		return BindDBResourceGroupWithUserOutcome(outcome.error());
+}
+
+void AdbClient::bindDBResourceGroupWithUserAsync(const BindDBResourceGroupWithUserRequest& request, const BindDBResourceGroupWithUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, bindDBResourceGroupWithUser(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdbClient::BindDBResourceGroupWithUserOutcomeCallable AdbClient::bindDBResourceGroupWithUserCallable(const BindDBResourceGroupWithUserRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<BindDBResourceGroupWithUserOutcome()>>(
+			[this, request]()
+			{
+			return this->bindDBResourceGroupWithUser(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 AdbClient::BindDBResourcePoolWithUserOutcome AdbClient::bindDBResourcePoolWithUser(const BindDBResourcePoolWithUserRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -195,6 +231,42 @@ AdbClient::CreateDBClusterOutcomeCallable AdbClient::createDBClusterCallable(con
 	return task->get_future();
 }
 
+AdbClient::CreateDBResourceGroupOutcome AdbClient::createDBResourceGroup(const CreateDBResourceGroupRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return CreateDBResourceGroupOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return CreateDBResourceGroupOutcome(CreateDBResourceGroupResult(outcome.result()));
+	else
+		return CreateDBResourceGroupOutcome(outcome.error());
+}
+
+void AdbClient::createDBResourceGroupAsync(const CreateDBResourceGroupRequest& request, const CreateDBResourceGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, createDBResourceGroup(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdbClient::CreateDBResourceGroupOutcomeCallable AdbClient::createDBResourceGroupCallable(const CreateDBResourceGroupRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<CreateDBResourceGroupOutcome()>>(
+			[this, request]()
+			{
+			return this->createDBResourceGroup(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 AdbClient::CreateDBResourcePoolOutcome AdbClient::createDBResourcePool(const CreateDBResourcePoolRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -339,6 +411,42 @@ AdbClient::DeleteDBClusterOutcomeCallable AdbClient::deleteDBClusterCallable(con
 	return task->get_future();
 }
 
+AdbClient::DeleteDBResourceGroupOutcome AdbClient::deleteDBResourceGroup(const DeleteDBResourceGroupRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DeleteDBResourceGroupOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DeleteDBResourceGroupOutcome(DeleteDBResourceGroupResult(outcome.result()));
+	else
+		return DeleteDBResourceGroupOutcome(outcome.error());
+}
+
+void AdbClient::deleteDBResourceGroupAsync(const DeleteDBResourceGroupRequest& request, const DeleteDBResourceGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, deleteDBResourceGroup(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdbClient::DeleteDBResourceGroupOutcomeCallable AdbClient::deleteDBResourceGroupCallable(const DeleteDBResourceGroupRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DeleteDBResourceGroupOutcome()>>(
+			[this, request]()
+			{
+			return this->deleteDBResourceGroup(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 AdbClient::DeleteDBResourcePoolOutcome AdbClient::deleteDBResourcePool(const DeleteDBResourcePoolRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -879,6 +987,78 @@ AdbClient::DescribeDBClusterAttributeOutcomeCallable AdbClient::describeDBCluste
 	return task->get_future();
 }
 
+AdbClient::DescribeDBClusterForecastOutcome AdbClient::describeDBClusterForecast(const DescribeDBClusterForecastRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDBClusterForecastOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDBClusterForecastOutcome(DescribeDBClusterForecastResult(outcome.result()));
+	else
+		return DescribeDBClusterForecastOutcome(outcome.error());
+}
+
+void AdbClient::describeDBClusterForecastAsync(const DescribeDBClusterForecastRequest& request, const DescribeDBClusterForecastAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDBClusterForecast(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdbClient::DescribeDBClusterForecastOutcomeCallable AdbClient::describeDBClusterForecastCallable(const DescribeDBClusterForecastRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDBClusterForecastOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDBClusterForecast(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AdbClient::DescribeDBClusterHealthReportOutcome AdbClient::describeDBClusterHealthReport(const DescribeDBClusterHealthReportRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDBClusterHealthReportOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDBClusterHealthReportOutcome(DescribeDBClusterHealthReportResult(outcome.result()));
+	else
+		return DescribeDBClusterHealthReportOutcome(outcome.error());
+}
+
+void AdbClient::describeDBClusterHealthReportAsync(const DescribeDBClusterHealthReportRequest& request, const DescribeDBClusterHealthReportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDBClusterHealthReport(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdbClient::DescribeDBClusterHealthReportOutcomeCallable AdbClient::describeDBClusterHealthReportCallable(const DescribeDBClusterHealthReportRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDBClusterHealthReportOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDBClusterHealthReport(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 AdbClient::DescribeDBClusterNetInfoOutcome AdbClient::describeDBClusterNetInfo(const DescribeDBClusterNetInfoRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1023,6 +1203,42 @@ AdbClient::DescribeDBClustersOutcomeCallable AdbClient::describeDBClustersCallab
 	return task->get_future();
 }
 
+AdbClient::DescribeDBResourceGroupOutcome AdbClient::describeDBResourceGroup(const DescribeDBResourceGroupRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDBResourceGroupOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDBResourceGroupOutcome(DescribeDBResourceGroupResult(outcome.result()));
+	else
+		return DescribeDBResourceGroupOutcome(outcome.error());
+}
+
+void AdbClient::describeDBResourceGroupAsync(const DescribeDBResourceGroupRequest& request, const DescribeDBResourceGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDBResourceGroup(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdbClient::DescribeDBResourceGroupOutcomeCallable AdbClient::describeDBResourceGroupCallable(const DescribeDBResourceGroupRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDBResourceGroupOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDBResourceGroup(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 AdbClient::DescribeDBResourcePoolOutcome AdbClient::describeDBResourcePool(const DescribeDBResourcePoolRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1059,6 +1275,114 @@ AdbClient::DescribeDBResourcePoolOutcomeCallable AdbClient::describeDBResourcePo
 	return task->get_future();
 }
 
+AdbClient::DescribeDiagnosisDimensionsOutcome AdbClient::describeDiagnosisDimensions(const DescribeDiagnosisDimensionsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDiagnosisDimensionsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDiagnosisDimensionsOutcome(DescribeDiagnosisDimensionsResult(outcome.result()));
+	else
+		return DescribeDiagnosisDimensionsOutcome(outcome.error());
+}
+
+void AdbClient::describeDiagnosisDimensionsAsync(const DescribeDiagnosisDimensionsRequest& request, const DescribeDiagnosisDimensionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDiagnosisDimensions(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdbClient::DescribeDiagnosisDimensionsOutcomeCallable AdbClient::describeDiagnosisDimensionsCallable(const DescribeDiagnosisDimensionsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDiagnosisDimensionsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDiagnosisDimensions(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AdbClient::DescribeDiagnosisRecordsOutcome AdbClient::describeDiagnosisRecords(const DescribeDiagnosisRecordsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDiagnosisRecordsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDiagnosisRecordsOutcome(DescribeDiagnosisRecordsResult(outcome.result()));
+	else
+		return DescribeDiagnosisRecordsOutcome(outcome.error());
+}
+
+void AdbClient::describeDiagnosisRecordsAsync(const DescribeDiagnosisRecordsRequest& request, const DescribeDiagnosisRecordsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDiagnosisRecords(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdbClient::DescribeDiagnosisRecordsOutcomeCallable AdbClient::describeDiagnosisRecordsCallable(const DescribeDiagnosisRecordsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDiagnosisRecordsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDiagnosisRecords(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AdbClient::DescribeDownloadRecordsOutcome AdbClient::describeDownloadRecords(const DescribeDownloadRecordsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDownloadRecordsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDownloadRecordsOutcome(DescribeDownloadRecordsResult(outcome.result()));
+	else
+		return DescribeDownloadRecordsOutcome(outcome.error());
+}
+
+void AdbClient::describeDownloadRecordsAsync(const DescribeDownloadRecordsRequest& request, const DescribeDownloadRecordsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDownloadRecords(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdbClient::DescribeDownloadRecordsOutcomeCallable AdbClient::describeDownloadRecordsCallable(const DescribeDownloadRecordsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDownloadRecordsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDownloadRecords(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 AdbClient::DescribeElasticDailyPlanOutcome AdbClient::describeElasticDailyPlan(const DescribeElasticDailyPlanRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1203,6 +1527,42 @@ AdbClient::DescribeLoadTasksRecordsOutcomeCallable AdbClient::describeLoadTasksR
 	return task->get_future();
 }
 
+AdbClient::DescribeMaintenanceActionOutcome AdbClient::describeMaintenanceAction(const DescribeMaintenanceActionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeMaintenanceActionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeMaintenanceActionOutcome(DescribeMaintenanceActionResult(outcome.result()));
+	else
+		return DescribeMaintenanceActionOutcome(outcome.error());
+}
+
+void AdbClient::describeMaintenanceActionAsync(const DescribeMaintenanceActionRequest& request, const DescribeMaintenanceActionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeMaintenanceAction(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdbClient::DescribeMaintenanceActionOutcomeCallable AdbClient::describeMaintenanceActionCallable(const DescribeMaintenanceActionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeMaintenanceActionOutcome()>>(
+			[this, request]()
+			{
+			return this->describeMaintenanceAction(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 AdbClient::DescribeOperatorPermissionOutcome AdbClient::describeOperatorPermission(const DescribeOperatorPermissionRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1239,6 +1599,42 @@ AdbClient::DescribeOperatorPermissionOutcomeCallable AdbClient::describeOperator
 	return task->get_future();
 }
 
+AdbClient::DescribePatternPerformanceOutcome AdbClient::describePatternPerformance(const DescribePatternPerformanceRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribePatternPerformanceOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribePatternPerformanceOutcome(DescribePatternPerformanceResult(outcome.result()));
+	else
+		return DescribePatternPerformanceOutcome(outcome.error());
+}
+
+void AdbClient::describePatternPerformanceAsync(const DescribePatternPerformanceRequest& request, const DescribePatternPerformanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describePatternPerformance(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdbClient::DescribePatternPerformanceOutcomeCallable AdbClient::describePatternPerformanceCallable(const DescribePatternPerformanceRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribePatternPerformanceOutcome()>>(
+			[this, request]()
+			{
+			return this->describePatternPerformance(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 AdbClient::DescribeProcessListOutcome AdbClient::describeProcessList(const DescribeProcessListRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1311,6 +1707,78 @@ AdbClient::DescribeRegionsOutcomeCallable AdbClient::describeRegionsCallable(con
 	return task->get_future();
 }
 
+AdbClient::DescribeSQLPatternAttributeOutcome AdbClient::describeSQLPatternAttribute(const DescribeSQLPatternAttributeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeSQLPatternAttributeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeSQLPatternAttributeOutcome(DescribeSQLPatternAttributeResult(outcome.result()));
+	else
+		return DescribeSQLPatternAttributeOutcome(outcome.error());
+}
+
+void AdbClient::describeSQLPatternAttributeAsync(const DescribeSQLPatternAttributeRequest& request, const DescribeSQLPatternAttributeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeSQLPatternAttribute(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdbClient::DescribeSQLPatternAttributeOutcomeCallable AdbClient::describeSQLPatternAttributeCallable(const DescribeSQLPatternAttributeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeSQLPatternAttributeOutcome()>>(
+			[this, request]()
+			{
+			return this->describeSQLPatternAttribute(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AdbClient::DescribeSQLPatternsOutcome AdbClient::describeSQLPatterns(const DescribeSQLPatternsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeSQLPatternsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeSQLPatternsOutcome(DescribeSQLPatternsResult(outcome.result()));
+	else
+		return DescribeSQLPatternsOutcome(outcome.error());
+}
+
+void AdbClient::describeSQLPatternsAsync(const DescribeSQLPatternsRequest& request, const DescribeSQLPatternsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeSQLPatterns(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdbClient::DescribeSQLPatternsOutcomeCallable AdbClient::describeSQLPatternsCallable(const DescribeSQLPatternsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeSQLPatternsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeSQLPatterns(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 AdbClient::DescribeSQLPlanOutcome AdbClient::describeSQLPlan(const DescribeSQLPlanRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1491,6 +1959,78 @@ AdbClient::DescribeSlowLogTrendOutcomeCallable AdbClient::describeSlowLogTrendCa
 	return task->get_future();
 }
 
+AdbClient::DescribeSqlPatternOutcome AdbClient::describeSqlPattern(const DescribeSqlPatternRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeSqlPatternOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeSqlPatternOutcome(DescribeSqlPatternResult(outcome.result()));
+	else
+		return DescribeSqlPatternOutcome(outcome.error());
+}
+
+void AdbClient::describeSqlPatternAsync(const DescribeSqlPatternRequest& request, const DescribeSqlPatternAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeSqlPattern(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdbClient::DescribeSqlPatternOutcomeCallable AdbClient::describeSqlPatternCallable(const DescribeSqlPatternRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeSqlPatternOutcome()>>(
+			[this, request]()
+			{
+			return this->describeSqlPattern(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+AdbClient::DescribeTableAccessCountOutcome AdbClient::describeTableAccessCount(const DescribeTableAccessCountRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeTableAccessCountOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeTableAccessCountOutcome(DescribeTableAccessCountResult(outcome.result()));
+	else
+		return DescribeTableAccessCountOutcome(outcome.error());
+}
+
+void AdbClient::describeTableAccessCountAsync(const DescribeTableAccessCountRequest& request, const DescribeTableAccessCountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeTableAccessCount(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdbClient::DescribeTableAccessCountOutcomeCallable AdbClient::describeTableAccessCountCallable(const DescribeTableAccessCountRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeTableAccessCountOutcome()>>(
+			[this, request]()
+			{
+			return this->describeTableAccessCount(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 AdbClient::DescribeTableDetailOutcome AdbClient::describeTableDetail(const DescribeTableDetailRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1671,6 +2211,42 @@ AdbClient::DescribeTaskInfoOutcomeCallable AdbClient::describeTaskInfoCallable(c
 	return task->get_future();
 }
 
+AdbClient::DownloadDiagnosisRecordsOutcome AdbClient::downloadDiagnosisRecords(const DownloadDiagnosisRecordsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DownloadDiagnosisRecordsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DownloadDiagnosisRecordsOutcome(DownloadDiagnosisRecordsResult(outcome.result()));
+	else
+		return DownloadDiagnosisRecordsOutcome(outcome.error());
+}
+
+void AdbClient::downloadDiagnosisRecordsAsync(const DownloadDiagnosisRecordsRequest& request, const DownloadDiagnosisRecordsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, downloadDiagnosisRecords(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdbClient::DownloadDiagnosisRecordsOutcomeCallable AdbClient::downloadDiagnosisRecordsCallable(const DownloadDiagnosisRecordsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DownloadDiagnosisRecordsOutcome()>>(
+			[this, request]()
+			{
+			return this->downloadDiagnosisRecords(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 AdbClient::GrantOperatorPermissionOutcome AdbClient::grantOperatorPermission(const GrantOperatorPermissionRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2103,6 +2679,42 @@ AdbClient::ModifyDBClusterMaintainTimeOutcomeCallable AdbClient::modifyDBCluster
 	return task->get_future();
 }
 
+AdbClient::ModifyDBClusterPayTypeOutcome AdbClient::modifyDBClusterPayType(const ModifyDBClusterPayTypeRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifyDBClusterPayTypeOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyDBClusterPayTypeOutcome(ModifyDBClusterPayTypeResult(outcome.result()));
+	else
+		return ModifyDBClusterPayTypeOutcome(outcome.error());
+}
+
+void AdbClient::modifyDBClusterPayTypeAsync(const ModifyDBClusterPayTypeRequest& request, const ModifyDBClusterPayTypeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyDBClusterPayType(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdbClient::ModifyDBClusterPayTypeOutcomeCallable AdbClient::modifyDBClusterPayTypeCallable(const ModifyDBClusterPayTypeRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyDBClusterPayTypeOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyDBClusterPayType(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 AdbClient::ModifyDBClusterResourceGroupOutcome AdbClient::modifyDBClusterResourceGroup(const ModifyDBClusterResourceGroupRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2139,6 +2751,42 @@ AdbClient::ModifyDBClusterResourceGroupOutcomeCallable AdbClient::modifyDBCluste
 	return task->get_future();
 }
 
+AdbClient::ModifyDBResourceGroupOutcome AdbClient::modifyDBResourceGroup(const ModifyDBResourceGroupRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifyDBResourceGroupOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyDBResourceGroupOutcome(ModifyDBResourceGroupResult(outcome.result()));
+	else
+		return ModifyDBResourceGroupOutcome(outcome.error());
+}
+
+void AdbClient::modifyDBResourceGroupAsync(const ModifyDBResourceGroupRequest& request, const ModifyDBResourceGroupAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyDBResourceGroup(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdbClient::ModifyDBResourceGroupOutcomeCallable AdbClient::modifyDBResourceGroupCallable(const ModifyDBResourceGroupRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyDBResourceGroupOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyDBResourceGroup(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 AdbClient::ModifyDBResourcePoolOutcome AdbClient::modifyDBResourcePool(const ModifyDBResourcePoolRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2247,6 +2895,42 @@ AdbClient::ModifyLogBackupPolicyOutcomeCallable AdbClient::modifyLogBackupPolicy
 	return task->get_future();
 }
 
+AdbClient::ModifyMaintenanceActionOutcome AdbClient::modifyMaintenanceAction(const ModifyMaintenanceActionRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifyMaintenanceActionOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyMaintenanceActionOutcome(ModifyMaintenanceActionResult(outcome.result()));
+	else
+		return ModifyMaintenanceActionOutcome(outcome.error());
+}
+
+void AdbClient::modifyMaintenanceActionAsync(const ModifyMaintenanceActionRequest& request, const ModifyMaintenanceActionAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyMaintenanceAction(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdbClient::ModifyMaintenanceActionOutcomeCallable AdbClient::modifyMaintenanceActionCallable(const ModifyMaintenanceActionRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyMaintenanceActionOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyMaintenanceAction(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 AdbClient::ReleaseClusterPublicConnectionOutcome AdbClient::releaseClusterPublicConnection(const ReleaseClusterPublicConnectionRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -2391,6 +3075,42 @@ AdbClient::TagResourcesOutcomeCallable AdbClient::tagResourcesCallable(const Tag
 	return task->get_future();
 }
 
+AdbClient::UnbindDBResourceGroupWithUserOutcome AdbClient::unbindDBResourceGroupWithUser(const UnbindDBResourceGroupWithUserRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return UnbindDBResourceGroupWithUserOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return UnbindDBResourceGroupWithUserOutcome(UnbindDBResourceGroupWithUserResult(outcome.result()));
+	else
+		return UnbindDBResourceGroupWithUserOutcome(outcome.error());
+}
+
+void AdbClient::unbindDBResourceGroupWithUserAsync(const UnbindDBResourceGroupWithUserRequest& request, const UnbindDBResourceGroupWithUserAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, unbindDBResourceGroupWithUser(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+AdbClient::UnbindDBResourceGroupWithUserOutcomeCallable AdbClient::unbindDBResourceGroupWithUserCallable(const UnbindDBResourceGroupWithUserRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<UnbindDBResourceGroupWithUserOutcome()>>(
+			[this, request]()
+			{
+			return this->unbindDBResourceGroupWithUser(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 AdbClient::UnbindDBResourcePoolWithUserOutcome AdbClient::unbindDBResourcePoolWithUser(const UnbindDBResourcePoolWithUserRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

adb/src/model/AllocateClusterPublicConnectionRequest.cc

@@ -1,106 +1,90 @@
 /*
  * 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/adb/model/AllocateClusterPublicConnectionRequest.h>
-
-using AlibabaCloud::Adb::Model::AllocateClusterPublicConnectionRequest;
-
-AllocateClusterPublicConnectionRequest::AllocateClusterPublicConnectionRequest() :
-	RpcServiceRequest("adb", "2019-03-15", "AllocateClusterPublicConnection")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-AllocateClusterPublicConnectionRequest::~AllocateClusterPublicConnectionRequest()
-{}
-
-long AllocateClusterPublicConnectionRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/adb/model/AllocateClusterPublicConnectionRequest.h>
+
+using AlibabaCloud::Adb::Model::AllocateClusterPublicConnectionRequest;
+
+AllocateClusterPublicConnectionRequest::AllocateClusterPublicConnectionRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "AllocateClusterPublicConnection") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void AllocateClusterPublicConnectionRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+AllocateClusterPublicConnectionRequest::~AllocateClusterPublicConnectionRequest() {}
+
+long AllocateClusterPublicConnectionRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string AllocateClusterPublicConnectionRequest::getConnectionStringPrefix()const
-{
-	return connectionStringPrefix_;
+void AllocateClusterPublicConnectionRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void AllocateClusterPublicConnectionRequest::setConnectionStringPrefix(const std::string& connectionStringPrefix)
-{
-	connectionStringPrefix_ = connectionStringPrefix;
-	setParameter("ConnectionStringPrefix", connectionStringPrefix);
+std::string AllocateClusterPublicConnectionRequest::getConnectionStringPrefix() const {
+  return connectionStringPrefix_;
 }
 
-std::string AllocateClusterPublicConnectionRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
+void AllocateClusterPublicConnectionRequest::setConnectionStringPrefix(const std::string &connectionStringPrefix) {
+  connectionStringPrefix_ = connectionStringPrefix;
+  setParameter(std::string("ConnectionStringPrefix"), connectionStringPrefix);
 }
 
-void AllocateClusterPublicConnectionRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+std::string AllocateClusterPublicConnectionRequest::getAccessKeyId() const {
+  return accessKeyId_;
 }
 
-std::string AllocateClusterPublicConnectionRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void AllocateClusterPublicConnectionRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-void AllocateClusterPublicConnectionRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string AllocateClusterPublicConnectionRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string AllocateClusterPublicConnectionRequest::getDBClusterId()const
-{
-	return dBClusterId_;
+void AllocateClusterPublicConnectionRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void AllocateClusterPublicConnectionRequest::setDBClusterId(const std::string& dBClusterId)
-{
-	dBClusterId_ = dBClusterId;
-	setParameter("DBClusterId", dBClusterId);
+std::string AllocateClusterPublicConnectionRequest::getDBClusterId() const {
+  return dBClusterId_;
 }
 
-std::string AllocateClusterPublicConnectionRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void AllocateClusterPublicConnectionRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
 }
 
-void AllocateClusterPublicConnectionRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string AllocateClusterPublicConnectionRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long AllocateClusterPublicConnectionRequest::getOwnerId()const
-{
-	return ownerId_;
+void AllocateClusterPublicConnectionRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void AllocateClusterPublicConnectionRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long AllocateClusterPublicConnectionRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void AllocateClusterPublicConnectionRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 

adb/src/model/BindDBResourceGroupWithUserRequest.cc

@@ -0,0 +1,99 @@
+/*
+ * 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/adb/model/BindDBResourceGroupWithUserRequest.h>
+
+using AlibabaCloud::Adb::Model::BindDBResourceGroupWithUserRequest;
+
+BindDBResourceGroupWithUserRequest::BindDBResourceGroupWithUserRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "BindDBResourceGroupWithUser") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+BindDBResourceGroupWithUserRequest::~BindDBResourceGroupWithUserRequest() {}
+
+long BindDBResourceGroupWithUserRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void BindDBResourceGroupWithUserRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string BindDBResourceGroupWithUserRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void BindDBResourceGroupWithUserRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string BindDBResourceGroupWithUserRequest::getGroupUser() const {
+  return groupUser_;
+}
+
+void BindDBResourceGroupWithUserRequest::setGroupUser(const std::string &groupUser) {
+  groupUser_ = groupUser;
+  setParameter(std::string("GroupUser"), groupUser);
+}
+
+std::string BindDBResourceGroupWithUserRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void BindDBResourceGroupWithUserRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string BindDBResourceGroupWithUserRequest::getDBClusterId() const {
+  return dBClusterId_;
+}
+
+void BindDBResourceGroupWithUserRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
+}
+
+std::string BindDBResourceGroupWithUserRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void BindDBResourceGroupWithUserRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long BindDBResourceGroupWithUserRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void BindDBResourceGroupWithUserRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string BindDBResourceGroupWithUserRequest::getGroupName() const {
+  return groupName_;
+}
+
+void BindDBResourceGroupWithUserRequest::setGroupName(const std::string &groupName) {
+  groupName_ = groupName;
+  setParameter(std::string("GroupName"), groupName);
+}
+

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

adb/src/model/BindDBResourcePoolWithUserRequest.cc

@@ -1,117 +1,99 @@
 /*
  * 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/adb/model/BindDBResourcePoolWithUserRequest.h>
-
-using AlibabaCloud::Adb::Model::BindDBResourcePoolWithUserRequest;
-
-BindDBResourcePoolWithUserRequest::BindDBResourcePoolWithUserRequest() :
-	RpcServiceRequest("adb", "2019-03-15", "BindDBResourcePoolWithUser")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-BindDBResourcePoolWithUserRequest::~BindDBResourcePoolWithUserRequest()
-{}
-
-std::string BindDBResourcePoolWithUserRequest::getPoolName()const
-{
-	return poolName_;
+ */
+
+#include <alibabacloud/adb/model/BindDBResourcePoolWithUserRequest.h>
+
+using AlibabaCloud::Adb::Model::BindDBResourcePoolWithUserRequest;
+
+BindDBResourcePoolWithUserRequest::BindDBResourcePoolWithUserRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "BindDBResourcePoolWithUser") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void BindDBResourcePoolWithUserRequest::setPoolName(const std::string& poolName)
-{
-	poolName_ = poolName;
-	setParameter("PoolName", poolName);
+BindDBResourcePoolWithUserRequest::~BindDBResourcePoolWithUserRequest() {}
+
+std::string BindDBResourcePoolWithUserRequest::getPoolName() const {
+  return poolName_;
 }
 
-long BindDBResourcePoolWithUserRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+void BindDBResourcePoolWithUserRequest::setPoolName(const std::string &poolName) {
+  poolName_ = poolName;
+  setParameter(std::string("PoolName"), poolName);
 }
 
-void BindDBResourcePoolWithUserRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+long BindDBResourcePoolWithUserRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string BindDBResourcePoolWithUserRequest::getPoolUser()const
-{
-	return poolUser_;
+void BindDBResourcePoolWithUserRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void BindDBResourcePoolWithUserRequest::setPoolUser(const std::string& poolUser)
-{
-	poolUser_ = poolUser;
-	setParameter("PoolUser", poolUser);
+std::string BindDBResourcePoolWithUserRequest::getPoolUser() const {
+  return poolUser_;
 }
 
-std::string BindDBResourcePoolWithUserRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
+void BindDBResourcePoolWithUserRequest::setPoolUser(const std::string &poolUser) {
+  poolUser_ = poolUser;
+  setParameter(std::string("PoolUser"), poolUser);
 }
 
-void BindDBResourcePoolWithUserRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+std::string BindDBResourcePoolWithUserRequest::getAccessKeyId() const {
+  return accessKeyId_;
 }
 
-std::string BindDBResourcePoolWithUserRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void BindDBResourcePoolWithUserRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-void BindDBResourcePoolWithUserRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string BindDBResourcePoolWithUserRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string BindDBResourcePoolWithUserRequest::getDBClusterId()const
-{
-	return dBClusterId_;
+void BindDBResourcePoolWithUserRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void BindDBResourcePoolWithUserRequest::setDBClusterId(const std::string& dBClusterId)
-{
-	dBClusterId_ = dBClusterId;
-	setParameter("DBClusterId", dBClusterId);
+std::string BindDBResourcePoolWithUserRequest::getDBClusterId() const {
+  return dBClusterId_;
 }
 
-std::string BindDBResourcePoolWithUserRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void BindDBResourcePoolWithUserRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
 }
 
-void BindDBResourcePoolWithUserRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string BindDBResourcePoolWithUserRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long BindDBResourcePoolWithUserRequest::getOwnerId()const
-{
-	return ownerId_;
+void BindDBResourcePoolWithUserRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void BindDBResourcePoolWithUserRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long BindDBResourcePoolWithUserRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void BindDBResourcePoolWithUserRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 

adb/src/model/CreateAccountRequest.cc

@@ -1,139 +1,117 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
-
-#include <alibabacloud/adb/model/CreateAccountRequest.h>
-
-using AlibabaCloud::Adb::Model::CreateAccountRequest;
-
-CreateAccountRequest::CreateAccountRequest() :
-	RpcServiceRequest("adb", "2019-03-15", "CreateAccount")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CreateAccountRequest::~CreateAccountRequest()
-{}
-
-long CreateAccountRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/adb/model/CreateAccountRequest.h>
+
+using AlibabaCloud::Adb::Model::CreateAccountRequest;
+
+CreateAccountRequest::CreateAccountRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "CreateAccount") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void CreateAccountRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+CreateAccountRequest::~CreateAccountRequest() {}
+
+long CreateAccountRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string CreateAccountRequest::getAccountType()const
-{
-	return accountType_;
+void CreateAccountRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void CreateAccountRequest::setAccountType(const std::string& accountType)
-{
-	accountType_ = accountType;
-	setParameter("AccountType", accountType);
+std::string CreateAccountRequest::getAccountType() const {
+  return accountType_;
 }
 
-std::string CreateAccountRequest::getAccountDescription()const
-{
-	return accountDescription_;
+void CreateAccountRequest::setAccountType(const std::string &accountType) {
+  accountType_ = accountType;
+  setParameter(std::string("AccountType"), accountType);
 }
 
-void CreateAccountRequest::setAccountDescription(const std::string& accountDescription)
-{
-	accountDescription_ = accountDescription;
-	setParameter("AccountDescription", accountDescription);
+std::string CreateAccountRequest::getAccountDescription() const {
+  return accountDescription_;
 }
 
-std::string CreateAccountRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
+void CreateAccountRequest::setAccountDescription(const std::string &accountDescription) {
+  accountDescription_ = accountDescription;
+  setParameter(std::string("AccountDescription"), accountDescription);
 }
 
-void CreateAccountRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+std::string CreateAccountRequest::getAccessKeyId() const {
+  return accessKeyId_;
 }
 
-std::string CreateAccountRequest::getAccountName()const
-{
-	return accountName_;
+void CreateAccountRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-void CreateAccountRequest::setAccountName(const std::string& accountName)
-{
-	accountName_ = accountName;
-	setParameter("AccountName", accountName);
+std::string CreateAccountRequest::getAccountName() const {
+  return accountName_;
 }
 
-std::string CreateAccountRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void CreateAccountRequest::setAccountName(const std::string &accountName) {
+  accountName_ = accountName;
+  setParameter(std::string("AccountName"), accountName);
 }
 
-void CreateAccountRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string CreateAccountRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string CreateAccountRequest::getDBClusterId()const
-{
-	return dBClusterId_;
+void CreateAccountRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void CreateAccountRequest::setDBClusterId(const std::string& dBClusterId)
-{
-	dBClusterId_ = dBClusterId;
-	setParameter("DBClusterId", dBClusterId);
+std::string CreateAccountRequest::getDBClusterId() const {
+  return dBClusterId_;
 }
 
-std::string CreateAccountRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void CreateAccountRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
 }
 
-void CreateAccountRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string CreateAccountRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long CreateAccountRequest::getOwnerId()const
-{
-	return ownerId_;
+void CreateAccountRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void CreateAccountRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long CreateAccountRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string CreateAccountRequest::getAccountPassword()const
-{
-	return accountPassword_;
+void CreateAccountRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void CreateAccountRequest::setAccountPassword(const std::string& accountPassword)
-{
-	accountPassword_ = accountPassword;
-	setParameter("AccountPassword", accountPassword);
+std::string CreateAccountRequest::getAccountPassword() const {
+  return accountPassword_;
+}
+
+void CreateAccountRequest::setAccountPassword(const std::string &accountPassword) {
+  accountPassword_ = accountPassword;
+  setParameter(std::string("AccountPassword"), accountPassword);
 }
 

adb/src/model/CreateAccountResult.cc

@@ -39,10 +39,10 @@ void CreateAccountResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["DBClusterId"].isNull())
-		dBClusterId_ = value["DBClusterId"].asString();
 	if(!value["TaskId"].isNull())
 		taskId_ = std::stoi(value["TaskId"].asString());
+	if(!value["DBClusterId"].isNull())
+		dBClusterId_ = value["DBClusterId"].asString();
 
 }
 

adb/src/model/CreateDBClusterRequest.cc

@@ -1,359 +1,306 @@
 /*
  * 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/adb/model/CreateDBClusterRequest.h>
-
-using AlibabaCloud::Adb::Model::CreateDBClusterRequest;
-
-CreateDBClusterRequest::CreateDBClusterRequest() :
-	RpcServiceRequest("adb", "2019-03-15", "CreateDBCluster")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CreateDBClusterRequest::~CreateDBClusterRequest()
-{}
-
-long CreateDBClusterRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/adb/model/CreateDBClusterRequest.h>
+
+using AlibabaCloud::Adb::Model::CreateDBClusterRequest;
+
+CreateDBClusterRequest::CreateDBClusterRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "CreateDBCluster") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void CreateDBClusterRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+CreateDBClusterRequest::~CreateDBClusterRequest() {}
+
+long CreateDBClusterRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string CreateDBClusterRequest::getDBClusterDescription()const
-{
-	return dBClusterDescription_;
+void CreateDBClusterRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void CreateDBClusterRequest::setDBClusterDescription(const std::string& dBClusterDescription)
-{
-	dBClusterDescription_ = dBClusterDescription;
-	setParameter("DBClusterDescription", dBClusterDescription);
+std::string CreateDBClusterRequest::getDBClusterDescription() const {
+  return dBClusterDescription_;
 }
 
-std::string CreateDBClusterRequest::getStorageType()const
-{
-	return storageType_;
+void CreateDBClusterRequest::setDBClusterDescription(const std::string &dBClusterDescription) {
+  dBClusterDescription_ = dBClusterDescription;
+  setParameter(std::string("DBClusterDescription"), dBClusterDescription);
 }
 
-void CreateDBClusterRequest::setStorageType(const std::string& storageType)
-{
-	storageType_ = storageType;
-	setParameter("StorageType", storageType);
+std::string CreateDBClusterRequest::getStorageType() const {
+  return storageType_;
 }
 
-std::string CreateDBClusterRequest::getMode()const
-{
-	return mode_;
+void CreateDBClusterRequest::setStorageType(const std::string &storageType) {
+  storageType_ = storageType;
+  setParameter(std::string("StorageType"), storageType);
 }
 
-void CreateDBClusterRequest::setMode(const std::string& mode)
-{
-	mode_ = mode;
-	setParameter("Mode", mode);
+std::string CreateDBClusterRequest::getMode() const {
+  return mode_;
 }
 
-std::string CreateDBClusterRequest::getResourceGroupId()const
-{
-	return resourceGroupId_;
+void CreateDBClusterRequest::setMode(const std::string &mode) {
+  mode_ = mode;
+  setParameter(std::string("Mode"), mode);
 }
 
-void CreateDBClusterRequest::setResourceGroupId(const std::string& resourceGroupId)
-{
-	resourceGroupId_ = resourceGroupId;
-	setParameter("ResourceGroupId", resourceGroupId);
+std::string CreateDBClusterRequest::getResourceGroupId() const {
+  return resourceGroupId_;
 }
 
-std::string CreateDBClusterRequest::getPeriod()const
-{
-	return period_;
+void CreateDBClusterRequest::setResourceGroupId(const std::string &resourceGroupId) {
+  resourceGroupId_ = resourceGroupId;
+  setParameter(std::string("ResourceGroupId"), resourceGroupId);
 }
 
-void CreateDBClusterRequest::setPeriod(const std::string& period)
-{
-	period_ = period;
-	setParameter("Period", period);
+std::string CreateDBClusterRequest::getPeriod() const {
+  return period_;
 }
 
-std::string CreateDBClusterRequest::getBackupSetID()const
-{
-	return backupSetID_;
+void CreateDBClusterRequest::setPeriod(const std::string &period) {
+  period_ = period;
+  setParameter(std::string("Period"), period);
 }
 
-void CreateDBClusterRequest::setBackupSetID(const std::string& backupSetID)
-{
-	backupSetID_ = backupSetID;
-	setParameter("BackupSetID", backupSetID);
+std::string CreateDBClusterRequest::getBackupSetID() const {
+  return backupSetID_;
 }
 
-long CreateDBClusterRequest::getOwnerId()const
-{
-	return ownerId_;
+void CreateDBClusterRequest::setBackupSetID(const std::string &backupSetID) {
+  backupSetID_ = backupSetID;
+  setParameter(std::string("BackupSetID"), backupSetID);
 }
 
-void CreateDBClusterRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long CreateDBClusterRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string CreateDBClusterRequest::getDBNodeGroupCount()const
-{
-	return dBNodeGroupCount_;
+void CreateDBClusterRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void CreateDBClusterRequest::setDBNodeGroupCount(const std::string& dBNodeGroupCount)
-{
-	dBNodeGroupCount_ = dBNodeGroupCount;
-	setParameter("DBNodeGroupCount", dBNodeGroupCount);
+std::string CreateDBClusterRequest::getDBNodeGroupCount() const {
+  return dBNodeGroupCount_;
 }
 
-std::string CreateDBClusterRequest::getVSwitchId()const
-{
-	return vSwitchId_;
+void CreateDBClusterRequest::setDBNodeGroupCount(const std::string &dBNodeGroupCount) {
+  dBNodeGroupCount_ = dBNodeGroupCount;
+  setParameter(std::string("DBNodeGroupCount"), dBNodeGroupCount);
 }
 
-void CreateDBClusterRequest::setVSwitchId(const std::string& vSwitchId)
-{
-	vSwitchId_ = vSwitchId;
-	setParameter("VSwitchId", vSwitchId);
+std::string CreateDBClusterRequest::getVSwitchId() const {
+  return vSwitchId_;
 }
 
-std::string CreateDBClusterRequest::getZoneId()const
-{
-	return zoneId_;
+void CreateDBClusterRequest::setVSwitchId(const std::string &vSwitchId) {
+  vSwitchId_ = vSwitchId;
+  setParameter(std::string("VSwitchId"), vSwitchId);
 }
 
-void CreateDBClusterRequest::setZoneId(const std::string& zoneId)
-{
-	zoneId_ = zoneId;
-	setParameter("ZoneId", zoneId);
+std::string CreateDBClusterRequest::getZoneId() const {
+  return zoneId_;
 }
 
-std::string CreateDBClusterRequest::getComputeResource()const
-{
-	return computeResource_;
+void CreateDBClusterRequest::setZoneId(const std::string &zoneId) {
+  zoneId_ = zoneId;
+  setParameter(std::string("ZoneId"), zoneId);
 }
 
-void CreateDBClusterRequest::setComputeResource(const std::string& computeResource)
-{
-	computeResource_ = computeResource;
-	setParameter("ComputeResource", computeResource);
+std::string CreateDBClusterRequest::getComputeResource() const {
+  return computeResource_;
 }
 
-std::string CreateDBClusterRequest::getSourceDBInstanceName()const
-{
-	return sourceDBInstanceName_;
+void CreateDBClusterRequest::setComputeResource(const std::string &computeResource) {
+  computeResource_ = computeResource;
+  setParameter(std::string("ComputeResource"), computeResource);
 }
 
-void CreateDBClusterRequest::setSourceDBInstanceName(const std::string& sourceDBInstanceName)
-{
-	sourceDBInstanceName_ = sourceDBInstanceName;
-	setParameter("SourceDBInstanceName", sourceDBInstanceName);
+std::string CreateDBClusterRequest::getElasticIOResource() const {
+  return elasticIOResource_;
 }
 
-std::string CreateDBClusterRequest::getClientToken()const
-{
-	return clientToken_;
+void CreateDBClusterRequest::setElasticIOResource(const std::string &elasticIOResource) {
+  elasticIOResource_ = elasticIOResource;
+  setParameter(std::string("ElasticIOResource"), elasticIOResource);
 }
 
-void CreateDBClusterRequest::setClientToken(const std::string& clientToken)
-{
-	clientToken_ = clientToken;
-	setParameter("ClientToken", clientToken);
+std::string CreateDBClusterRequest::getSourceDBInstanceName() const {
+  return sourceDBInstanceName_;
 }
 
-std::string CreateDBClusterRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
+void CreateDBClusterRequest::setSourceDBInstanceName(const std::string &sourceDBInstanceName) {
+  sourceDBInstanceName_ = sourceDBInstanceName;
+  setParameter(std::string("SourceDBInstanceName"), sourceDBInstanceName);
 }
 
-void CreateDBClusterRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+std::string CreateDBClusterRequest::getClientToken() const {
+  return clientToken_;
 }
 
-std::string CreateDBClusterRequest::getStorageResource()const
-{
-	return storageResource_;
+void CreateDBClusterRequest::setClientToken(const std::string &clientToken) {
+  clientToken_ = clientToken;
+  setParameter(std::string("ClientToken"), clientToken);
 }
 
-void CreateDBClusterRequest::setStorageResource(const std::string& storageResource)
-{
-	storageResource_ = storageResource;
-	setParameter("StorageResource", storageResource);
+std::string CreateDBClusterRequest::getAccessKeyId() const {
+  return accessKeyId_;
 }
 
-std::string CreateDBClusterRequest::getRegionId()const
-{
-	return regionId_;
+void CreateDBClusterRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-void CreateDBClusterRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string CreateDBClusterRequest::getStorageResource() const {
+  return storageResource_;
 }
 
-std::string CreateDBClusterRequest::getDBClusterCategory()const
-{
-	return dBClusterCategory_;
+void CreateDBClusterRequest::setStorageResource(const std::string &storageResource) {
+  storageResource_ = storageResource;
+  setParameter(std::string("StorageResource"), storageResource);
 }
 
-void CreateDBClusterRequest::setDBClusterCategory(const std::string& dBClusterCategory)
-{
-	dBClusterCategory_ = dBClusterCategory;
-	setParameter("DBClusterCategory", dBClusterCategory);
+std::string CreateDBClusterRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string CreateDBClusterRequest::getDBClusterNetworkType()const
-{
-	return dBClusterNetworkType_;
+void CreateDBClusterRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void CreateDBClusterRequest::setDBClusterNetworkType(const std::string& dBClusterNetworkType)
-{
-	dBClusterNetworkType_ = dBClusterNetworkType;
-	setParameter("DBClusterNetworkType", dBClusterNetworkType);
+std::string CreateDBClusterRequest::getDBClusterCategory() const {
+  return dBClusterCategory_;
 }
 
-std::string CreateDBClusterRequest::getRestoreTime()const
-{
-	return restoreTime_;
+void CreateDBClusterRequest::setDBClusterCategory(const std::string &dBClusterCategory) {
+  dBClusterCategory_ = dBClusterCategory;
+  setParameter(std::string("DBClusterCategory"), dBClusterCategory);
 }
 
-void CreateDBClusterRequest::setRestoreTime(const std::string& restoreTime)
-{
-	restoreTime_ = restoreTime;
-	setParameter("RestoreTime", restoreTime);
+std::string CreateDBClusterRequest::getDBClusterNetworkType() const {
+  return dBClusterNetworkType_;
 }
 
-std::string CreateDBClusterRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void CreateDBClusterRequest::setDBClusterNetworkType(const std::string &dBClusterNetworkType) {
+  dBClusterNetworkType_ = dBClusterNetworkType;
+  setParameter(std::string("DBClusterNetworkType"), dBClusterNetworkType);
 }
 
-void CreateDBClusterRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string CreateDBClusterRequest::getRestoreTime() const {
+  return restoreTime_;
 }
 
-std::string CreateDBClusterRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void CreateDBClusterRequest::setRestoreTime(const std::string &restoreTime) {
+  restoreTime_ = restoreTime;
+  setParameter(std::string("RestoreTime"), restoreTime);
 }
 
-void CreateDBClusterRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string CreateDBClusterRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string CreateDBClusterRequest::getDBClusterVersion()const
-{
-	return dBClusterVersion_;
+void CreateDBClusterRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void CreateDBClusterRequest::setDBClusterVersion(const std::string& dBClusterVersion)
-{
-	dBClusterVersion_ = dBClusterVersion;
-	setParameter("DBClusterVersion", dBClusterVersion);
+std::string CreateDBClusterRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-std::string CreateDBClusterRequest::getDBClusterClass()const
-{
-	return dBClusterClass_;
+void CreateDBClusterRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void CreateDBClusterRequest::setDBClusterClass(const std::string& dBClusterClass)
-{
-	dBClusterClass_ = dBClusterClass;
-	setParameter("DBClusterClass", dBClusterClass);
+std::string CreateDBClusterRequest::getDBClusterVersion() const {
+  return dBClusterVersion_;
 }
 
-std::string CreateDBClusterRequest::getUsedTime()const
-{
-	return usedTime_;
+void CreateDBClusterRequest::setDBClusterVersion(const std::string &dBClusterVersion) {
+  dBClusterVersion_ = dBClusterVersion;
+  setParameter(std::string("DBClusterVersion"), dBClusterVersion);
 }
 
-void CreateDBClusterRequest::setUsedTime(const std::string& usedTime)
-{
-	usedTime_ = usedTime;
-	setParameter("UsedTime", usedTime);
+std::string CreateDBClusterRequest::getDBClusterClass() const {
+  return dBClusterClass_;
 }
 
-std::string CreateDBClusterRequest::getRestoreType()const
-{
-	return restoreType_;
+void CreateDBClusterRequest::setDBClusterClass(const std::string &dBClusterClass) {
+  dBClusterClass_ = dBClusterClass;
+  setParameter(std::string("DBClusterClass"), dBClusterClass);
 }
 
-void CreateDBClusterRequest::setRestoreType(const std::string& restoreType)
-{
-	restoreType_ = restoreType;
-	setParameter("RestoreType", restoreType);
+std::string CreateDBClusterRequest::getUsedTime() const {
+  return usedTime_;
 }
 
-std::string CreateDBClusterRequest::getDBNodeStorage()const
-{
-	return dBNodeStorage_;
+void CreateDBClusterRequest::setUsedTime(const std::string &usedTime) {
+  usedTime_ = usedTime;
+  setParameter(std::string("UsedTime"), usedTime);
 }
 
-void CreateDBClusterRequest::setDBNodeStorage(const std::string& dBNodeStorage)
-{
-	dBNodeStorage_ = dBNodeStorage;
-	setParameter("DBNodeStorage", dBNodeStorage);
+std::string CreateDBClusterRequest::getRestoreType() const {
+  return restoreType_;
 }
 
-std::string CreateDBClusterRequest::getExecutorCount()const
-{
-	return executorCount_;
+void CreateDBClusterRequest::setRestoreType(const std::string &restoreType) {
+  restoreType_ = restoreType;
+  setParameter(std::string("RestoreType"), restoreType);
 }
 
-void CreateDBClusterRequest::setExecutorCount(const std::string& executorCount)
-{
-	executorCount_ = executorCount;
-	setParameter("ExecutorCount", executorCount);
+std::string CreateDBClusterRequest::getDBNodeStorage() const {
+  return dBNodeStorage_;
 }
 
-std::string CreateDBClusterRequest::getVPCId()const
-{
-	return vPCId_;
+void CreateDBClusterRequest::setDBNodeStorage(const std::string &dBNodeStorage) {
+  dBNodeStorage_ = dBNodeStorage;
+  setParameter(std::string("DBNodeStorage"), dBNodeStorage);
 }
 
-void CreateDBClusterRequest::setVPCId(const std::string& vPCId)
-{
-	vPCId_ = vPCId;
-	setParameter("VPCId", vPCId);
+std::string CreateDBClusterRequest::getExecutorCount() const {
+  return executorCount_;
 }
 
-std::string CreateDBClusterRequest::getPayType()const
-{
-	return payType_;
+void CreateDBClusterRequest::setExecutorCount(const std::string &executorCount) {
+  executorCount_ = executorCount;
+  setParameter(std::string("ExecutorCount"), executorCount);
 }
 
-void CreateDBClusterRequest::setPayType(const std::string& payType)
-{
-	payType_ = payType;
-	setParameter("PayType", payType);
+std::string CreateDBClusterRequest::getVPCId() const {
+  return vPCId_;
+}
+
+void CreateDBClusterRequest::setVPCId(const std::string &vPCId) {
+  vPCId_ = vPCId;
+  setParameter(std::string("VPCId"), vPCId);
+}
+
+std::string CreateDBClusterRequest::getPayType() const {
+  return payType_;
+}
+
+void CreateDBClusterRequest::setPayType(const std::string &payType) {
+  payType_ = payType;
+  setParameter(std::string("PayType"), payType);
 }
 

adb/src/model/CreateDBClusterResult.cc

@@ -39,12 +39,12 @@ void CreateDBClusterResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
+	if(!value["ResourceGroupId"].isNull())
+		resourceGroupId_ = value["ResourceGroupId"].asString();
 	if(!value["DBClusterId"].isNull())
 		dBClusterId_ = value["DBClusterId"].asString();
 	if(!value["OrderId"].isNull())
 		orderId_ = value["OrderId"].asString();
-	if(!value["ResourceGroupId"].isNull())
-		resourceGroupId_ = value["ResourceGroupId"].asString();
 
 }
 

adb/src/model/CreateDBResourceGroupRequest.cc

@@ -0,0 +1,108 @@
+/*
+ * 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/adb/model/CreateDBResourceGroupRequest.h>
+
+using AlibabaCloud::Adb::Model::CreateDBResourceGroupRequest;
+
+CreateDBResourceGroupRequest::CreateDBResourceGroupRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "CreateDBResourceGroup") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+CreateDBResourceGroupRequest::~CreateDBResourceGroupRequest() {}
+
+long CreateDBResourceGroupRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void CreateDBResourceGroupRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+int CreateDBResourceGroupRequest::getNodeNum() const {
+  return nodeNum_;
+}
+
+void CreateDBResourceGroupRequest::setNodeNum(int nodeNum) {
+  nodeNum_ = nodeNum;
+  setParameter(std::string("NodeNum"), std::to_string(nodeNum));
+}
+
+std::string CreateDBResourceGroupRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void CreateDBResourceGroupRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string CreateDBResourceGroupRequest::getGroupType() const {
+  return groupType_;
+}
+
+void CreateDBResourceGroupRequest::setGroupType(const std::string &groupType) {
+  groupType_ = groupType;
+  setParameter(std::string("GroupType"), groupType);
+}
+
+std::string CreateDBResourceGroupRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void CreateDBResourceGroupRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string CreateDBResourceGroupRequest::getDBClusterId() const {
+  return dBClusterId_;
+}
+
+void CreateDBResourceGroupRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
+}
+
+std::string CreateDBResourceGroupRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void CreateDBResourceGroupRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long CreateDBResourceGroupRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void CreateDBResourceGroupRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string CreateDBResourceGroupRequest::getGroupName() const {
+  return groupName_;
+}
+
+void CreateDBResourceGroupRequest::setGroupName(const std::string &groupName) {
+  groupName_ = groupName;
+  setParameter(std::string("GroupName"), groupName);
+}
+

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

adb/src/model/CreateDBResourcePoolRequest.cc

@@ -1,128 +1,108 @@
 /*
  * 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/adb/model/CreateDBResourcePoolRequest.h>
-
-using AlibabaCloud::Adb::Model::CreateDBResourcePoolRequest;
-
-CreateDBResourcePoolRequest::CreateDBResourcePoolRequest() :
-	RpcServiceRequest("adb", "2019-03-15", "CreateDBResourcePool")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CreateDBResourcePoolRequest::~CreateDBResourcePoolRequest()
-{}
-
-std::string CreateDBResourcePoolRequest::getPoolName()const
-{
-	return poolName_;
+ */
+
+#include <alibabacloud/adb/model/CreateDBResourcePoolRequest.h>
+
+using AlibabaCloud::Adb::Model::CreateDBResourcePoolRequest;
+
+CreateDBResourcePoolRequest::CreateDBResourcePoolRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "CreateDBResourcePool") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void CreateDBResourcePoolRequest::setPoolName(const std::string& poolName)
-{
-	poolName_ = poolName;
-	setParameter("PoolName", poolName);
+CreateDBResourcePoolRequest::~CreateDBResourcePoolRequest() {}
+
+std::string CreateDBResourcePoolRequest::getPoolName() const {
+  return poolName_;
 }
 
-long CreateDBResourcePoolRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+void CreateDBResourcePoolRequest::setPoolName(const std::string &poolName) {
+  poolName_ = poolName;
+  setParameter(std::string("PoolName"), poolName);
 }
 
-void CreateDBResourcePoolRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+long CreateDBResourcePoolRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-int CreateDBResourcePoolRequest::getNodeNum()const
-{
-	return nodeNum_;
+void CreateDBResourcePoolRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void CreateDBResourcePoolRequest::setNodeNum(int nodeNum)
-{
-	nodeNum_ = nodeNum;
-	setParameter("NodeNum", std::to_string(nodeNum));
+int CreateDBResourcePoolRequest::getNodeNum() const {
+  return nodeNum_;
 }
 
-std::string CreateDBResourcePoolRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
+void CreateDBResourcePoolRequest::setNodeNum(int nodeNum) {
+  nodeNum_ = nodeNum;
+  setParameter(std::string("NodeNum"), std::to_string(nodeNum));
 }
 
-void CreateDBResourcePoolRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+std::string CreateDBResourcePoolRequest::getAccessKeyId() const {
+  return accessKeyId_;
 }
 
-std::string CreateDBResourcePoolRequest::getQueryType()const
-{
-	return queryType_;
+void CreateDBResourcePoolRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-void CreateDBResourcePoolRequest::setQueryType(const std::string& queryType)
-{
-	queryType_ = queryType;
-	setParameter("QueryType", queryType);
+std::string CreateDBResourcePoolRequest::getQueryType() const {
+  return queryType_;
 }
 
-std::string CreateDBResourcePoolRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void CreateDBResourcePoolRequest::setQueryType(const std::string &queryType) {
+  queryType_ = queryType;
+  setParameter(std::string("QueryType"), queryType);
 }
 
-void CreateDBResourcePoolRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string CreateDBResourcePoolRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string CreateDBResourcePoolRequest::getDBClusterId()const
-{
-	return dBClusterId_;
+void CreateDBResourcePoolRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void CreateDBResourcePoolRequest::setDBClusterId(const std::string& dBClusterId)
-{
-	dBClusterId_ = dBClusterId;
-	setParameter("DBClusterId", dBClusterId);
+std::string CreateDBResourcePoolRequest::getDBClusterId() const {
+  return dBClusterId_;
 }
 
-std::string CreateDBResourcePoolRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void CreateDBResourcePoolRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
 }
 
-void CreateDBResourcePoolRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string CreateDBResourcePoolRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long CreateDBResourcePoolRequest::getOwnerId()const
-{
-	return ownerId_;
+void CreateDBResourcePoolRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void CreateDBResourcePoolRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long CreateDBResourcePoolRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void CreateDBResourcePoolRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 

adb/src/model/CreateElasticPlanRequest.cc

@@ -1,194 +1,162 @@
 /*
  * 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/adb/model/CreateElasticPlanRequest.h>
-
-using AlibabaCloud::Adb::Model::CreateElasticPlanRequest;
-
-CreateElasticPlanRequest::CreateElasticPlanRequest() :
-	RpcServiceRequest("adb", "2019-03-15", "CreateElasticPlan")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-CreateElasticPlanRequest::~CreateElasticPlanRequest()
-{}
-
-long CreateElasticPlanRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/adb/model/CreateElasticPlanRequest.h>
+
+using AlibabaCloud::Adb::Model::CreateElasticPlanRequest;
+
+CreateElasticPlanRequest::CreateElasticPlanRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "CreateElasticPlan") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void CreateElasticPlanRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+CreateElasticPlanRequest::~CreateElasticPlanRequest() {}
+
+long CreateElasticPlanRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string CreateElasticPlanRequest::getElasticPlanTimeStart()const
-{
-	return elasticPlanTimeStart_;
+void CreateElasticPlanRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void CreateElasticPlanRequest::setElasticPlanTimeStart(const std::string& elasticPlanTimeStart)
-{
-	elasticPlanTimeStart_ = elasticPlanTimeStart;
-	setParameter("ElasticPlanTimeStart", elasticPlanTimeStart);
+std::string CreateElasticPlanRequest::getElasticPlanTimeStart() const {
+  return elasticPlanTimeStart_;
 }
 
-std::string CreateElasticPlanRequest::getElasticPlanEndDay()const
-{
-	return elasticPlanEndDay_;
+void CreateElasticPlanRequest::setElasticPlanTimeStart(const std::string &elasticPlanTimeStart) {
+  elasticPlanTimeStart_ = elasticPlanTimeStart;
+  setParameter(std::string("ElasticPlanTimeStart"), elasticPlanTimeStart);
 }
 
-void CreateElasticPlanRequest::setElasticPlanEndDay(const std::string& elasticPlanEndDay)
-{
-	elasticPlanEndDay_ = elasticPlanEndDay;
-	setParameter("ElasticPlanEndDay", elasticPlanEndDay);
+std::string CreateElasticPlanRequest::getElasticPlanEndDay() const {
+  return elasticPlanEndDay_;
 }
 
-std::string CreateElasticPlanRequest::getElasticPlanWeeklyRepeat()const
-{
-	return elasticPlanWeeklyRepeat_;
+void CreateElasticPlanRequest::setElasticPlanEndDay(const std::string &elasticPlanEndDay) {
+  elasticPlanEndDay_ = elasticPlanEndDay;
+  setParameter(std::string("ElasticPlanEndDay"), elasticPlanEndDay);
 }
 
-void CreateElasticPlanRequest::setElasticPlanWeeklyRepeat(const std::string& elasticPlanWeeklyRepeat)
-{
-	elasticPlanWeeklyRepeat_ = elasticPlanWeeklyRepeat;
-	setParameter("ElasticPlanWeeklyRepeat", elasticPlanWeeklyRepeat);
+std::string CreateElasticPlanRequest::getElasticPlanWeeklyRepeat() const {
+  return elasticPlanWeeklyRepeat_;
 }
 
-std::string CreateElasticPlanRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
+void CreateElasticPlanRequest::setElasticPlanWeeklyRepeat(const std::string &elasticPlanWeeklyRepeat) {
+  elasticPlanWeeklyRepeat_ = elasticPlanWeeklyRepeat;
+  setParameter(std::string("ElasticPlanWeeklyRepeat"), elasticPlanWeeklyRepeat);
 }
 
-void CreateElasticPlanRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+std::string CreateElasticPlanRequest::getAccessKeyId() const {
+  return accessKeyId_;
 }
 
-bool CreateElasticPlanRequest::getElasticPlanEnable()const
-{
-	return elasticPlanEnable_;
+void CreateElasticPlanRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-void CreateElasticPlanRequest::setElasticPlanEnable(bool elasticPlanEnable)
-{
-	elasticPlanEnable_ = elasticPlanEnable;
-	setParameter("ElasticPlanEnable", elasticPlanEnable ? "true" : "false");
+bool CreateElasticPlanRequest::getElasticPlanEnable() const {
+  return elasticPlanEnable_;
 }
 
-std::string CreateElasticPlanRequest::getElasticPlanTimeEnd()const
-{
-	return elasticPlanTimeEnd_;
+void CreateElasticPlanRequest::setElasticPlanEnable(bool elasticPlanEnable) {
+  elasticPlanEnable_ = elasticPlanEnable;
+  setParameter(std::string("ElasticPlanEnable"), elasticPlanEnable ? "true" : "false");
 }
 
-void CreateElasticPlanRequest::setElasticPlanTimeEnd(const std::string& elasticPlanTimeEnd)
-{
-	elasticPlanTimeEnd_ = elasticPlanTimeEnd;
-	setParameter("ElasticPlanTimeEnd", elasticPlanTimeEnd);
+std::string CreateElasticPlanRequest::getElasticPlanTimeEnd() const {
+  return elasticPlanTimeEnd_;
 }
 
-std::string CreateElasticPlanRequest::getElasticPlanStartDay()const
-{
-	return elasticPlanStartDay_;
+void CreateElasticPlanRequest::setElasticPlanTimeEnd(const std::string &elasticPlanTimeEnd) {
+  elasticPlanTimeEnd_ = elasticPlanTimeEnd;
+  setParameter(std::string("ElasticPlanTimeEnd"), elasticPlanTimeEnd);
 }
 
-void CreateElasticPlanRequest::setElasticPlanStartDay(const std::string& elasticPlanStartDay)
-{
-	elasticPlanStartDay_ = elasticPlanStartDay;
-	setParameter("ElasticPlanStartDay", elasticPlanStartDay);
+std::string CreateElasticPlanRequest::getElasticPlanStartDay() const {
+  return elasticPlanStartDay_;
 }
 
-std::string CreateElasticPlanRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void CreateElasticPlanRequest::setElasticPlanStartDay(const std::string &elasticPlanStartDay) {
+  elasticPlanStartDay_ = elasticPlanStartDay;
+  setParameter(std::string("ElasticPlanStartDay"), elasticPlanStartDay);
 }
 
-void CreateElasticPlanRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string CreateElasticPlanRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string CreateElasticPlanRequest::getDBClusterId()const
-{
-	return dBClusterId_;
+void CreateElasticPlanRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void CreateElasticPlanRequest::setDBClusterId(const std::string& dBClusterId)
-{
-	dBClusterId_ = dBClusterId;
-	setParameter("DBClusterId", dBClusterId);
+std::string CreateElasticPlanRequest::getDBClusterId() const {
+  return dBClusterId_;
 }
 
-std::string CreateElasticPlanRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void CreateElasticPlanRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
 }
 
-void CreateElasticPlanRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string CreateElasticPlanRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long CreateElasticPlanRequest::getOwnerId()const
-{
-	return ownerId_;
+void CreateElasticPlanRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void CreateElasticPlanRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long CreateElasticPlanRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string CreateElasticPlanRequest::getElasticPlanName()const
-{
-	return elasticPlanName_;
+void CreateElasticPlanRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void CreateElasticPlanRequest::setElasticPlanName(const std::string& elasticPlanName)
-{
-	elasticPlanName_ = elasticPlanName;
-	setParameter("ElasticPlanName", elasticPlanName);
+std::string CreateElasticPlanRequest::getElasticPlanName() const {
+  return elasticPlanName_;
 }
 
-std::string CreateElasticPlanRequest::getResourcePoolName()const
-{
-	return resourcePoolName_;
+void CreateElasticPlanRequest::setElasticPlanName(const std::string &elasticPlanName) {
+  elasticPlanName_ = elasticPlanName;
+  setParameter(std::string("ElasticPlanName"), elasticPlanName);
 }
 
-void CreateElasticPlanRequest::setResourcePoolName(const std::string& resourcePoolName)
-{
-	resourcePoolName_ = resourcePoolName;
-	setParameter("ResourcePoolName", resourcePoolName);
+std::string CreateElasticPlanRequest::getResourcePoolName() const {
+  return resourcePoolName_;
 }
 
-int CreateElasticPlanRequest::getElasticPlanNodeNum()const
-{
-	return elasticPlanNodeNum_;
+void CreateElasticPlanRequest::setResourcePoolName(const std::string &resourcePoolName) {
+  resourcePoolName_ = resourcePoolName;
+  setParameter(std::string("ResourcePoolName"), resourcePoolName);
 }
 
-void CreateElasticPlanRequest::setElasticPlanNodeNum(int elasticPlanNodeNum)
-{
-	elasticPlanNodeNum_ = elasticPlanNodeNum;
-	setParameter("ElasticPlanNodeNum", std::to_string(elasticPlanNodeNum));
+int CreateElasticPlanRequest::getElasticPlanNodeNum() const {
+  return elasticPlanNodeNum_;
+}
+
+void CreateElasticPlanRequest::setElasticPlanNodeNum(int elasticPlanNodeNum) {
+  elasticPlanNodeNum_ = elasticPlanNodeNum;
+  setParameter(std::string("ElasticPlanNodeNum"), std::to_string(elasticPlanNodeNum));
 }
 

adb/src/model/DeleteAccountRequest.cc

@@ -1,117 +1,99 @@
 /*
  * 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/adb/model/DeleteAccountRequest.h>
-
-using AlibabaCloud::Adb::Model::DeleteAccountRequest;
-
-DeleteAccountRequest::DeleteAccountRequest() :
-	RpcServiceRequest("adb", "2019-03-15", "DeleteAccount")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DeleteAccountRequest::~DeleteAccountRequest()
-{}
-
-long DeleteAccountRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/adb/model/DeleteAccountRequest.h>
+
+using AlibabaCloud::Adb::Model::DeleteAccountRequest;
+
+DeleteAccountRequest::DeleteAccountRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DeleteAccount") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DeleteAccountRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+DeleteAccountRequest::~DeleteAccountRequest() {}
+
+long DeleteAccountRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string DeleteAccountRequest::getAccountType()const
-{
-	return accountType_;
+void DeleteAccountRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void DeleteAccountRequest::setAccountType(const std::string& accountType)
-{
-	accountType_ = accountType;
-	setParameter("AccountType", accountType);
+std::string DeleteAccountRequest::getAccountType() const {
+  return accountType_;
 }
 
-std::string DeleteAccountRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
+void DeleteAccountRequest::setAccountType(const std::string &accountType) {
+  accountType_ = accountType;
+  setParameter(std::string("AccountType"), accountType);
 }
 
-void DeleteAccountRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+std::string DeleteAccountRequest::getAccessKeyId() const {
+  return accessKeyId_;
 }
 
-std::string DeleteAccountRequest::getAccountName()const
-{
-	return accountName_;
+void DeleteAccountRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-void DeleteAccountRequest::setAccountName(const std::string& accountName)
-{
-	accountName_ = accountName;
-	setParameter("AccountName", accountName);
+std::string DeleteAccountRequest::getAccountName() const {
+  return accountName_;
 }
 
-std::string DeleteAccountRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void DeleteAccountRequest::setAccountName(const std::string &accountName) {
+  accountName_ = accountName;
+  setParameter(std::string("AccountName"), accountName);
 }
 
-void DeleteAccountRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string DeleteAccountRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string DeleteAccountRequest::getDBClusterId()const
-{
-	return dBClusterId_;
+void DeleteAccountRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void DeleteAccountRequest::setDBClusterId(const std::string& dBClusterId)
-{
-	dBClusterId_ = dBClusterId;
-	setParameter("DBClusterId", dBClusterId);
+std::string DeleteAccountRequest::getDBClusterId() const {
+  return dBClusterId_;
 }
 
-std::string DeleteAccountRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void DeleteAccountRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
 }
 
-void DeleteAccountRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string DeleteAccountRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long DeleteAccountRequest::getOwnerId()const
-{
-	return ownerId_;
+void DeleteAccountRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void DeleteAccountRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long DeleteAccountRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DeleteAccountRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 

adb/src/model/DeleteDBClusterRequest.cc

@@ -1,95 +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/adb/model/DeleteDBClusterRequest.h>
-
-using AlibabaCloud::Adb::Model::DeleteDBClusterRequest;
-
-DeleteDBClusterRequest::DeleteDBClusterRequest() :
-	RpcServiceRequest("adb", "2019-03-15", "DeleteDBCluster")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DeleteDBClusterRequest::~DeleteDBClusterRequest()
-{}
-
-long DeleteDBClusterRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/adb/model/DeleteDBClusterRequest.h>
+
+using AlibabaCloud::Adb::Model::DeleteDBClusterRequest;
+
+DeleteDBClusterRequest::DeleteDBClusterRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DeleteDBCluster") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DeleteDBClusterRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+DeleteDBClusterRequest::~DeleteDBClusterRequest() {}
+
+long DeleteDBClusterRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string DeleteDBClusterRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
+void DeleteDBClusterRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void DeleteDBClusterRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+std::string DeleteDBClusterRequest::getAccessKeyId() const {
+  return accessKeyId_;
 }
 
-std::string DeleteDBClusterRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void DeleteDBClusterRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-void DeleteDBClusterRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string DeleteDBClusterRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string DeleteDBClusterRequest::getDBClusterId()const
-{
-	return dBClusterId_;
+void DeleteDBClusterRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void DeleteDBClusterRequest::setDBClusterId(const std::string& dBClusterId)
-{
-	dBClusterId_ = dBClusterId;
-	setParameter("DBClusterId", dBClusterId);
+std::string DeleteDBClusterRequest::getDBClusterId() const {
+  return dBClusterId_;
 }
 
-std::string DeleteDBClusterRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void DeleteDBClusterRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
 }
 
-void DeleteDBClusterRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string DeleteDBClusterRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long DeleteDBClusterRequest::getOwnerId()const
-{
-	return ownerId_;
+void DeleteDBClusterRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void DeleteDBClusterRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long DeleteDBClusterRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DeleteDBClusterRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 

adb/src/model/DeleteDBResourceGroupRequest.cc

@@ -0,0 +1,90 @@
+/*
+ * 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/adb/model/DeleteDBResourceGroupRequest.h>
+
+using AlibabaCloud::Adb::Model::DeleteDBResourceGroupRequest;
+
+DeleteDBResourceGroupRequest::DeleteDBResourceGroupRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DeleteDBResourceGroup") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DeleteDBResourceGroupRequest::~DeleteDBResourceGroupRequest() {}
+
+long DeleteDBResourceGroupRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void DeleteDBResourceGroupRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string DeleteDBResourceGroupRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void DeleteDBResourceGroupRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string DeleteDBResourceGroupRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void DeleteDBResourceGroupRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string DeleteDBResourceGroupRequest::getDBClusterId() const {
+  return dBClusterId_;
+}
+
+void DeleteDBResourceGroupRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
+}
+
+std::string DeleteDBResourceGroupRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void DeleteDBResourceGroupRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long DeleteDBResourceGroupRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DeleteDBResourceGroupRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string DeleteDBResourceGroupRequest::getGroupName() const {
+  return groupName_;
+}
+
+void DeleteDBResourceGroupRequest::setGroupName(const std::string &groupName) {
+  groupName_ = groupName;
+  setParameter(std::string("GroupName"), groupName);
+}
+

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

adb/src/model/DeleteDBResourcePoolRequest.cc

@@ -1,106 +1,90 @@
 /*
  * 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/adb/model/DeleteDBResourcePoolRequest.h>
-
-using AlibabaCloud::Adb::Model::DeleteDBResourcePoolRequest;
-
-DeleteDBResourcePoolRequest::DeleteDBResourcePoolRequest() :
-	RpcServiceRequest("adb", "2019-03-15", "DeleteDBResourcePool")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DeleteDBResourcePoolRequest::~DeleteDBResourcePoolRequest()
-{}
-
-std::string DeleteDBResourcePoolRequest::getPoolName()const
-{
-	return poolName_;
+ */
+
+#include <alibabacloud/adb/model/DeleteDBResourcePoolRequest.h>
+
+using AlibabaCloud::Adb::Model::DeleteDBResourcePoolRequest;
+
+DeleteDBResourcePoolRequest::DeleteDBResourcePoolRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DeleteDBResourcePool") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DeleteDBResourcePoolRequest::setPoolName(const std::string& poolName)
-{
-	poolName_ = poolName;
-	setParameter("PoolName", poolName);
+DeleteDBResourcePoolRequest::~DeleteDBResourcePoolRequest() {}
+
+std::string DeleteDBResourcePoolRequest::getPoolName() const {
+  return poolName_;
 }
 
-long DeleteDBResourcePoolRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+void DeleteDBResourcePoolRequest::setPoolName(const std::string &poolName) {
+  poolName_ = poolName;
+  setParameter(std::string("PoolName"), poolName);
 }
 
-void DeleteDBResourcePoolRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+long DeleteDBResourcePoolRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string DeleteDBResourcePoolRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
+void DeleteDBResourcePoolRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void DeleteDBResourcePoolRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+std::string DeleteDBResourcePoolRequest::getAccessKeyId() const {
+  return accessKeyId_;
 }
 
-std::string DeleteDBResourcePoolRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void DeleteDBResourcePoolRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-void DeleteDBResourcePoolRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string DeleteDBResourcePoolRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string DeleteDBResourcePoolRequest::getDBClusterId()const
-{
-	return dBClusterId_;
+void DeleteDBResourcePoolRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void DeleteDBResourcePoolRequest::setDBClusterId(const std::string& dBClusterId)
-{
-	dBClusterId_ = dBClusterId;
-	setParameter("DBClusterId", dBClusterId);
+std::string DeleteDBResourcePoolRequest::getDBClusterId() const {
+  return dBClusterId_;
 }
 
-std::string DeleteDBResourcePoolRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void DeleteDBResourcePoolRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
 }
 
-void DeleteDBResourcePoolRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string DeleteDBResourcePoolRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long DeleteDBResourcePoolRequest::getOwnerId()const
-{
-	return ownerId_;
+void DeleteDBResourcePoolRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void DeleteDBResourcePoolRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long DeleteDBResourcePoolRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DeleteDBResourcePoolRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 

adb/src/model/DeleteElasticPlanRequest.cc

@@ -1,106 +1,90 @@
 /*
  * 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/adb/model/DeleteElasticPlanRequest.h>
-
-using AlibabaCloud::Adb::Model::DeleteElasticPlanRequest;
-
-DeleteElasticPlanRequest::DeleteElasticPlanRequest() :
-	RpcServiceRequest("adb", "2019-03-15", "DeleteElasticPlan")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DeleteElasticPlanRequest::~DeleteElasticPlanRequest()
-{}
-
-long DeleteElasticPlanRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/adb/model/DeleteElasticPlanRequest.h>
+
+using AlibabaCloud::Adb::Model::DeleteElasticPlanRequest;
+
+DeleteElasticPlanRequest::DeleteElasticPlanRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DeleteElasticPlan") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DeleteElasticPlanRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+DeleteElasticPlanRequest::~DeleteElasticPlanRequest() {}
+
+long DeleteElasticPlanRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string DeleteElasticPlanRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
+void DeleteElasticPlanRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void DeleteElasticPlanRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+std::string DeleteElasticPlanRequest::getAccessKeyId() const {
+  return accessKeyId_;
 }
 
-std::string DeleteElasticPlanRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void DeleteElasticPlanRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-void DeleteElasticPlanRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string DeleteElasticPlanRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string DeleteElasticPlanRequest::getDBClusterId()const
-{
-	return dBClusterId_;
+void DeleteElasticPlanRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void DeleteElasticPlanRequest::setDBClusterId(const std::string& dBClusterId)
-{
-	dBClusterId_ = dBClusterId;
-	setParameter("DBClusterId", dBClusterId);
+std::string DeleteElasticPlanRequest::getDBClusterId() const {
+  return dBClusterId_;
 }
 
-std::string DeleteElasticPlanRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void DeleteElasticPlanRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
 }
 
-void DeleteElasticPlanRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string DeleteElasticPlanRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long DeleteElasticPlanRequest::getOwnerId()const
-{
-	return ownerId_;
+void DeleteElasticPlanRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void DeleteElasticPlanRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long DeleteElasticPlanRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string DeleteElasticPlanRequest::getElasticPlanName()const
-{
-	return elasticPlanName_;
+void DeleteElasticPlanRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void DeleteElasticPlanRequest::setElasticPlanName(const std::string& elasticPlanName)
-{
-	elasticPlanName_ = elasticPlanName;
-	setParameter("ElasticPlanName", elasticPlanName);
+std::string DeleteElasticPlanRequest::getElasticPlanName() const {
+  return elasticPlanName_;
+}
+
+void DeleteElasticPlanRequest::setElasticPlanName(const std::string &elasticPlanName) {
+  elasticPlanName_ = elasticPlanName;
+  setParameter(std::string("ElasticPlanName"), elasticPlanName);
 }
 

adb/src/model/DescribeAccountsRequest.cc

@@ -1,117 +1,99 @@
 /*
  * 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/adb/model/DescribeAccountsRequest.h>
-
-using AlibabaCloud::Adb::Model::DescribeAccountsRequest;
-
-DescribeAccountsRequest::DescribeAccountsRequest() :
-	RpcServiceRequest("adb", "2019-03-15", "DescribeAccounts")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeAccountsRequest::~DescribeAccountsRequest()
-{}
-
-long DescribeAccountsRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/adb/model/DescribeAccountsRequest.h>
+
+using AlibabaCloud::Adb::Model::DescribeAccountsRequest;
+
+DescribeAccountsRequest::DescribeAccountsRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DescribeAccounts") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeAccountsRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+DescribeAccountsRequest::~DescribeAccountsRequest() {}
+
+long DescribeAccountsRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string DescribeAccountsRequest::getAccountType()const
-{
-	return accountType_;
+void DescribeAccountsRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void DescribeAccountsRequest::setAccountType(const std::string& accountType)
-{
-	accountType_ = accountType;
-	setParameter("AccountType", accountType);
+std::string DescribeAccountsRequest::getAccountType() const {
+  return accountType_;
 }
 
-std::string DescribeAccountsRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
+void DescribeAccountsRequest::setAccountType(const std::string &accountType) {
+  accountType_ = accountType;
+  setParameter(std::string("AccountType"), accountType);
 }
 
-void DescribeAccountsRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+std::string DescribeAccountsRequest::getAccessKeyId() const {
+  return accessKeyId_;
 }
 
-std::string DescribeAccountsRequest::getAccountName()const
-{
-	return accountName_;
+void DescribeAccountsRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-void DescribeAccountsRequest::setAccountName(const std::string& accountName)
-{
-	accountName_ = accountName;
-	setParameter("AccountName", accountName);
+std::string DescribeAccountsRequest::getAccountName() const {
+  return accountName_;
 }
 
-std::string DescribeAccountsRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void DescribeAccountsRequest::setAccountName(const std::string &accountName) {
+  accountName_ = accountName;
+  setParameter(std::string("AccountName"), accountName);
 }
 
-void DescribeAccountsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string DescribeAccountsRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string DescribeAccountsRequest::getDBClusterId()const
-{
-	return dBClusterId_;
+void DescribeAccountsRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void DescribeAccountsRequest::setDBClusterId(const std::string& dBClusterId)
-{
-	dBClusterId_ = dBClusterId;
-	setParameter("DBClusterId", dBClusterId);
+std::string DescribeAccountsRequest::getDBClusterId() const {
+  return dBClusterId_;
 }
 
-std::string DescribeAccountsRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void DescribeAccountsRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
 }
 
-void DescribeAccountsRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string DescribeAccountsRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long DescribeAccountsRequest::getOwnerId()const
-{
-	return ownerId_;
+void DescribeAccountsRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void DescribeAccountsRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long DescribeAccountsRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DescribeAccountsRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 

adb/src/model/DescribeAccountsResult.cc

@@ -43,14 +43,14 @@ void DescribeAccountsResult::parse(const std::string &payload)
 	for (auto valueAccountListDBAccount : allAccountListNode)
 	{
 		DBAccount accountListObject;
-		if(!valueAccountListDBAccount["AccountName"].isNull())
-			accountListObject.accountName = valueAccountListDBAccount["AccountName"].asString();
 		if(!valueAccountListDBAccount["AccountStatus"].isNull())
 			accountListObject.accountStatus = valueAccountListDBAccount["AccountStatus"].asString();
 		if(!valueAccountListDBAccount["AccountDescription"].isNull())
 			accountListObject.accountDescription = valueAccountListDBAccount["AccountDescription"].asString();
 		if(!valueAccountListDBAccount["AccountType"].isNull())
 			accountListObject.accountType = valueAccountListDBAccount["AccountType"].asString();
+		if(!valueAccountListDBAccount["AccountName"].isNull())
+			accountListObject.accountName = valueAccountListDBAccount["AccountName"].asString();
 		accountList_.push_back(accountListObject);
 	}
 

adb/src/model/DescribeAllAccountsRequest.cc

@@ -1,95 +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/adb/model/DescribeAllAccountsRequest.h>
-
-using AlibabaCloud::Adb::Model::DescribeAllAccountsRequest;
-
-DescribeAllAccountsRequest::DescribeAllAccountsRequest() :
-	RpcServiceRequest("adb", "2019-03-15", "DescribeAllAccounts")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeAllAccountsRequest::~DescribeAllAccountsRequest()
-{}
-
-long DescribeAllAccountsRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/adb/model/DescribeAllAccountsRequest.h>
+
+using AlibabaCloud::Adb::Model::DescribeAllAccountsRequest;
+
+DescribeAllAccountsRequest::DescribeAllAccountsRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DescribeAllAccounts") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeAllAccountsRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+DescribeAllAccountsRequest::~DescribeAllAccountsRequest() {}
+
+long DescribeAllAccountsRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string DescribeAllAccountsRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
+void DescribeAllAccountsRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void DescribeAllAccountsRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+std::string DescribeAllAccountsRequest::getAccessKeyId() const {
+  return accessKeyId_;
 }
 
-std::string DescribeAllAccountsRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void DescribeAllAccountsRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-void DescribeAllAccountsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string DescribeAllAccountsRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string DescribeAllAccountsRequest::getDBClusterId()const
-{
-	return dBClusterId_;
+void DescribeAllAccountsRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void DescribeAllAccountsRequest::setDBClusterId(const std::string& dBClusterId)
-{
-	dBClusterId_ = dBClusterId;
-	setParameter("DBClusterId", dBClusterId);
+std::string DescribeAllAccountsRequest::getDBClusterId() const {
+  return dBClusterId_;
 }
 
-std::string DescribeAllAccountsRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void DescribeAllAccountsRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
 }
 
-void DescribeAllAccountsRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string DescribeAllAccountsRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long DescribeAllAccountsRequest::getOwnerId()const
-{
-	return ownerId_;
+void DescribeAllAccountsRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void DescribeAllAccountsRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long DescribeAllAccountsRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DescribeAllAccountsRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 

adb/src/model/DescribeAllDataSourceRequest.cc

@@ -1,117 +1,99 @@
 /*
  * 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/adb/model/DescribeAllDataSourceRequest.h>
-
-using AlibabaCloud::Adb::Model::DescribeAllDataSourceRequest;
-
-DescribeAllDataSourceRequest::DescribeAllDataSourceRequest() :
-	RpcServiceRequest("adb", "2019-03-15", "DescribeAllDataSource")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeAllDataSourceRequest::~DescribeAllDataSourceRequest()
-{}
-
-long DescribeAllDataSourceRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/adb/model/DescribeAllDataSourceRequest.h>
+
+using AlibabaCloud::Adb::Model::DescribeAllDataSourceRequest;
+
+DescribeAllDataSourceRequest::DescribeAllDataSourceRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DescribeAllDataSource") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeAllDataSourceRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+DescribeAllDataSourceRequest::~DescribeAllDataSourceRequest() {}
+
+long DescribeAllDataSourceRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string DescribeAllDataSourceRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
+void DescribeAllDataSourceRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void DescribeAllDataSourceRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+std::string DescribeAllDataSourceRequest::getAccessKeyId() const {
+  return accessKeyId_;
 }
 
-std::string DescribeAllDataSourceRequest::getTableName()const
-{
-	return tableName_;
+void DescribeAllDataSourceRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-void DescribeAllDataSourceRequest::setTableName(const std::string& tableName)
-{
-	tableName_ = tableName;
-	setParameter("TableName", tableName);
+std::string DescribeAllDataSourceRequest::getTableName() const {
+  return tableName_;
 }
 
-std::string DescribeAllDataSourceRequest::getSchemaName()const
-{
-	return schemaName_;
+void DescribeAllDataSourceRequest::setTableName(const std::string &tableName) {
+  tableName_ = tableName;
+  setParameter(std::string("TableName"), tableName);
 }
 
-void DescribeAllDataSourceRequest::setSchemaName(const std::string& schemaName)
-{
-	schemaName_ = schemaName;
-	setParameter("SchemaName", schemaName);
+std::string DescribeAllDataSourceRequest::getSchemaName() const {
+  return schemaName_;
 }
 
-std::string DescribeAllDataSourceRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void DescribeAllDataSourceRequest::setSchemaName(const std::string &schemaName) {
+  schemaName_ = schemaName;
+  setParameter(std::string("SchemaName"), schemaName);
 }
 
-void DescribeAllDataSourceRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string DescribeAllDataSourceRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string DescribeAllDataSourceRequest::getDBClusterId()const
-{
-	return dBClusterId_;
+void DescribeAllDataSourceRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void DescribeAllDataSourceRequest::setDBClusterId(const std::string& dBClusterId)
-{
-	dBClusterId_ = dBClusterId;
-	setParameter("DBClusterId", dBClusterId);
+std::string DescribeAllDataSourceRequest::getDBClusterId() const {
+  return dBClusterId_;
 }
 
-std::string DescribeAllDataSourceRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void DescribeAllDataSourceRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
 }
 
-void DescribeAllDataSourceRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string DescribeAllDataSourceRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long DescribeAllDataSourceRequest::getOwnerId()const
-{
-	return ownerId_;
+void DescribeAllDataSourceRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void DescribeAllDataSourceRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long DescribeAllDataSourceRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DescribeAllDataSourceRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 

adb/src/model/DescribeAllDataSourceResult.cc

@@ -39,6 +39,38 @@ void DescribeAllDataSourceResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
+	auto allTablesNode = value["Tables"]["Table"];
+	for (auto valueTablesTable : allTablesNode)
+	{
+		Table tablesObject;
+		if(!valueTablesTable["TableName"].isNull())
+			tablesObject.tableName = valueTablesTable["TableName"].asString();
+		if(!valueTablesTable["DBClusterId"].isNull())
+			tablesObject.dBClusterId = valueTablesTable["DBClusterId"].asString();
+		if(!valueTablesTable["SchemaName"].isNull())
+			tablesObject.schemaName = valueTablesTable["SchemaName"].asString();
+		tables_.push_back(tablesObject);
+	}
+	auto allColumnsNode = value["Columns"]["Column"];
+	for (auto valueColumnsColumn : allColumnsNode)
+	{
+		Column columnsObject;
+		if(!valueColumnsColumn["Type"].isNull())
+			columnsObject.type = valueColumnsColumn["Type"].asString();
+		if(!valueColumnsColumn["ColumnName"].isNull())
+			columnsObject.columnName = valueColumnsColumn["ColumnName"].asString();
+		if(!valueColumnsColumn["TableName"].isNull())
+			columnsObject.tableName = valueColumnsColumn["TableName"].asString();
+		if(!valueColumnsColumn["AutoIncrementColumn"].isNull())
+			columnsObject.autoIncrementColumn = valueColumnsColumn["AutoIncrementColumn"].asString() == "true";
+		if(!valueColumnsColumn["DBClusterId"].isNull())
+			columnsObject.dBClusterId = valueColumnsColumn["DBClusterId"].asString();
+		if(!valueColumnsColumn["PrimaryKey"].isNull())
+			columnsObject.primaryKey = valueColumnsColumn["PrimaryKey"].asString() == "true";
+		if(!valueColumnsColumn["SchemaName"].isNull())
+			columnsObject.schemaName = valueColumnsColumn["SchemaName"].asString();
+		columns_.push_back(columnsObject);
+	}
 	auto allSchemasNode = value["Schemas"]["Schema"];
 	for (auto valueSchemasSchema : allSchemasNode)
 	{
@@ -49,38 +81,6 @@ void DescribeAllDataSourceResult::parse(const std::string &payload)
 			schemasObject.schemaName = valueSchemasSchema["SchemaName"].asString();
 		schemas_.push_back(schemasObject);
 	}
-	auto allTablesNode = value["Tables"]["Table"];
-	for (auto valueTablesTable : allTablesNode)
-	{
-		Table tablesObject;
-		if(!valueTablesTable["DBClusterId"].isNull())
-			tablesObject.dBClusterId = valueTablesTable["DBClusterId"].asString();
-		if(!valueTablesTable["SchemaName"].isNull())
-			tablesObject.schemaName = valueTablesTable["SchemaName"].asString();
-		if(!valueTablesTable["TableName"].isNull())
-			tablesObject.tableName = valueTablesTable["TableName"].asString();
-		tables_.push_back(tablesObject);
-	}
-	auto allColumnsNode = value["Columns"]["Column"];
-	for (auto valueColumnsColumn : allColumnsNode)
-	{
-		Column columnsObject;
-		if(!valueColumnsColumn["DBClusterId"].isNull())
-			columnsObject.dBClusterId = valueColumnsColumn["DBClusterId"].asString();
-		if(!valueColumnsColumn["SchemaName"].isNull())
-			columnsObject.schemaName = valueColumnsColumn["SchemaName"].asString();
-		if(!valueColumnsColumn["TableName"].isNull())
-			columnsObject.tableName = valueColumnsColumn["TableName"].asString();
-		if(!valueColumnsColumn["ColumnName"].isNull())
-			columnsObject.columnName = valueColumnsColumn["ColumnName"].asString();
-		if(!valueColumnsColumn["Type"].isNull())
-			columnsObject.type = valueColumnsColumn["Type"].asString();
-		if(!valueColumnsColumn["PrimaryKey"].isNull())
-			columnsObject.primaryKey = valueColumnsColumn["PrimaryKey"].asString() == "true";
-		if(!valueColumnsColumn["AutoIncrementColumn"].isNull())
-			columnsObject.autoIncrementColumn = valueColumnsColumn["AutoIncrementColumn"].asString() == "true";
-		columns_.push_back(columnsObject);
-	}
 
 }
 

adb/src/model/DescribeAuditLogConfigRequest.cc

@@ -1,106 +1,90 @@
 /*
  * 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/adb/model/DescribeAuditLogConfigRequest.h>
-
-using AlibabaCloud::Adb::Model::DescribeAuditLogConfigRequest;
-
-DescribeAuditLogConfigRequest::DescribeAuditLogConfigRequest() :
-	RpcServiceRequest("adb", "2019-03-15", "DescribeAuditLogConfig")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeAuditLogConfigRequest::~DescribeAuditLogConfigRequest()
-{}
-
-long DescribeAuditLogConfigRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/adb/model/DescribeAuditLogConfigRequest.h>
+
+using AlibabaCloud::Adb::Model::DescribeAuditLogConfigRequest;
+
+DescribeAuditLogConfigRequest::DescribeAuditLogConfigRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DescribeAuditLogConfig") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeAuditLogConfigRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+DescribeAuditLogConfigRequest::~DescribeAuditLogConfigRequest() {}
+
+long DescribeAuditLogConfigRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string DescribeAuditLogConfigRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
+void DescribeAuditLogConfigRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void DescribeAuditLogConfigRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+std::string DescribeAuditLogConfigRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string DescribeAuditLogConfigRequest::getRegionId()const
-{
-	return regionId_;
+void DescribeAuditLogConfigRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void DescribeAuditLogConfigRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string DescribeAuditLogConfigRequest::getDBClusterId() const {
+  return dBClusterId_;
 }
 
-std::string DescribeAuditLogConfigRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void DescribeAuditLogConfigRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
 }
 
-void DescribeAuditLogConfigRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string DescribeAuditLogConfigRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-std::string DescribeAuditLogConfigRequest::getDBClusterId()const
-{
-	return dBClusterId_;
+void DescribeAuditLogConfigRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void DescribeAuditLogConfigRequest::setDBClusterId(const std::string& dBClusterId)
-{
-	dBClusterId_ = dBClusterId;
-	setParameter("DBClusterId", dBClusterId);
+long DescribeAuditLogConfigRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string DescribeAuditLogConfigRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void DescribeAuditLogConfigRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void DescribeAuditLogConfigRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string DescribeAuditLogConfigRequest::getAccessKeyId() const {
+  return accessKeyId_;
 }
 
-long DescribeAuditLogConfigRequest::getOwnerId()const
-{
-	return ownerId_;
+void DescribeAuditLogConfigRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-void DescribeAuditLogConfigRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+std::string DescribeAuditLogConfigRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeAuditLogConfigRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 

adb/src/model/DescribeAuditLogRecordsRequest.cc

@@ -1,227 +1,198 @@
 /*
  * 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/adb/model/DescribeAuditLogRecordsRequest.h>
-
-using AlibabaCloud::Adb::Model::DescribeAuditLogRecordsRequest;
-
-DescribeAuditLogRecordsRequest::DescribeAuditLogRecordsRequest() :
-	RpcServiceRequest("adb", "2019-03-15", "DescribeAuditLogRecords")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeAuditLogRecordsRequest::~DescribeAuditLogRecordsRequest()
-{}
-
-long DescribeAuditLogRecordsRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/adb/model/DescribeAuditLogRecordsRequest.h>
+
+using AlibabaCloud::Adb::Model::DescribeAuditLogRecordsRequest;
+
+DescribeAuditLogRecordsRequest::DescribeAuditLogRecordsRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DescribeAuditLogRecords") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeAuditLogRecordsRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+DescribeAuditLogRecordsRequest::~DescribeAuditLogRecordsRequest() {}
+
+long DescribeAuditLogRecordsRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string DescribeAuditLogRecordsRequest::getStartTime()const
-{
-	return startTime_;
+void DescribeAuditLogRecordsRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void DescribeAuditLogRecordsRequest::setStartTime(const std::string& startTime)
-{
-	startTime_ = startTime;
-	setParameter("StartTime", startTime);
+std::string DescribeAuditLogRecordsRequest::getStartTime() const {
+  return startTime_;
 }
 
-int DescribeAuditLogRecordsRequest::getPageNumber()const
-{
-	return pageNumber_;
+void DescribeAuditLogRecordsRequest::setStartTime(const std::string &startTime) {
+  startTime_ = startTime;
+  setParameter(std::string("StartTime"), startTime);
 }
 
-void DescribeAuditLogRecordsRequest::setPageNumber(int pageNumber)
-{
-	pageNumber_ = pageNumber;
-	setParameter("PageNumber", std::to_string(pageNumber));
+int DescribeAuditLogRecordsRequest::getPageNumber() const {
+  return pageNumber_;
 }
 
-std::string DescribeAuditLogRecordsRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
+void DescribeAuditLogRecordsRequest::setPageNumber(int pageNumber) {
+  pageNumber_ = pageNumber;
+  setParameter(std::string("PageNumber"), std::to_string(pageNumber));
 }
 
-void DescribeAuditLogRecordsRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+std::string DescribeAuditLogRecordsRequest::getAccessKeyId() const {
+  return accessKeyId_;
 }
 
-std::string DescribeAuditLogRecordsRequest::getHostAddress()const
-{
-	return hostAddress_;
+void DescribeAuditLogRecordsRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-void DescribeAuditLogRecordsRequest::setHostAddress(const std::string& hostAddress)
-{
-	hostAddress_ = hostAddress;
-	setParameter("HostAddress", hostAddress);
+std::string DescribeAuditLogRecordsRequest::getHostAddress() const {
+  return hostAddress_;
 }
 
-std::string DescribeAuditLogRecordsRequest::getRegionId()const
-{
-	return regionId_;
+void DescribeAuditLogRecordsRequest::setHostAddress(const std::string &hostAddress) {
+  hostAddress_ = hostAddress;
+  setParameter(std::string("HostAddress"), hostAddress);
 }
 
-void DescribeAuditLogRecordsRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string DescribeAuditLogRecordsRequest::getRegionId() const {
+  return regionId_;
 }
 
-int DescribeAuditLogRecordsRequest::getPageSize()const
-{
-	return pageSize_;
+void DescribeAuditLogRecordsRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void DescribeAuditLogRecordsRequest::setPageSize(int pageSize)
-{
-	pageSize_ = pageSize;
-	setParameter("PageSize", std::to_string(pageSize));
+int DescribeAuditLogRecordsRequest::getPageSize() const {
+  return pageSize_;
 }
 
-std::string DescribeAuditLogRecordsRequest::getSqlType()const
-{
-	return sqlType_;
+void DescribeAuditLogRecordsRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
 }
 
-void DescribeAuditLogRecordsRequest::setSqlType(const std::string& sqlType)
-{
-	sqlType_ = sqlType;
-	setParameter("SqlType", sqlType);
+std::string DescribeAuditLogRecordsRequest::getOrder() const {
+  return order_;
 }
 
-std::string DescribeAuditLogRecordsRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void DescribeAuditLogRecordsRequest::setOrder(const std::string &order) {
+  order_ = order;
+  setParameter(std::string("Order"), order);
 }
 
-void DescribeAuditLogRecordsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string DescribeAuditLogRecordsRequest::getSqlType() const {
+  return sqlType_;
 }
 
-std::string DescribeAuditLogRecordsRequest::getDBClusterId()const
-{
-	return dBClusterId_;
+void DescribeAuditLogRecordsRequest::setSqlType(const std::string &sqlType) {
+  sqlType_ = sqlType;
+  setParameter(std::string("SqlType"), sqlType);
 }
 
-void DescribeAuditLogRecordsRequest::setDBClusterId(const std::string& dBClusterId)
-{
-	dBClusterId_ = dBClusterId;
-	setParameter("DBClusterId", dBClusterId);
+std::string DescribeAuditLogRecordsRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string DescribeAuditLogRecordsRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void DescribeAuditLogRecordsRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void DescribeAuditLogRecordsRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string DescribeAuditLogRecordsRequest::getDBClusterId() const {
+  return dBClusterId_;
 }
 
-std::string DescribeAuditLogRecordsRequest::getQueryKeyword()const
-{
-	return queryKeyword_;
+void DescribeAuditLogRecordsRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
 }
 
-void DescribeAuditLogRecordsRequest::setQueryKeyword(const std::string& queryKeyword)
-{
-	queryKeyword_ = queryKeyword;
-	setParameter("QueryKeyword", queryKeyword);
+std::string DescribeAuditLogRecordsRequest::getQueryKeyword() const {
+  return queryKeyword_;
 }
 
-std::string DescribeAuditLogRecordsRequest::getEndTime()const
-{
-	return endTime_;
+void DescribeAuditLogRecordsRequest::setQueryKeyword(const std::string &queryKeyword) {
+  queryKeyword_ = queryKeyword;
+  setParameter(std::string("QueryKeyword"), queryKeyword);
 }
 
-void DescribeAuditLogRecordsRequest::setEndTime(const std::string& endTime)
-{
-	endTime_ = endTime;
-	setParameter("EndTime", endTime);
+std::string DescribeAuditLogRecordsRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long DescribeAuditLogRecordsRequest::getOwnerId()const
-{
-	return ownerId_;
+void DescribeAuditLogRecordsRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void DescribeAuditLogRecordsRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+std::string DescribeAuditLogRecordsRequest::getEndTime() const {
+  return endTime_;
 }
 
-std::string DescribeAuditLogRecordsRequest::getDBName()const
-{
-	return dBName_;
+void DescribeAuditLogRecordsRequest::setEndTime(const std::string &endTime) {
+  endTime_ = endTime;
+  setParameter(std::string("EndTime"), endTime);
 }
 
-void DescribeAuditLogRecordsRequest::setDBName(const std::string& dBName)
-{
-	dBName_ = dBName;
-	setParameter("DBName", dBName);
+long DescribeAuditLogRecordsRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string DescribeAuditLogRecordsRequest::getSucceed()const
-{
-	return succeed_;
+void DescribeAuditLogRecordsRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void DescribeAuditLogRecordsRequest::setSucceed(const std::string& succeed)
-{
-	succeed_ = succeed;
-	setParameter("Succeed", succeed);
+std::string DescribeAuditLogRecordsRequest::getDBName() const {
+  return dBName_;
 }
 
-std::string DescribeAuditLogRecordsRequest::getUser()const
-{
-	return user_;
+void DescribeAuditLogRecordsRequest::setDBName(const std::string &dBName) {
+  dBName_ = dBName;
+  setParameter(std::string("DBName"), dBName);
 }
 
-void DescribeAuditLogRecordsRequest::setUser(const std::string& user)
-{
-	user_ = user;
-	setParameter("User", user);
+std::string DescribeAuditLogRecordsRequest::getSucceed() const {
+  return succeed_;
 }
 
-std::string DescribeAuditLogRecordsRequest::getOrderType()const
-{
-	return orderType_;
+void DescribeAuditLogRecordsRequest::setSucceed(const std::string &succeed) {
+  succeed_ = succeed;
+  setParameter(std::string("Succeed"), succeed);
 }
 
-void DescribeAuditLogRecordsRequest::setOrderType(const std::string& orderType)
-{
-	orderType_ = orderType;
-	setParameter("OrderType", orderType);
+std::string DescribeAuditLogRecordsRequest::getUser() const {
+  return user_;
+}
+
+void DescribeAuditLogRecordsRequest::setUser(const std::string &user) {
+  user_ = user;
+  setParameter(std::string("User"), user);
+}
+
+std::string DescribeAuditLogRecordsRequest::getOrderType() const {
+  return orderType_;
+}
+
+void DescribeAuditLogRecordsRequest::setOrderType(const std::string &orderType) {
+  orderType_ = orderType;
+  setParameter(std::string("OrderType"), orderType);
 }
 

adb/src/model/DescribeAuditLogRecordsResult.cc

@@ -45,30 +45,32 @@ void DescribeAuditLogRecordsResult::parse(const std::string &payload)
 		SlowLogRecord itemsObject;
 		if(!valueItemsSlowLogRecord["HostAddress"].isNull())
 			itemsObject.hostAddress = valueItemsSlowLogRecord["HostAddress"].asString();
-		if(!valueItemsSlowLogRecord["DBName"].isNull())
-			itemsObject.dBName = valueItemsSlowLogRecord["DBName"].asString();
-		if(!valueItemsSlowLogRecord["SQLText"].isNull())
-			itemsObject.sQLText = valueItemsSlowLogRecord["SQLText"].asString();
-		if(!valueItemsSlowLogRecord["SQLType"].isNull())
-			itemsObject.sQLType = valueItemsSlowLogRecord["SQLType"].asString();
-		if(!valueItemsSlowLogRecord["ConnId"].isNull())
-			itemsObject.connId = valueItemsSlowLogRecord["ConnId"].asString();
-		if(!valueItemsSlowLogRecord["ExecuteTime"].isNull())
-			itemsObject.executeTime = valueItemsSlowLogRecord["ExecuteTime"].asString();
 		if(!valueItemsSlowLogRecord["Succeed"].isNull())
 			itemsObject.succeed = valueItemsSlowLogRecord["Succeed"].asString();
+		if(!valueItemsSlowLogRecord["SQLText"].isNull())
+			itemsObject.sQLText = valueItemsSlowLogRecord["SQLText"].asString();
 		if(!valueItemsSlowLogRecord["TotalTime"].isNull())
 			itemsObject.totalTime = valueItemsSlowLogRecord["TotalTime"].asString();
+		if(!valueItemsSlowLogRecord["ConnId"].isNull())
+			itemsObject.connId = valueItemsSlowLogRecord["ConnId"].asString();
+		if(!valueItemsSlowLogRecord["DBName"].isNull())
+			itemsObject.dBName = valueItemsSlowLogRecord["DBName"].asString();
+		if(!valueItemsSlowLogRecord["SQLType"].isNull())
+			itemsObject.sQLType = valueItemsSlowLogRecord["SQLType"].asString();
+		if(!valueItemsSlowLogRecord["ExecuteTime"].isNull())
+			itemsObject.executeTime = valueItemsSlowLogRecord["ExecuteTime"].asString();
 		if(!valueItemsSlowLogRecord["ProcessID"].isNull())
 			itemsObject.processID = valueItemsSlowLogRecord["ProcessID"].asString();
+		if(!valueItemsSlowLogRecord["User"].isNull())
+			itemsObject.user = valueItemsSlowLogRecord["User"].asString();
 		items_.push_back(itemsObject);
 	}
 	if(!value["TotalCount"].isNull())
 		totalCount_ = value["TotalCount"].asString();
-	if(!value["PageNumber"].isNull())
-		pageNumber_ = value["PageNumber"].asString();
 	if(!value["PageSize"].isNull())
 		pageSize_ = value["PageSize"].asString();
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = value["PageNumber"].asString();
 	if(!value["DBClusterId"].isNull())
 		dBClusterId_ = value["DBClusterId"].asString();
 

adb/src/model/DescribeAutoRenewAttributeRequest.cc

@@ -1,139 +1,117 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
-
-#include <alibabacloud/adb/model/DescribeAutoRenewAttributeRequest.h>
-
-using AlibabaCloud::Adb::Model::DescribeAutoRenewAttributeRequest;
-
-DescribeAutoRenewAttributeRequest::DescribeAutoRenewAttributeRequest() :
-	RpcServiceRequest("adb", "2019-03-15", "DescribeAutoRenewAttribute")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeAutoRenewAttributeRequest::~DescribeAutoRenewAttributeRequest()
-{}
-
-long DescribeAutoRenewAttributeRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/adb/model/DescribeAutoRenewAttributeRequest.h>
+
+using AlibabaCloud::Adb::Model::DescribeAutoRenewAttributeRequest;
+
+DescribeAutoRenewAttributeRequest::DescribeAutoRenewAttributeRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DescribeAutoRenewAttribute") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeAutoRenewAttributeRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+DescribeAutoRenewAttributeRequest::~DescribeAutoRenewAttributeRequest() {}
+
+long DescribeAutoRenewAttributeRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-int DescribeAutoRenewAttributeRequest::getPageNumber()const
-{
-	return pageNumber_;
+void DescribeAutoRenewAttributeRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void DescribeAutoRenewAttributeRequest::setPageNumber(int pageNumber)
-{
-	pageNumber_ = pageNumber;
-	setParameter("PageNumber", std::to_string(pageNumber));
+int DescribeAutoRenewAttributeRequest::getPageNumber() const {
+  return pageNumber_;
 }
 
-std::string DescribeAutoRenewAttributeRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
+void DescribeAutoRenewAttributeRequest::setPageNumber(int pageNumber) {
+  pageNumber_ = pageNumber;
+  setParameter(std::string("PageNumber"), std::to_string(pageNumber));
 }
 
-void DescribeAutoRenewAttributeRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+std::string DescribeAutoRenewAttributeRequest::getAccessKeyId() const {
+  return accessKeyId_;
 }
 
-std::string DescribeAutoRenewAttributeRequest::getResourceGroupId()const
-{
-	return resourceGroupId_;
+void DescribeAutoRenewAttributeRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-void DescribeAutoRenewAttributeRequest::setResourceGroupId(const std::string& resourceGroupId)
-{
-	resourceGroupId_ = resourceGroupId;
-	setParameter("ResourceGroupId", resourceGroupId);
+std::string DescribeAutoRenewAttributeRequest::getResourceGroupId() const {
+  return resourceGroupId_;
 }
 
-std::string DescribeAutoRenewAttributeRequest::getRegionId()const
-{
-	return regionId_;
+void DescribeAutoRenewAttributeRequest::setResourceGroupId(const std::string &resourceGroupId) {
+  resourceGroupId_ = resourceGroupId;
+  setParameter(std::string("ResourceGroupId"), resourceGroupId);
 }
 
-void DescribeAutoRenewAttributeRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string DescribeAutoRenewAttributeRequest::getRegionId() const {
+  return regionId_;
 }
 
-int DescribeAutoRenewAttributeRequest::getPageSize()const
-{
-	return pageSize_;
+void DescribeAutoRenewAttributeRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void DescribeAutoRenewAttributeRequest::setPageSize(int pageSize)
-{
-	pageSize_ = pageSize;
-	setParameter("PageSize", std::to_string(pageSize));
+int DescribeAutoRenewAttributeRequest::getPageSize() const {
+  return pageSize_;
 }
 
-std::string DescribeAutoRenewAttributeRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void DescribeAutoRenewAttributeRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
 }
 
-void DescribeAutoRenewAttributeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string DescribeAutoRenewAttributeRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string DescribeAutoRenewAttributeRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void DescribeAutoRenewAttributeRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void DescribeAutoRenewAttributeRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string DescribeAutoRenewAttributeRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long DescribeAutoRenewAttributeRequest::getOwnerId()const
-{
-	return ownerId_;
+void DescribeAutoRenewAttributeRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void DescribeAutoRenewAttributeRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long DescribeAutoRenewAttributeRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string DescribeAutoRenewAttributeRequest::getDBClusterIds()const
-{
-	return dBClusterIds_;
+void DescribeAutoRenewAttributeRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void DescribeAutoRenewAttributeRequest::setDBClusterIds(const std::string& dBClusterIds)
-{
-	dBClusterIds_ = dBClusterIds;
-	setParameter("DBClusterIds", dBClusterIds);
+std::string DescribeAutoRenewAttributeRequest::getDBClusterIds() const {
+  return dBClusterIds_;
+}
+
+void DescribeAutoRenewAttributeRequest::setDBClusterIds(const std::string &dBClusterIds) {
+  dBClusterIds_ = dBClusterIds;
+  setParameter(std::string("DBClusterIds"), dBClusterIds);
 }
 

adb/src/model/DescribeAutoRenewAttributeResult.cc

@@ -45,24 +45,24 @@ void DescribeAutoRenewAttributeResult::parse(const std::string &payload)
 		AutoRenewAttribute itemsObject;
 		if(!valueItemsAutoRenewAttribute["DBClusterId"].isNull())
 			itemsObject.dBClusterId = valueItemsAutoRenewAttribute["DBClusterId"].asString();
-		if(!valueItemsAutoRenewAttribute["RegionId"].isNull())
-			itemsObject.regionId = valueItemsAutoRenewAttribute["RegionId"].asString();
-		if(!valueItemsAutoRenewAttribute["AutoRenewEnabled"].isNull())
-			itemsObject.autoRenewEnabled = valueItemsAutoRenewAttribute["AutoRenewEnabled"].asString() == "true";
-		if(!valueItemsAutoRenewAttribute["Duration"].isNull())
-			itemsObject.duration = std::stoi(valueItemsAutoRenewAttribute["Duration"].asString());
 		if(!valueItemsAutoRenewAttribute["PeriodUnit"].isNull())
 			itemsObject.periodUnit = valueItemsAutoRenewAttribute["PeriodUnit"].asString();
+		if(!valueItemsAutoRenewAttribute["Duration"].isNull())
+			itemsObject.duration = std::stoi(valueItemsAutoRenewAttribute["Duration"].asString());
 		if(!valueItemsAutoRenewAttribute["RenewalStatus"].isNull())
 			itemsObject.renewalStatus = valueItemsAutoRenewAttribute["RenewalStatus"].asString();
+		if(!valueItemsAutoRenewAttribute["AutoRenewEnabled"].isNull())
+			itemsObject.autoRenewEnabled = valueItemsAutoRenewAttribute["AutoRenewEnabled"].asString() == "true";
+		if(!valueItemsAutoRenewAttribute["RegionId"].isNull())
+			itemsObject.regionId = valueItemsAutoRenewAttribute["RegionId"].asString();
 		items_.push_back(itemsObject);
 	}
-	if(!value["PageNumber"].isNull())
-		pageNumber_ = std::stoi(value["PageNumber"].asString());
 	if(!value["TotalRecordCount"].isNull())
 		totalRecordCount_ = std::stoi(value["TotalRecordCount"].asString());
 	if(!value["PageRecordCount"].isNull())
 		pageRecordCount_ = std::stoi(value["PageRecordCount"].asString());
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
 
 }
 

adb/src/model/DescribeAvailableResourceRequest.cc

@@ -1,128 +1,108 @@
 /*
  * 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/adb/model/DescribeAvailableResourceRequest.h>
-
-using AlibabaCloud::Adb::Model::DescribeAvailableResourceRequest;
-
-DescribeAvailableResourceRequest::DescribeAvailableResourceRequest() :
-	RpcServiceRequest("adb", "2019-03-15", "DescribeAvailableResource")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeAvailableResourceRequest::~DescribeAvailableResourceRequest()
-{}
-
-long DescribeAvailableResourceRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/adb/model/DescribeAvailableResourceRequest.h>
+
+using AlibabaCloud::Adb::Model::DescribeAvailableResourceRequest;
+
+DescribeAvailableResourceRequest::DescribeAvailableResourceRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DescribeAvailableResource") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeAvailableResourceRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+DescribeAvailableResourceRequest::~DescribeAvailableResourceRequest() {}
+
+long DescribeAvailableResourceRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string DescribeAvailableResourceRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
+void DescribeAvailableResourceRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void DescribeAvailableResourceRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+std::string DescribeAvailableResourceRequest::getAccessKeyId() const {
+  return accessKeyId_;
 }
 
-std::string DescribeAvailableResourceRequest::getRegionId()const
-{
-	return regionId_;
+void DescribeAvailableResourceRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-void DescribeAvailableResourceRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string DescribeAvailableResourceRequest::getRegionId() const {
+  return regionId_;
 }
 
-std::string DescribeAvailableResourceRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void DescribeAvailableResourceRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void DescribeAvailableResourceRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string DescribeAvailableResourceRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string DescribeAvailableResourceRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void DescribeAvailableResourceRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void DescribeAvailableResourceRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string DescribeAvailableResourceRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long DescribeAvailableResourceRequest::getOwnerId()const
-{
-	return ownerId_;
+void DescribeAvailableResourceRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void DescribeAvailableResourceRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long DescribeAvailableResourceRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string DescribeAvailableResourceRequest::getAcceptLanguage()const
-{
-	return acceptLanguage_;
+void DescribeAvailableResourceRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void DescribeAvailableResourceRequest::setAcceptLanguage(const std::string& acceptLanguage)
-{
-	acceptLanguage_ = acceptLanguage;
-	setParameter("AcceptLanguage", acceptLanguage);
+std::string DescribeAvailableResourceRequest::getAcceptLanguage() const {
+  return acceptLanguage_;
 }
 
-std::string DescribeAvailableResourceRequest::getZoneId()const
-{
-	return zoneId_;
+void DescribeAvailableResourceRequest::setAcceptLanguage(const std::string &acceptLanguage) {
+  acceptLanguage_ = acceptLanguage;
+  setParameter(std::string("AcceptLanguage"), acceptLanguage);
 }
 
-void DescribeAvailableResourceRequest::setZoneId(const std::string& zoneId)
-{
-	zoneId_ = zoneId;
-	setParameter("ZoneId", zoneId);
+std::string DescribeAvailableResourceRequest::getZoneId() const {
+  return zoneId_;
 }
 
-std::string DescribeAvailableResourceRequest::getChargeType()const
-{
-	return chargeType_;
+void DescribeAvailableResourceRequest::setZoneId(const std::string &zoneId) {
+  zoneId_ = zoneId;
+  setParameter(std::string("ZoneId"), zoneId);
 }
 
-void DescribeAvailableResourceRequest::setChargeType(const std::string& chargeType)
-{
-	chargeType_ = chargeType;
-	setParameter("ChargeType", chargeType);
+std::string DescribeAvailableResourceRequest::getChargeType() const {
+  return chargeType_;
+}
+
+void DescribeAvailableResourceRequest::setChargeType(const std::string &chargeType) {
+  chargeType_ = chargeType;
+  setParameter(std::string("ChargeType"), chargeType);
 }
 

adb/src/model/DescribeAvailableResourceResult.cc

@@ -64,18 +64,18 @@ void DescribeAvailableResourceResult::parse(const std::string &payload)
 					if(!valueAvailableZoneListAvailableZoneSupportedModeSupportedModeItemSupportedSerialListSupportedSerialListItemSupportedFlexibleResourceSupportedFlexibleResourceItem["StorageType"].isNull())
 						supportedFlexibleResourceObject.storageType = valueAvailableZoneListAvailableZoneSupportedModeSupportedModeItemSupportedSerialListSupportedSerialListItemSupportedFlexibleResourceSupportedFlexibleResourceItem["StorageType"].asString();
 					auto supportedElasticIOResourceNode = value["SupportedElasticIOResource"];
+					if(!supportedElasticIOResourceNode["Step"].isNull())
+						supportedFlexibleResourceObject.supportedElasticIOResource.step = supportedElasticIOResourceNode["Step"].asString();
 					if(!supportedElasticIOResourceNode["MinCount"].isNull())
 						supportedFlexibleResourceObject.supportedElasticIOResource.minCount = supportedElasticIOResourceNode["MinCount"].asString();
 					if(!supportedElasticIOResourceNode["MaxCount"].isNull())
 						supportedFlexibleResourceObject.supportedElasticIOResource.maxCount = supportedElasticIOResourceNode["MaxCount"].asString();
-					if(!supportedElasticIOResourceNode["Step"].isNull())
-						supportedFlexibleResourceObject.supportedElasticIOResource.step = supportedElasticIOResourceNode["Step"].asString();
-					auto allSupportedStorageResource = value["SupportedStorageResource"]["SupportedStorageResource"];
-					for (auto value : allSupportedStorageResource)
-						supportedFlexibleResourceObject.supportedStorageResource.push_back(value.asString());
 					auto allSupportedComputeResource = value["SupportedComputeResource"]["SupportedComputeResource"];
 					for (auto value : allSupportedComputeResource)
 						supportedFlexibleResourceObject.supportedComputeResource.push_back(value.asString());
+					auto allSupportedStorageResource = value["SupportedStorageResource"]["SupportedStorageResource"];
+					for (auto value : allSupportedStorageResource)
+						supportedFlexibleResourceObject.supportedStorageResource.push_back(value.asString());
 					supportedSerialListObject.supportedFlexibleResource.push_back(supportedFlexibleResourceObject);
 				}
 				auto allSupportedInstanceClassListNode = valueAvailableZoneListAvailableZoneSupportedModeSupportedModeItemSupportedSerialListSupportedSerialListItem["SupportedInstanceClassList"]["SupportedInstanceClass"];
@@ -91,12 +91,12 @@ void DescribeAvailableResourceResult::parse(const std::string &payload)
 					{
 						AvailableZone::SupportedModeItem::SupportedSerialListItem::SupportedInstanceClass::SupportedNodeCount supportedNodeCountListObject;
 						auto nodeCountNode = value["NodeCount"];
+						if(!nodeCountNode["Step"].isNull())
+							supportedNodeCountListObject.nodeCount.step = nodeCountNode["Step"].asString();
 						if(!nodeCountNode["MinCount"].isNull())
 							supportedNodeCountListObject.nodeCount.minCount = nodeCountNode["MinCount"].asString();
 						if(!nodeCountNode["MaxCount"].isNull())
 							supportedNodeCountListObject.nodeCount.maxCount = nodeCountNode["MaxCount"].asString();
-						if(!nodeCountNode["Step"].isNull())
-							supportedNodeCountListObject.nodeCount.step = nodeCountNode["Step"].asString();
 						auto allStorageSize = value["StorageSize"]["StorageSize"];
 						for (auto value : allStorageSize)
 							supportedNodeCountListObject.storageSize.push_back(value.asString());
@@ -107,12 +107,12 @@ void DescribeAvailableResourceResult::parse(const std::string &payload)
 					{
 						AvailableZone::SupportedModeItem::SupportedSerialListItem::SupportedInstanceClass::SupportedExecutor supportedExecutorListObject;
 						auto nodeCount1Node = value["NodeCount"];
+						if(!nodeCount1Node["Step"].isNull())
+							supportedExecutorListObject.nodeCount1.step = nodeCount1Node["Step"].asString();
 						if(!nodeCount1Node["MinCount"].isNull())
 							supportedExecutorListObject.nodeCount1.minCount = nodeCount1Node["MinCount"].asString();
 						if(!nodeCount1Node["MaxCount"].isNull())
 							supportedExecutorListObject.nodeCount1.maxCount = nodeCount1Node["MaxCount"].asString();
-						if(!nodeCount1Node["Step"].isNull())
-							supportedExecutorListObject.nodeCount1.step = nodeCount1Node["Step"].asString();
 						supportedInstanceClassListObject.supportedExecutorList.push_back(supportedExecutorListObject);
 					}
 					supportedSerialListObject.supportedInstanceClassList.push_back(supportedInstanceClassListObject);

adb/src/model/DescribeBackupPolicyRequest.cc

@@ -1,95 +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/adb/model/DescribeBackupPolicyRequest.h>
-
-using AlibabaCloud::Adb::Model::DescribeBackupPolicyRequest;
-
-DescribeBackupPolicyRequest::DescribeBackupPolicyRequest() :
-	RpcServiceRequest("adb", "2019-03-15", "DescribeBackupPolicy")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeBackupPolicyRequest::~DescribeBackupPolicyRequest()
-{}
-
-long DescribeBackupPolicyRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/adb/model/DescribeBackupPolicyRequest.h>
+
+using AlibabaCloud::Adb::Model::DescribeBackupPolicyRequest;
+
+DescribeBackupPolicyRequest::DescribeBackupPolicyRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DescribeBackupPolicy") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeBackupPolicyRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+DescribeBackupPolicyRequest::~DescribeBackupPolicyRequest() {}
+
+long DescribeBackupPolicyRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string DescribeBackupPolicyRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
+void DescribeBackupPolicyRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void DescribeBackupPolicyRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+std::string DescribeBackupPolicyRequest::getAccessKeyId() const {
+  return accessKeyId_;
 }
 
-std::string DescribeBackupPolicyRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void DescribeBackupPolicyRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-void DescribeBackupPolicyRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string DescribeBackupPolicyRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string DescribeBackupPolicyRequest::getDBClusterId()const
-{
-	return dBClusterId_;
+void DescribeBackupPolicyRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void DescribeBackupPolicyRequest::setDBClusterId(const std::string& dBClusterId)
-{
-	dBClusterId_ = dBClusterId;
-	setParameter("DBClusterId", dBClusterId);
+std::string DescribeBackupPolicyRequest::getDBClusterId() const {
+  return dBClusterId_;
 }
 
-std::string DescribeBackupPolicyRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void DescribeBackupPolicyRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
 }
 
-void DescribeBackupPolicyRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string DescribeBackupPolicyRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long DescribeBackupPolicyRequest::getOwnerId()const
-{
-	return ownerId_;
+void DescribeBackupPolicyRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void DescribeBackupPolicyRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long DescribeBackupPolicyRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DescribeBackupPolicyRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 

adb/src/model/DescribeBackupPolicyResult.cc

@@ -39,16 +39,16 @@ void DescribeBackupPolicyResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["BackupRetentionPeriod"].isNull())
-		backupRetentionPeriod_ = std::stoi(value["BackupRetentionPeriod"].asString());
-	if(!value["PreferredBackupTime"].isNull())
-		preferredBackupTime_ = value["PreferredBackupTime"].asString();
 	if(!value["PreferredBackupPeriod"].isNull())
 		preferredBackupPeriod_ = value["PreferredBackupPeriod"].asString();
-	if(!value["EnableBackupLog"].isNull())
-		enableBackupLog_ = value["EnableBackupLog"].asString();
 	if(!value["LogBackupRetentionPeriod"].isNull())
 		logBackupRetentionPeriod_ = std::stoi(value["LogBackupRetentionPeriod"].asString());
+	if(!value["PreferredBackupTime"].isNull())
+		preferredBackupTime_ = value["PreferredBackupTime"].asString();
+	if(!value["EnableBackupLog"].isNull())
+		enableBackupLog_ = value["EnableBackupLog"].asString();
+	if(!value["BackupRetentionPeriod"].isNull())
+		backupRetentionPeriod_ = std::stoi(value["BackupRetentionPeriod"].asString());
 
 }
 

adb/src/model/DescribeBackupsRequest.cc

@@ -1,150 +1,126 @@
 /*
  * 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/adb/model/DescribeBackupsRequest.h>
-
-using AlibabaCloud::Adb::Model::DescribeBackupsRequest;
-
-DescribeBackupsRequest::DescribeBackupsRequest() :
-	RpcServiceRequest("adb", "2019-03-15", "DescribeBackups")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeBackupsRequest::~DescribeBackupsRequest()
-{}
-
-long DescribeBackupsRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/adb/model/DescribeBackupsRequest.h>
+
+using AlibabaCloud::Adb::Model::DescribeBackupsRequest;
+
+DescribeBackupsRequest::DescribeBackupsRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DescribeBackups") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeBackupsRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+DescribeBackupsRequest::~DescribeBackupsRequest() {}
+
+long DescribeBackupsRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string DescribeBackupsRequest::getStartTime()const
-{
-	return startTime_;
+void DescribeBackupsRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void DescribeBackupsRequest::setStartTime(const std::string& startTime)
-{
-	startTime_ = startTime;
-	setParameter("StartTime", startTime);
+std::string DescribeBackupsRequest::getStartTime() const {
+  return startTime_;
 }
 
-int DescribeBackupsRequest::getPageNumber()const
-{
-	return pageNumber_;
+void DescribeBackupsRequest::setStartTime(const std::string &startTime) {
+  startTime_ = startTime;
+  setParameter(std::string("StartTime"), startTime);
 }
 
-void DescribeBackupsRequest::setPageNumber(int pageNumber)
-{
-	pageNumber_ = pageNumber;
-	setParameter("PageNumber", std::to_string(pageNumber));
+int DescribeBackupsRequest::getPageNumber() const {
+  return pageNumber_;
 }
 
-std::string DescribeBackupsRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
+void DescribeBackupsRequest::setPageNumber(int pageNumber) {
+  pageNumber_ = pageNumber;
+  setParameter(std::string("PageNumber"), std::to_string(pageNumber));
 }
 
-void DescribeBackupsRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+std::string DescribeBackupsRequest::getAccessKeyId() const {
+  return accessKeyId_;
 }
 
-int DescribeBackupsRequest::getPageSize()const
-{
-	return pageSize_;
+void DescribeBackupsRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-void DescribeBackupsRequest::setPageSize(int pageSize)
-{
-	pageSize_ = pageSize;
-	setParameter("PageSize", std::to_string(pageSize));
+int DescribeBackupsRequest::getPageSize() const {
+  return pageSize_;
 }
 
-std::string DescribeBackupsRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void DescribeBackupsRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
 }
 
-void DescribeBackupsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string DescribeBackupsRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string DescribeBackupsRequest::getDBClusterId()const
-{
-	return dBClusterId_;
+void DescribeBackupsRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void DescribeBackupsRequest::setDBClusterId(const std::string& dBClusterId)
-{
-	dBClusterId_ = dBClusterId;
-	setParameter("DBClusterId", dBClusterId);
+std::string DescribeBackupsRequest::getDBClusterId() const {
+  return dBClusterId_;
 }
 
-std::string DescribeBackupsRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void DescribeBackupsRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
 }
 
-void DescribeBackupsRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string DescribeBackupsRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-std::string DescribeBackupsRequest::getBackupId()const
-{
-	return backupId_;
+void DescribeBackupsRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void DescribeBackupsRequest::setBackupId(const std::string& backupId)
-{
-	backupId_ = backupId;
-	setParameter("BackupId", backupId);
+std::string DescribeBackupsRequest::getBackupId() const {
+  return backupId_;
 }
 
-std::string DescribeBackupsRequest::getEndTime()const
-{
-	return endTime_;
+void DescribeBackupsRequest::setBackupId(const std::string &backupId) {
+  backupId_ = backupId;
+  setParameter(std::string("BackupId"), backupId);
 }
 
-void DescribeBackupsRequest::setEndTime(const std::string& endTime)
-{
-	endTime_ = endTime;
-	setParameter("EndTime", endTime);
+std::string DescribeBackupsRequest::getEndTime() const {
+  return endTime_;
 }
 
-long DescribeBackupsRequest::getOwnerId()const
-{
-	return ownerId_;
+void DescribeBackupsRequest::setEndTime(const std::string &endTime) {
+  endTime_ = endTime;
+  setParameter(std::string("EndTime"), endTime);
 }
 
-void DescribeBackupsRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long DescribeBackupsRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DescribeBackupsRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 

adb/src/model/DescribeBackupsResult.cc

@@ -43,28 +43,28 @@ void DescribeBackupsResult::parse(const std::string &payload)
 	for (auto valueItemsBackup : allItemsNode)
 	{
 		Backup itemsObject;
-		if(!valueItemsBackup["BackupId"].isNull())
-			itemsObject.backupId = valueItemsBackup["BackupId"].asString();
 		if(!valueItemsBackup["DBClusterId"].isNull())
 			itemsObject.dBClusterId = valueItemsBackup["DBClusterId"].asString();
-		if(!valueItemsBackup["BackupStartTime"].isNull())
-			itemsObject.backupStartTime = valueItemsBackup["BackupStartTime"].asString();
-		if(!valueItemsBackup["BackupEndTime"].isNull())
-			itemsObject.backupEndTime = valueItemsBackup["BackupEndTime"].asString();
-		if(!valueItemsBackup["BackupSize"].isNull())
-			itemsObject.backupSize = std::stoi(valueItemsBackup["BackupSize"].asString());
-		if(!valueItemsBackup["BackupMethod"].isNull())
-			itemsObject.backupMethod = valueItemsBackup["BackupMethod"].asString();
 		if(!valueItemsBackup["BackupType"].isNull())
 			itemsObject.backupType = valueItemsBackup["BackupType"].asString();
+		if(!valueItemsBackup["BackupStartTime"].isNull())
+			itemsObject.backupStartTime = valueItemsBackup["BackupStartTime"].asString();
+		if(!valueItemsBackup["BackupSize"].isNull())
+			itemsObject.backupSize = std::stoi(valueItemsBackup["BackupSize"].asString());
+		if(!valueItemsBackup["BackupEndTime"].isNull())
+			itemsObject.backupEndTime = valueItemsBackup["BackupEndTime"].asString();
+		if(!valueItemsBackup["BackupId"].isNull())
+			itemsObject.backupId = valueItemsBackup["BackupId"].asString();
+		if(!valueItemsBackup["BackupMethod"].isNull())
+			itemsObject.backupMethod = valueItemsBackup["BackupMethod"].asString();
 		items_.push_back(itemsObject);
 	}
 	if(!value["TotalCount"].isNull())
 		totalCount_ = value["TotalCount"].asString();
-	if(!value["PageNumber"].isNull())
-		pageNumber_ = value["PageNumber"].asString();
 	if(!value["PageSize"].isNull())
 		pageSize_ = value["PageSize"].asString();
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = value["PageNumber"].asString();
 
 }
 

adb/src/model/DescribeColumnsRequest.cc

@@ -1,117 +1,99 @@
 /*
  * 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/adb/model/DescribeColumnsRequest.h>
-
-using AlibabaCloud::Adb::Model::DescribeColumnsRequest;
-
-DescribeColumnsRequest::DescribeColumnsRequest() :
-	RpcServiceRequest("adb", "2019-03-15", "DescribeColumns")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeColumnsRequest::~DescribeColumnsRequest()
-{}
-
-long DescribeColumnsRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/adb/model/DescribeColumnsRequest.h>
+
+using AlibabaCloud::Adb::Model::DescribeColumnsRequest;
+
+DescribeColumnsRequest::DescribeColumnsRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DescribeColumns") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeColumnsRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+DescribeColumnsRequest::~DescribeColumnsRequest() {}
+
+long DescribeColumnsRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string DescribeColumnsRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
+void DescribeColumnsRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void DescribeColumnsRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+std::string DescribeColumnsRequest::getAccessKeyId() const {
+  return accessKeyId_;
 }
 
-std::string DescribeColumnsRequest::getTableName()const
-{
-	return tableName_;
+void DescribeColumnsRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-void DescribeColumnsRequest::setTableName(const std::string& tableName)
-{
-	tableName_ = tableName;
-	setParameter("TableName", tableName);
+std::string DescribeColumnsRequest::getTableName() const {
+  return tableName_;
 }
 
-std::string DescribeColumnsRequest::getSchemaName()const
-{
-	return schemaName_;
+void DescribeColumnsRequest::setTableName(const std::string &tableName) {
+  tableName_ = tableName;
+  setParameter(std::string("TableName"), tableName);
 }
 
-void DescribeColumnsRequest::setSchemaName(const std::string& schemaName)
-{
-	schemaName_ = schemaName;
-	setParameter("SchemaName", schemaName);
+std::string DescribeColumnsRequest::getSchemaName() const {
+  return schemaName_;
 }
 
-std::string DescribeColumnsRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void DescribeColumnsRequest::setSchemaName(const std::string &schemaName) {
+  schemaName_ = schemaName;
+  setParameter(std::string("SchemaName"), schemaName);
 }
 
-void DescribeColumnsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string DescribeColumnsRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string DescribeColumnsRequest::getDBClusterId()const
-{
-	return dBClusterId_;
+void DescribeColumnsRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void DescribeColumnsRequest::setDBClusterId(const std::string& dBClusterId)
-{
-	dBClusterId_ = dBClusterId;
-	setParameter("DBClusterId", dBClusterId);
+std::string DescribeColumnsRequest::getDBClusterId() const {
+  return dBClusterId_;
 }
 
-std::string DescribeColumnsRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void DescribeColumnsRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
 }
 
-void DescribeColumnsRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string DescribeColumnsRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long DescribeColumnsRequest::getOwnerId()const
-{
-	return ownerId_;
+void DescribeColumnsRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void DescribeColumnsRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long DescribeColumnsRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DescribeColumnsRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 

adb/src/model/DescribeColumnsResult.cc

@@ -43,20 +43,20 @@ void DescribeColumnsResult::parse(const std::string &payload)
 	for (auto valueItemsColumn : allItemsNode)
 	{
 		Column itemsObject;
-		if(!valueItemsColumn["DBClusterId"].isNull())
-			itemsObject.dBClusterId = valueItemsColumn["DBClusterId"].asString();
-		if(!valueItemsColumn["SchemaName"].isNull())
-			itemsObject.schemaName = valueItemsColumn["SchemaName"].asString();
-		if(!valueItemsColumn["TableName"].isNull())
-			itemsObject.tableName = valueItemsColumn["TableName"].asString();
-		if(!valueItemsColumn["ColumnName"].isNull())
-			itemsObject.columnName = valueItemsColumn["ColumnName"].asString();
 		if(!valueItemsColumn["Type"].isNull())
 			itemsObject.type = valueItemsColumn["Type"].asString();
-		if(!valueItemsColumn["PrimaryKey"].isNull())
-			itemsObject.primaryKey = valueItemsColumn["PrimaryKey"].asString() == "true";
+		if(!valueItemsColumn["ColumnName"].isNull())
+			itemsObject.columnName = valueItemsColumn["ColumnName"].asString();
+		if(!valueItemsColumn["TableName"].isNull())
+			itemsObject.tableName = valueItemsColumn["TableName"].asString();
 		if(!valueItemsColumn["AutoIncrementColumn"].isNull())
 			itemsObject.autoIncrementColumn = valueItemsColumn["AutoIncrementColumn"].asString() == "true";
+		if(!valueItemsColumn["DBClusterId"].isNull())
+			itemsObject.dBClusterId = valueItemsColumn["DBClusterId"].asString();
+		if(!valueItemsColumn["PrimaryKey"].isNull())
+			itemsObject.primaryKey = valueItemsColumn["PrimaryKey"].asString() == "true";
+		if(!valueItemsColumn["SchemaName"].isNull())
+			itemsObject.schemaName = valueItemsColumn["SchemaName"].asString();
 		items_.push_back(itemsObject);
 	}
 

adb/src/model/DescribeConnectionCountRecordsRequest.cc

@@ -1,95 +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/adb/model/DescribeConnectionCountRecordsRequest.h>
-
-using AlibabaCloud::Adb::Model::DescribeConnectionCountRecordsRequest;
-
-DescribeConnectionCountRecordsRequest::DescribeConnectionCountRecordsRequest() :
-	RpcServiceRequest("adb", "2019-03-15", "DescribeConnectionCountRecords")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeConnectionCountRecordsRequest::~DescribeConnectionCountRecordsRequest()
-{}
-
-long DescribeConnectionCountRecordsRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/adb/model/DescribeConnectionCountRecordsRequest.h>
+
+using AlibabaCloud::Adb::Model::DescribeConnectionCountRecordsRequest;
+
+DescribeConnectionCountRecordsRequest::DescribeConnectionCountRecordsRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DescribeConnectionCountRecords") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeConnectionCountRecordsRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+DescribeConnectionCountRecordsRequest::~DescribeConnectionCountRecordsRequest() {}
+
+long DescribeConnectionCountRecordsRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string DescribeConnectionCountRecordsRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
+void DescribeConnectionCountRecordsRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void DescribeConnectionCountRecordsRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+std::string DescribeConnectionCountRecordsRequest::getAccessKeyId() const {
+  return accessKeyId_;
 }
 
-std::string DescribeConnectionCountRecordsRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void DescribeConnectionCountRecordsRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-void DescribeConnectionCountRecordsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string DescribeConnectionCountRecordsRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string DescribeConnectionCountRecordsRequest::getDBClusterId()const
-{
-	return dBClusterId_;
+void DescribeConnectionCountRecordsRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void DescribeConnectionCountRecordsRequest::setDBClusterId(const std::string& dBClusterId)
-{
-	dBClusterId_ = dBClusterId;
-	setParameter("DBClusterId", dBClusterId);
+std::string DescribeConnectionCountRecordsRequest::getDBClusterId() const {
+  return dBClusterId_;
 }
 
-std::string DescribeConnectionCountRecordsRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void DescribeConnectionCountRecordsRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
 }
 
-void DescribeConnectionCountRecordsRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string DescribeConnectionCountRecordsRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long DescribeConnectionCountRecordsRequest::getOwnerId()const
-{
-	return ownerId_;
+void DescribeConnectionCountRecordsRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void DescribeConnectionCountRecordsRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long DescribeConnectionCountRecordsRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DescribeConnectionCountRecordsRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 

adb/src/model/DescribeConnectionCountRecordsResult.cc

@@ -39,16 +39,6 @@ void DescribeConnectionCountRecordsResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	auto allUserRecordsNode = value["UserRecords"]["Users"];
-	for (auto valueUserRecordsUsers : allUserRecordsNode)
-	{
-		Users userRecordsObject;
-		if(!valueUserRecordsUsers["User"].isNull())
-			userRecordsObject.user = valueUserRecordsUsers["User"].asString();
-		if(!valueUserRecordsUsers["Count"].isNull())
-			userRecordsObject.count = std::stol(valueUserRecordsUsers["Count"].asString());
-		userRecords_.push_back(userRecordsObject);
-	}
 	auto allAccessIpRecordsNode = value["AccessIpRecords"]["AccessIps"];
 	for (auto valueAccessIpRecordsAccessIps : allAccessIpRecordsNode)
 	{
@@ -59,6 +49,16 @@ void DescribeConnectionCountRecordsResult::parse(const std::string &payload)
 			accessIpRecordsObject.count = std::stol(valueAccessIpRecordsAccessIps["Count"].asString());
 		accessIpRecords_.push_back(accessIpRecordsObject);
 	}
+	auto allUserRecordsNode = value["UserRecords"]["Users"];
+	for (auto valueUserRecordsUsers : allUserRecordsNode)
+	{
+		Users userRecordsObject;
+		if(!valueUserRecordsUsers["User"].isNull())
+			userRecordsObject.user = valueUserRecordsUsers["User"].asString();
+		if(!valueUserRecordsUsers["Count"].isNull())
+			userRecordsObject.count = std::stol(valueUserRecordsUsers["Count"].asString());
+		userRecords_.push_back(userRecordsObject);
+	}
 	if(!value["TotalCount"].isNull())
 		totalCount_ = value["TotalCount"].asString();
 	if(!value["DBClusterId"].isNull())

adb/src/model/DescribeDBClusterAccessWhiteListRequest.cc

@@ -1,95 +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/adb/model/DescribeDBClusterAccessWhiteListRequest.h>
-
-using AlibabaCloud::Adb::Model::DescribeDBClusterAccessWhiteListRequest;
-
-DescribeDBClusterAccessWhiteListRequest::DescribeDBClusterAccessWhiteListRequest() :
-	RpcServiceRequest("adb", "2019-03-15", "DescribeDBClusterAccessWhiteList")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeDBClusterAccessWhiteListRequest::~DescribeDBClusterAccessWhiteListRequest()
-{}
-
-long DescribeDBClusterAccessWhiteListRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/adb/model/DescribeDBClusterAccessWhiteListRequest.h>
+
+using AlibabaCloud::Adb::Model::DescribeDBClusterAccessWhiteListRequest;
+
+DescribeDBClusterAccessWhiteListRequest::DescribeDBClusterAccessWhiteListRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DescribeDBClusterAccessWhiteList") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeDBClusterAccessWhiteListRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+DescribeDBClusterAccessWhiteListRequest::~DescribeDBClusterAccessWhiteListRequest() {}
+
+long DescribeDBClusterAccessWhiteListRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string DescribeDBClusterAccessWhiteListRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
+void DescribeDBClusterAccessWhiteListRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void DescribeDBClusterAccessWhiteListRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+std::string DescribeDBClusterAccessWhiteListRequest::getAccessKeyId() const {
+  return accessKeyId_;
 }
 
-std::string DescribeDBClusterAccessWhiteListRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void DescribeDBClusterAccessWhiteListRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-void DescribeDBClusterAccessWhiteListRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string DescribeDBClusterAccessWhiteListRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string DescribeDBClusterAccessWhiteListRequest::getDBClusterId()const
-{
-	return dBClusterId_;
+void DescribeDBClusterAccessWhiteListRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void DescribeDBClusterAccessWhiteListRequest::setDBClusterId(const std::string& dBClusterId)
-{
-	dBClusterId_ = dBClusterId;
-	setParameter("DBClusterId", dBClusterId);
+std::string DescribeDBClusterAccessWhiteListRequest::getDBClusterId() const {
+  return dBClusterId_;
 }
 
-std::string DescribeDBClusterAccessWhiteListRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void DescribeDBClusterAccessWhiteListRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
 }
 
-void DescribeDBClusterAccessWhiteListRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string DescribeDBClusterAccessWhiteListRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long DescribeDBClusterAccessWhiteListRequest::getOwnerId()const
-{
-	return ownerId_;
+void DescribeDBClusterAccessWhiteListRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void DescribeDBClusterAccessWhiteListRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long DescribeDBClusterAccessWhiteListRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DescribeDBClusterAccessWhiteListRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 

adb/src/model/DescribeDBClusterAccessWhiteListResult.cc

@@ -43,12 +43,12 @@ void DescribeDBClusterAccessWhiteListResult::parse(const std::string &payload)
 	for (auto valueItemsIPArray : allItemsNode)
 	{
 		IPArray itemsObject;
-		if(!valueItemsIPArray["DBClusterIPArrayName"].isNull())
-			itemsObject.dBClusterIPArrayName = valueItemsIPArray["DBClusterIPArrayName"].asString();
-		if(!valueItemsIPArray["SecurityIPList"].isNull())
-			itemsObject.securityIPList = valueItemsIPArray["SecurityIPList"].asString();
 		if(!valueItemsIPArray["DBClusterIPArrayAttribute"].isNull())
 			itemsObject.dBClusterIPArrayAttribute = valueItemsIPArray["DBClusterIPArrayAttribute"].asString();
+		if(!valueItemsIPArray["SecurityIPList"].isNull())
+			itemsObject.securityIPList = valueItemsIPArray["SecurityIPList"].asString();
+		if(!valueItemsIPArray["DBClusterIPArrayName"].isNull())
+			itemsObject.dBClusterIPArrayName = valueItemsIPArray["DBClusterIPArrayName"].asString();
 		items_.push_back(itemsObject);
 	}
 

adb/src/model/DescribeDBClusterAttributeRequest.cc

@@ -1,95 +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/adb/model/DescribeDBClusterAttributeRequest.h>
-
-using AlibabaCloud::Adb::Model::DescribeDBClusterAttributeRequest;
-
-DescribeDBClusterAttributeRequest::DescribeDBClusterAttributeRequest() :
-	RpcServiceRequest("adb", "2019-03-15", "DescribeDBClusterAttribute")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeDBClusterAttributeRequest::~DescribeDBClusterAttributeRequest()
-{}
-
-long DescribeDBClusterAttributeRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/adb/model/DescribeDBClusterAttributeRequest.h>
+
+using AlibabaCloud::Adb::Model::DescribeDBClusterAttributeRequest;
+
+DescribeDBClusterAttributeRequest::DescribeDBClusterAttributeRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DescribeDBClusterAttribute") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeDBClusterAttributeRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+DescribeDBClusterAttributeRequest::~DescribeDBClusterAttributeRequest() {}
+
+long DescribeDBClusterAttributeRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string DescribeDBClusterAttributeRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
+void DescribeDBClusterAttributeRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void DescribeDBClusterAttributeRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+std::string DescribeDBClusterAttributeRequest::getAccessKeyId() const {
+  return accessKeyId_;
 }
 
-std::string DescribeDBClusterAttributeRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void DescribeDBClusterAttributeRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-void DescribeDBClusterAttributeRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string DescribeDBClusterAttributeRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string DescribeDBClusterAttributeRequest::getDBClusterId()const
-{
-	return dBClusterId_;
+void DescribeDBClusterAttributeRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void DescribeDBClusterAttributeRequest::setDBClusterId(const std::string& dBClusterId)
-{
-	dBClusterId_ = dBClusterId;
-	setParameter("DBClusterId", dBClusterId);
+std::string DescribeDBClusterAttributeRequest::getDBClusterId() const {
+  return dBClusterId_;
 }
 
-std::string DescribeDBClusterAttributeRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void DescribeDBClusterAttributeRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
 }
 
-void DescribeDBClusterAttributeRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string DescribeDBClusterAttributeRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long DescribeDBClusterAttributeRequest::getOwnerId()const
-{
-	return ownerId_;
+void DescribeDBClusterAttributeRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void DescribeDBClusterAttributeRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long DescribeDBClusterAttributeRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DescribeDBClusterAttributeRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 

adb/src/model/DescribeDBClusterAttributeResult.cc

@@ -43,84 +43,86 @@ void DescribeDBClusterAttributeResult::parse(const std::string &payload)
 	for (auto valueItemsDBCluster : allItemsNode)
 	{
 		DBCluster itemsObject;
-		if(!valueItemsDBCluster["RegionId"].isNull())
-			itemsObject.regionId = valueItemsDBCluster["RegionId"].asString();
-		if(!valueItemsDBCluster["ZoneId"].isNull())
-			itemsObject.zoneId = valueItemsDBCluster["ZoneId"].asString();
-		if(!valueItemsDBCluster["DBClusterId"].isNull())
-			itemsObject.dBClusterId = valueItemsDBCluster["DBClusterId"].asString();
-		if(!valueItemsDBCluster["DBClusterType"].isNull())
-			itemsObject.dBClusterType = valueItemsDBCluster["DBClusterType"].asString();
-		if(!valueItemsDBCluster["DBClusterDescription"].isNull())
-			itemsObject.dBClusterDescription = valueItemsDBCluster["DBClusterDescription"].asString();
-		if(!valueItemsDBCluster["Category"].isNull())
-			itemsObject.category = valueItemsDBCluster["Category"].asString();
-		if(!valueItemsDBCluster["LockMode"].isNull())
-			itemsObject.lockMode = valueItemsDBCluster["LockMode"].asString();
-		if(!valueItemsDBCluster["LockReason"].isNull())
-			itemsObject.lockReason = valueItemsDBCluster["LockReason"].asString();
-		if(!valueItemsDBCluster["PayType"].isNull())
-			itemsObject.payType = valueItemsDBCluster["PayType"].asString();
-		if(!valueItemsDBCluster["DBVersion"].isNull())
-			itemsObject.dBVersion = valueItemsDBCluster["DBVersion"].asString();
-		if(!valueItemsDBCluster["DBClusterStatus"].isNull())
-			itemsObject.dBClusterStatus = valueItemsDBCluster["DBClusterStatus"].asString();
-		if(!valueItemsDBCluster["DBNodeStorage"].isNull())
-			itemsObject.dBNodeStorage = std::stol(valueItemsDBCluster["DBNodeStorage"].asString());
-		if(!valueItemsDBCluster["DBNodeClass"].isNull())
-			itemsObject.dBNodeClass = valueItemsDBCluster["DBNodeClass"].asString();
-		if(!valueItemsDBCluster["DBNodeCount"].isNull())
-			itemsObject.dBNodeCount = std::stol(valueItemsDBCluster["DBNodeCount"].asString());
 		if(!valueItemsDBCluster["CreationTime"].isNull())
 			itemsObject.creationTime = valueItemsDBCluster["CreationTime"].asString();
-		if(!valueItemsDBCluster["ExpireTime"].isNull())
-			itemsObject.expireTime = valueItemsDBCluster["ExpireTime"].asString();
+		if(!valueItemsDBCluster["EnableSpark"].isNull())
+			itemsObject.enableSpark = valueItemsDBCluster["EnableSpark"].asString() == "true";
+		if(!valueItemsDBCluster["DtsJobId"].isNull())
+			itemsObject.dtsJobId = valueItemsDBCluster["DtsJobId"].asString();
+		if(!valueItemsDBCluster["DBNodeCount"].isNull())
+			itemsObject.dBNodeCount = std::stol(valueItemsDBCluster["DBNodeCount"].asString());
 		if(!valueItemsDBCluster["Expired"].isNull())
 			itemsObject.expired = valueItemsDBCluster["Expired"].asString();
 		if(!valueItemsDBCluster["MaintainTime"].isNull())
 			itemsObject.maintainTime = valueItemsDBCluster["MaintainTime"].asString();
-		if(!valueItemsDBCluster["Engine"].isNull())
-			itemsObject.engine = valueItemsDBCluster["Engine"].asString();
-		if(!valueItemsDBCluster["VPCId"].isNull())
-			itemsObject.vPCId = valueItemsDBCluster["VPCId"].asString();
-		if(!valueItemsDBCluster["VSwitchId"].isNull())
-			itemsObject.vSwitchId = valueItemsDBCluster["VSwitchId"].asString();
-		if(!valueItemsDBCluster["VPCCloudInstanceId"].isNull())
-			itemsObject.vPCCloudInstanceId = valueItemsDBCluster["VPCCloudInstanceId"].asString();
-		if(!valueItemsDBCluster["CommodityCode"].isNull())
-			itemsObject.commodityCode = valueItemsDBCluster["CommodityCode"].asString();
-		if(!valueItemsDBCluster["DBClusterNetworkType"].isNull())
-			itemsObject.dBClusterNetworkType = valueItemsDBCluster["DBClusterNetworkType"].asString();
-		if(!valueItemsDBCluster["ConnectionString"].isNull())
-			itemsObject.connectionString = valueItemsDBCluster["ConnectionString"].asString();
-		if(!valueItemsDBCluster["Port"].isNull())
-			itemsObject.port = std::stoi(valueItemsDBCluster["Port"].asString());
-		if(!valueItemsDBCluster["RdsInstanceId"].isNull())
-			itemsObject.rdsInstanceId = valueItemsDBCluster["RdsInstanceId"].asString();
-		if(!valueItemsDBCluster["DtsJobId"].isNull())
-			itemsObject.dtsJobId = valueItemsDBCluster["DtsJobId"].asString();
-		if(!valueItemsDBCluster["ExecutorCount"].isNull())
-			itemsObject.executorCount = valueItemsDBCluster["ExecutorCount"].asString();
+		if(!valueItemsDBCluster["PayType"].isNull())
+			itemsObject.payType = valueItemsDBCluster["PayType"].asString();
 		if(!valueItemsDBCluster["DiskType"].isNull())
 			itemsObject.diskType = valueItemsDBCluster["DiskType"].asString();
-		if(!valueItemsDBCluster["ComputeResource"].isNull())
-			itemsObject.computeResource = valueItemsDBCluster["ComputeResource"].asString();
-		if(!valueItemsDBCluster["StorageResource"].isNull())
-			itemsObject.storageResource = valueItemsDBCluster["StorageResource"].asString();
 		if(!valueItemsDBCluster["Mode"].isNull())
 			itemsObject.mode = valueItemsDBCluster["Mode"].asString();
-		if(!valueItemsDBCluster["ResourceGroupId"].isNull())
-			itemsObject.resourceGroupId = valueItemsDBCluster["ResourceGroupId"].asString();
-		if(!valueItemsDBCluster["ElasticIOResource"].isNull())
-			itemsObject.elasticIOResource = std::stoi(valueItemsDBCluster["ElasticIOResource"].asString());
+		if(!valueItemsDBCluster["Port"].isNull())
+			itemsObject.port = std::stoi(valueItemsDBCluster["Port"].asString());
+		if(!valueItemsDBCluster["LockMode"].isNull())
+			itemsObject.lockMode = valueItemsDBCluster["LockMode"].asString();
 		if(!valueItemsDBCluster["EngineVersion"].isNull())
 			itemsObject.engineVersion = valueItemsDBCluster["EngineVersion"].asString();
-		if(!valueItemsDBCluster["UserENIStatus"].isNull())
-			itemsObject.userENIStatus = valueItemsDBCluster["UserENIStatus"].asString() == "true";
-		if(!valueItemsDBCluster["EnableSpark"].isNull())
-			itemsObject.enableSpark = valueItemsDBCluster["EnableSpark"].asString() == "true";
 		if(!valueItemsDBCluster["EnableAirflow"].isNull())
 			itemsObject.enableAirflow = valueItemsDBCluster["EnableAirflow"].asString() == "true";
+		if(!valueItemsDBCluster["ExecutorCount"].isNull())
+			itemsObject.executorCount = valueItemsDBCluster["ExecutorCount"].asString();
+		if(!valueItemsDBCluster["StorageResource"].isNull())
+			itemsObject.storageResource = valueItemsDBCluster["StorageResource"].asString();
+		if(!valueItemsDBCluster["DBClusterId"].isNull())
+			itemsObject.dBClusterId = valueItemsDBCluster["DBClusterId"].asString();
+		if(!valueItemsDBCluster["ConnectionString"].isNull())
+			itemsObject.connectionString = valueItemsDBCluster["ConnectionString"].asString();
+		if(!valueItemsDBCluster["RdsInstanceId"].isNull())
+			itemsObject.rdsInstanceId = valueItemsDBCluster["RdsInstanceId"].asString();
+		if(!valueItemsDBCluster["DBClusterType"].isNull())
+			itemsObject.dBClusterType = valueItemsDBCluster["DBClusterType"].asString();
+		if(!valueItemsDBCluster["CommodityCode"].isNull())
+			itemsObject.commodityCode = valueItemsDBCluster["CommodityCode"].asString();
+		if(!valueItemsDBCluster["ExpireTime"].isNull())
+			itemsObject.expireTime = valueItemsDBCluster["ExpireTime"].asString();
+		if(!valueItemsDBCluster["DBNodeStorage"].isNull())
+			itemsObject.dBNodeStorage = std::stol(valueItemsDBCluster["DBNodeStorage"].asString());
+		if(!valueItemsDBCluster["DBNodeClass"].isNull())
+			itemsObject.dBNodeClass = valueItemsDBCluster["DBNodeClass"].asString();
+		if(!valueItemsDBCluster["LockReason"].isNull())
+			itemsObject.lockReason = valueItemsDBCluster["LockReason"].asString();
+		if(!valueItemsDBCluster["VPCId"].isNull())
+			itemsObject.vPCId = valueItemsDBCluster["VPCId"].asString();
+		if(!valueItemsDBCluster["ComputeResource"].isNull())
+			itemsObject.computeResource = valueItemsDBCluster["ComputeResource"].asString();
+		if(!valueItemsDBCluster["RegionId"].isNull())
+			itemsObject.regionId = valueItemsDBCluster["RegionId"].asString();
+		if(!valueItemsDBCluster["ElasticIOResource"].isNull())
+			itemsObject.elasticIOResource = std::stoi(valueItemsDBCluster["ElasticIOResource"].asString());
+		if(!valueItemsDBCluster["VSwitchId"].isNull())
+			itemsObject.vSwitchId = valueItemsDBCluster["VSwitchId"].asString();
+		if(!valueItemsDBCluster["DBVersion"].isNull())
+			itemsObject.dBVersion = valueItemsDBCluster["DBVersion"].asString();
+		if(!valueItemsDBCluster["VPCCloudInstanceId"].isNull())
+			itemsObject.vPCCloudInstanceId = valueItemsDBCluster["VPCCloudInstanceId"].asString();
+		if(!valueItemsDBCluster["DBClusterStatus"].isNull())
+			itemsObject.dBClusterStatus = valueItemsDBCluster["DBClusterStatus"].asString();
+		if(!valueItemsDBCluster["ResourceGroupId"].isNull())
+			itemsObject.resourceGroupId = valueItemsDBCluster["ResourceGroupId"].asString();
+		if(!valueItemsDBCluster["DBClusterNetworkType"].isNull())
+			itemsObject.dBClusterNetworkType = valueItemsDBCluster["DBClusterNetworkType"].asString();
+		if(!valueItemsDBCluster["DBClusterDescription"].isNull())
+			itemsObject.dBClusterDescription = valueItemsDBCluster["DBClusterDescription"].asString();
+		if(!valueItemsDBCluster["UserENIStatus"].isNull())
+			itemsObject.userENIStatus = valueItemsDBCluster["UserENIStatus"].asString() == "true";
+		if(!valueItemsDBCluster["ZoneId"].isNull())
+			itemsObject.zoneId = valueItemsDBCluster["ZoneId"].asString();
+		if(!valueItemsDBCluster["Category"].isNull())
+			itemsObject.category = valueItemsDBCluster["Category"].asString();
+		if(!valueItemsDBCluster["Engine"].isNull())
+			itemsObject.engine = valueItemsDBCluster["Engine"].asString();
+		if(!valueItemsDBCluster["KmsId"].isNull())
+			itemsObject.kmsId = valueItemsDBCluster["KmsId"].asString();
 		auto allTagsNode = valueItemsDBCluster["Tags"]["Tag"];
 		for (auto valueItemsDBClusterTagsTag : allTagsNode)
 		{

adb/src/model/DescribeDBClusterForecastRequest.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/adb/model/DescribeDBClusterForecastRequest.h>
+
+using AlibabaCloud::Adb::Model::DescribeDBClusterForecastRequest;
+
+DescribeDBClusterForecastRequest::DescribeDBClusterForecastRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DescribeDBClusterForecast") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDBClusterForecastRequest::~DescribeDBClusterForecastRequest() {}
+
+std::string DescribeDBClusterForecastRequest::getMetricType() const {
+  return metricType_;
+}
+
+void DescribeDBClusterForecastRequest::setMetricType(const std::string &metricType) {
+  metricType_ = metricType;
+  setParameter(std::string("MetricType"), metricType);
+}
+
+std::string DescribeDBClusterForecastRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeDBClusterForecastRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string DescribeDBClusterForecastRequest::getDBClusterId() const {
+  return dBClusterId_;
+}
+
+void DescribeDBClusterForecastRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
+}
+
+std::string DescribeDBClusterForecastRequest::getStartTime() const {
+  return startTime_;
+}
+
+void DescribeDBClusterForecastRequest::setStartTime(const std::string &startTime) {
+  startTime_ = startTime;
+  setParameter(std::string("StartTime"), startTime);
+}
+

adb/src/model/DescribeDBClusterForecastResult.cc

@@ -0,0 +1,69 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/adb/model/DescribeDBClusterForecastResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Adb;
+using namespace AlibabaCloud::Adb::Model;
+
+DescribeDBClusterForecastResult::DescribeDBClusterForecastResult() :
+	ServiceResult()
+{}
+
+DescribeDBClusterForecastResult::DescribeDBClusterForecastResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDBClusterForecastResult::~DescribeDBClusterForecastResult()
+{}
+
+void DescribeDBClusterForecastResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allPerformancesNode = value["Performances"]["PerformancesItem"];
+	for (auto valuePerformancesPerformancesItem : allPerformancesNode)
+	{
+		PerformancesItem performancesObject;
+		if(!valuePerformancesPerformancesItem["Key"].isNull())
+			performancesObject.key = valuePerformancesPerformancesItem["Key"].asString();
+		if(!valuePerformancesPerformancesItem["Unit"].isNull())
+			performancesObject.unit = valuePerformancesPerformancesItem["Unit"].asString();
+		auto allSeriesNode = valuePerformancesPerformancesItem["Series"]["SeriesItem"];
+		for (auto valuePerformancesPerformancesItemSeriesSeriesItem : allSeriesNode)
+		{
+			PerformancesItem::SeriesItem seriesObject;
+			if(!valuePerformancesPerformancesItemSeriesSeriesItem["Name"].isNull())
+				seriesObject.name = valuePerformancesPerformancesItemSeriesSeriesItem["Name"].asString();
+			if(!valuePerformancesPerformancesItemSeriesSeriesItem["Values"].isNull())
+				seriesObject.values = valuePerformancesPerformancesItemSeriesSeriesItem["Values"].asString();
+			performancesObject.series.push_back(seriesObject);
+		}
+		performances_.push_back(performancesObject);
+	}
+
+}
+
+std::vector<DescribeDBClusterForecastResult::PerformancesItem> DescribeDBClusterForecastResult::getPerformances()const
+{
+	return performances_;
+}
+

adb/src/model/DescribeDBClusterHealthReportRequest.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/adb/model/DescribeDBClusterHealthReportRequest.h>
+
+using AlibabaCloud::Adb::Model::DescribeDBClusterHealthReportRequest;
+
+DescribeDBClusterHealthReportRequest::DescribeDBClusterHealthReportRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DescribeDBClusterHealthReport") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDBClusterHealthReportRequest::~DescribeDBClusterHealthReportRequest() {}
+
+std::string DescribeDBClusterHealthReportRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeDBClusterHealthReportRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string DescribeDBClusterHealthReportRequest::getDBClusterId() const {
+  return dBClusterId_;
+}
+
+void DescribeDBClusterHealthReportRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
+}
+
+std::string DescribeDBClusterHealthReportRequest::getStartTime() const {
+  return startTime_;
+}
+
+void DescribeDBClusterHealthReportRequest::setStartTime(const std::string &startTime) {
+  startTime_ = startTime;
+  setParameter(std::string("StartTime"), startTime);
+}
+

adb/src/model/DescribeDBClusterHealthReportResult.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/adb/model/DescribeDBClusterHealthReportResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Adb;
+using namespace AlibabaCloud::Adb::Model;
+
+DescribeDBClusterHealthReportResult::DescribeDBClusterHealthReportResult() :
+	ServiceResult()
+{}
+
+DescribeDBClusterHealthReportResult::DescribeDBClusterHealthReportResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDBClusterHealthReportResult::~DescribeDBClusterHealthReportResult()
+{}
+
+void DescribeDBClusterHealthReportResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allItemsNode = value["Items"]["ItemsItem"];
+	for (auto valueItemsItemsItem : allItemsNode)
+	{
+		ItemsItem itemsObject;
+		if(!valueItemsItemsItem["Key"].isNull())
+			itemsObject.key = valueItemsItemsItem["Key"].asString();
+		if(!valueItemsItemsItem["Max"].isNull())
+			itemsObject.max = valueItemsItemsItem["Max"].asString();
+		if(!valueItemsItemsItem["Name"].isNull())
+			itemsObject.name = valueItemsItemsItem["Name"].asString();
+		if(!valueItemsItemsItem["Avg"].isNull())
+			itemsObject.avg = valueItemsItemsItem["Avg"].asString();
+		items_.push_back(itemsObject);
+	}
+
+}
+
+std::vector<DescribeDBClusterHealthReportResult::ItemsItem> DescribeDBClusterHealthReportResult::getItems()const
+{
+	return items_;
+}
+

adb/src/model/DescribeDBClusterNetInfoRequest.cc

@@ -1,95 +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/adb/model/DescribeDBClusterNetInfoRequest.h>
-
-using AlibabaCloud::Adb::Model::DescribeDBClusterNetInfoRequest;
-
-DescribeDBClusterNetInfoRequest::DescribeDBClusterNetInfoRequest() :
-	RpcServiceRequest("adb", "2019-03-15", "DescribeDBClusterNetInfo")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeDBClusterNetInfoRequest::~DescribeDBClusterNetInfoRequest()
-{}
-
-long DescribeDBClusterNetInfoRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/adb/model/DescribeDBClusterNetInfoRequest.h>
+
+using AlibabaCloud::Adb::Model::DescribeDBClusterNetInfoRequest;
+
+DescribeDBClusterNetInfoRequest::DescribeDBClusterNetInfoRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DescribeDBClusterNetInfo") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeDBClusterNetInfoRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+DescribeDBClusterNetInfoRequest::~DescribeDBClusterNetInfoRequest() {}
+
+long DescribeDBClusterNetInfoRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string DescribeDBClusterNetInfoRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
+void DescribeDBClusterNetInfoRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void DescribeDBClusterNetInfoRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+std::string DescribeDBClusterNetInfoRequest::getAccessKeyId() const {
+  return accessKeyId_;
 }
 
-std::string DescribeDBClusterNetInfoRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void DescribeDBClusterNetInfoRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-void DescribeDBClusterNetInfoRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string DescribeDBClusterNetInfoRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string DescribeDBClusterNetInfoRequest::getDBClusterId()const
-{
-	return dBClusterId_;
+void DescribeDBClusterNetInfoRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void DescribeDBClusterNetInfoRequest::setDBClusterId(const std::string& dBClusterId)
-{
-	dBClusterId_ = dBClusterId;
-	setParameter("DBClusterId", dBClusterId);
+std::string DescribeDBClusterNetInfoRequest::getDBClusterId() const {
+  return dBClusterId_;
 }
 
-std::string DescribeDBClusterNetInfoRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void DescribeDBClusterNetInfoRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
 }
 
-void DescribeDBClusterNetInfoRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string DescribeDBClusterNetInfoRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long DescribeDBClusterNetInfoRequest::getOwnerId()const
-{
-	return ownerId_;
+void DescribeDBClusterNetInfoRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void DescribeDBClusterNetInfoRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long DescribeDBClusterNetInfoRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DescribeDBClusterNetInfoRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 

adb/src/model/DescribeDBClusterNetInfoResult.cc

@@ -43,18 +43,20 @@ void DescribeDBClusterNetInfoResult::parse(const std::string &payload)
 	for (auto valueItemsAddress : allItemsNode)
 	{
 		Address itemsObject;
+		if(!valueItemsAddress["VSwitchId"].isNull())
+			itemsObject.vSwitchId = valueItemsAddress["VSwitchId"].asString();
 		if(!valueItemsAddress["ConnectionString"].isNull())
 			itemsObject.connectionString = valueItemsAddress["ConnectionString"].asString();
-		if(!valueItemsAddress["IPAddress"].isNull())
-			itemsObject.iPAddress = valueItemsAddress["IPAddress"].asString();
 		if(!valueItemsAddress["NetType"].isNull())
 			itemsObject.netType = valueItemsAddress["NetType"].asString();
 		if(!valueItemsAddress["Port"].isNull())
 			itemsObject.port = valueItemsAddress["Port"].asString();
 		if(!valueItemsAddress["VPCId"].isNull())
 			itemsObject.vPCId = valueItemsAddress["VPCId"].asString();
-		if(!valueItemsAddress["VSwitchId"].isNull())
-			itemsObject.vSwitchId = valueItemsAddress["VSwitchId"].asString();
+		if(!valueItemsAddress["IPAddress"].isNull())
+			itemsObject.iPAddress = valueItemsAddress["IPAddress"].asString();
+		if(!valueItemsAddress["ConnectionStringPrefix"].isNull())
+			itemsObject.connectionStringPrefix = valueItemsAddress["ConnectionStringPrefix"].asString();
 		items_.push_back(itemsObject);
 	}
 	if(!value["ClusterNetworkType"].isNull())

adb/src/model/DescribeDBClusterPerformanceRequest.cc

@@ -1,128 +1,108 @@
 /*
  * 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/adb/model/DescribeDBClusterPerformanceRequest.h>
-
-using AlibabaCloud::Adb::Model::DescribeDBClusterPerformanceRequest;
-
-DescribeDBClusterPerformanceRequest::DescribeDBClusterPerformanceRequest() :
-	RpcServiceRequest("adb", "2019-03-15", "DescribeDBClusterPerformance")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeDBClusterPerformanceRequest::~DescribeDBClusterPerformanceRequest()
-{}
-
-long DescribeDBClusterPerformanceRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/adb/model/DescribeDBClusterPerformanceRequest.h>
+
+using AlibabaCloud::Adb::Model::DescribeDBClusterPerformanceRequest;
+
+DescribeDBClusterPerformanceRequest::DescribeDBClusterPerformanceRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DescribeDBClusterPerformance") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeDBClusterPerformanceRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+DescribeDBClusterPerformanceRequest::~DescribeDBClusterPerformanceRequest() {}
+
+long DescribeDBClusterPerformanceRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string DescribeDBClusterPerformanceRequest::getStartTime()const
-{
-	return startTime_;
+void DescribeDBClusterPerformanceRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void DescribeDBClusterPerformanceRequest::setStartTime(const std::string& startTime)
-{
-	startTime_ = startTime;
-	setParameter("StartTime", startTime);
+std::string DescribeDBClusterPerformanceRequest::getStartTime() const {
+  return startTime_;
 }
 
-std::string DescribeDBClusterPerformanceRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
+void DescribeDBClusterPerformanceRequest::setStartTime(const std::string &startTime) {
+  startTime_ = startTime;
+  setParameter(std::string("StartTime"), startTime);
 }
 
-void DescribeDBClusterPerformanceRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+std::string DescribeDBClusterPerformanceRequest::getAccessKeyId() const {
+  return accessKeyId_;
 }
 
-std::string DescribeDBClusterPerformanceRequest::getKey()const
-{
-	return key_;
+void DescribeDBClusterPerformanceRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-void DescribeDBClusterPerformanceRequest::setKey(const std::string& key)
-{
-	key_ = key;
-	setParameter("Key", key);
+std::string DescribeDBClusterPerformanceRequest::getKey() const {
+  return key_;
 }
 
-std::string DescribeDBClusterPerformanceRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void DescribeDBClusterPerformanceRequest::setKey(const std::string &key) {
+  key_ = key;
+  setParameter(std::string("Key"), key);
 }
 
-void DescribeDBClusterPerformanceRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string DescribeDBClusterPerformanceRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string DescribeDBClusterPerformanceRequest::getDBClusterId()const
-{
-	return dBClusterId_;
+void DescribeDBClusterPerformanceRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void DescribeDBClusterPerformanceRequest::setDBClusterId(const std::string& dBClusterId)
-{
-	dBClusterId_ = dBClusterId;
-	setParameter("DBClusterId", dBClusterId);
+std::string DescribeDBClusterPerformanceRequest::getDBClusterId() const {
+  return dBClusterId_;
 }
 
-std::string DescribeDBClusterPerformanceRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void DescribeDBClusterPerformanceRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
 }
 
-void DescribeDBClusterPerformanceRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string DescribeDBClusterPerformanceRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-std::string DescribeDBClusterPerformanceRequest::getEndTime()const
-{
-	return endTime_;
+void DescribeDBClusterPerformanceRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void DescribeDBClusterPerformanceRequest::setEndTime(const std::string& endTime)
-{
-	endTime_ = endTime;
-	setParameter("EndTime", endTime);
+std::string DescribeDBClusterPerformanceRequest::getEndTime() const {
+  return endTime_;
 }
 
-long DescribeDBClusterPerformanceRequest::getOwnerId()const
-{
-	return ownerId_;
+void DescribeDBClusterPerformanceRequest::setEndTime(const std::string &endTime) {
+  endTime_ = endTime;
+  setParameter(std::string("EndTime"), endTime);
 }
 
-void DescribeDBClusterPerformanceRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long DescribeDBClusterPerformanceRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DescribeDBClusterPerformanceRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 

adb/src/model/DescribeDBClusterPerformanceResult.cc

@@ -60,12 +60,12 @@ void DescribeDBClusterPerformanceResult::parse(const std::string &payload)
 		}
 		performances_.push_back(performancesObject);
 	}
-	if(!value["DBClusterId"].isNull())
-		dBClusterId_ = value["DBClusterId"].asString();
-	if(!value["StartTime"].isNull())
-		startTime_ = value["StartTime"].asString();
 	if(!value["EndTime"].isNull())
 		endTime_ = value["EndTime"].asString();
+	if(!value["StartTime"].isNull())
+		startTime_ = value["StartTime"].asString();
+	if(!value["DBClusterId"].isNull())
+		dBClusterId_ = value["DBClusterId"].asString();
 
 }
 
@@ -74,16 +74,16 @@ std::string DescribeDBClusterPerformanceResult::getEndTime()const
 	return endTime_;
 }
 
-std::string DescribeDBClusterPerformanceResult::getDBClusterId()const
-{
-	return dBClusterId_;
-}
-
 std::string DescribeDBClusterPerformanceResult::getStartTime()const
 {
 	return startTime_;
 }
 
+std::string DescribeDBClusterPerformanceResult::getDBClusterId()const
+{
+	return dBClusterId_;
+}
+
 std::vector<DescribeDBClusterPerformanceResult::PerformanceItem> DescribeDBClusterPerformanceResult::getPerformances()const
 {
 	return performances_;

adb/src/model/DescribeDBClusterResourcePoolPerformanceRequest.cc

@@ -1,139 +1,117 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
-
-#include <alibabacloud/adb/model/DescribeDBClusterResourcePoolPerformanceRequest.h>
-
-using AlibabaCloud::Adb::Model::DescribeDBClusterResourcePoolPerformanceRequest;
-
-DescribeDBClusterResourcePoolPerformanceRequest::DescribeDBClusterResourcePoolPerformanceRequest() :
-	RpcServiceRequest("adb", "2019-03-15", "DescribeDBClusterResourcePoolPerformance")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeDBClusterResourcePoolPerformanceRequest::~DescribeDBClusterResourcePoolPerformanceRequest()
-{}
-
-long DescribeDBClusterResourcePoolPerformanceRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/adb/model/DescribeDBClusterResourcePoolPerformanceRequest.h>
+
+using AlibabaCloud::Adb::Model::DescribeDBClusterResourcePoolPerformanceRequest;
+
+DescribeDBClusterResourcePoolPerformanceRequest::DescribeDBClusterResourcePoolPerformanceRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DescribeDBClusterResourcePoolPerformance") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeDBClusterResourcePoolPerformanceRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+DescribeDBClusterResourcePoolPerformanceRequest::~DescribeDBClusterResourcePoolPerformanceRequest() {}
+
+long DescribeDBClusterResourcePoolPerformanceRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string DescribeDBClusterResourcePoolPerformanceRequest::getStartTime()const
-{
-	return startTime_;
+void DescribeDBClusterResourcePoolPerformanceRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void DescribeDBClusterResourcePoolPerformanceRequest::setStartTime(const std::string& startTime)
-{
-	startTime_ = startTime;
-	setParameter("StartTime", startTime);
+std::string DescribeDBClusterResourcePoolPerformanceRequest::getStartTime() const {
+  return startTime_;
 }
 
-std::string DescribeDBClusterResourcePoolPerformanceRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
+void DescribeDBClusterResourcePoolPerformanceRequest::setStartTime(const std::string &startTime) {
+  startTime_ = startTime;
+  setParameter(std::string("StartTime"), startTime);
 }
 
-void DescribeDBClusterResourcePoolPerformanceRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+std::string DescribeDBClusterResourcePoolPerformanceRequest::getAccessKeyId() const {
+  return accessKeyId_;
 }
 
-std::string DescribeDBClusterResourcePoolPerformanceRequest::getResourcePools()const
-{
-	return resourcePools_;
+void DescribeDBClusterResourcePoolPerformanceRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-void DescribeDBClusterResourcePoolPerformanceRequest::setResourcePools(const std::string& resourcePools)
-{
-	resourcePools_ = resourcePools;
-	setParameter("ResourcePools", resourcePools);
+std::string DescribeDBClusterResourcePoolPerformanceRequest::getResourcePools() const {
+  return resourcePools_;
 }
 
-std::string DescribeDBClusterResourcePoolPerformanceRequest::getKey()const
-{
-	return key_;
+void DescribeDBClusterResourcePoolPerformanceRequest::setResourcePools(const std::string &resourcePools) {
+  resourcePools_ = resourcePools;
+  setParameter(std::string("ResourcePools"), resourcePools);
 }
 
-void DescribeDBClusterResourcePoolPerformanceRequest::setKey(const std::string& key)
-{
-	key_ = key;
-	setParameter("Key", key);
+std::string DescribeDBClusterResourcePoolPerformanceRequest::getKey() const {
+  return key_;
 }
 
-std::string DescribeDBClusterResourcePoolPerformanceRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void DescribeDBClusterResourcePoolPerformanceRequest::setKey(const std::string &key) {
+  key_ = key;
+  setParameter(std::string("Key"), key);
 }
 
-void DescribeDBClusterResourcePoolPerformanceRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string DescribeDBClusterResourcePoolPerformanceRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string DescribeDBClusterResourcePoolPerformanceRequest::getDBClusterId()const
-{
-	return dBClusterId_;
+void DescribeDBClusterResourcePoolPerformanceRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void DescribeDBClusterResourcePoolPerformanceRequest::setDBClusterId(const std::string& dBClusterId)
-{
-	dBClusterId_ = dBClusterId;
-	setParameter("DBClusterId", dBClusterId);
+std::string DescribeDBClusterResourcePoolPerformanceRequest::getDBClusterId() const {
+  return dBClusterId_;
 }
 
-std::string DescribeDBClusterResourcePoolPerformanceRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void DescribeDBClusterResourcePoolPerformanceRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
 }
 
-void DescribeDBClusterResourcePoolPerformanceRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string DescribeDBClusterResourcePoolPerformanceRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-std::string DescribeDBClusterResourcePoolPerformanceRequest::getEndTime()const
-{
-	return endTime_;
+void DescribeDBClusterResourcePoolPerformanceRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void DescribeDBClusterResourcePoolPerformanceRequest::setEndTime(const std::string& endTime)
-{
-	endTime_ = endTime;
-	setParameter("EndTime", endTime);
+std::string DescribeDBClusterResourcePoolPerformanceRequest::getEndTime() const {
+  return endTime_;
 }
 
-long DescribeDBClusterResourcePoolPerformanceRequest::getOwnerId()const
-{
-	return ownerId_;
+void DescribeDBClusterResourcePoolPerformanceRequest::setEndTime(const std::string &endTime) {
+  endTime_ = endTime;
+  setParameter(std::string("EndTime"), endTime);
 }
 
-void DescribeDBClusterResourcePoolPerformanceRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long DescribeDBClusterResourcePoolPerformanceRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DescribeDBClusterResourcePoolPerformanceRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 

adb/src/model/DescribeDBClusterResourcePoolPerformanceResult.cc

@@ -68,12 +68,12 @@ void DescribeDBClusterResourcePoolPerformanceResult::parse(const std::string &pa
 		}
 		performances_.push_back(performancesObject);
 	}
-	if(!value["DBClusterId"].isNull())
-		dBClusterId_ = value["DBClusterId"].asString();
-	if(!value["StartTime"].isNull())
-		startTime_ = value["StartTime"].asString();
 	if(!value["EndTime"].isNull())
 		endTime_ = value["EndTime"].asString();
+	if(!value["StartTime"].isNull())
+		startTime_ = value["StartTime"].asString();
+	if(!value["DBClusterId"].isNull())
+		dBClusterId_ = value["DBClusterId"].asString();
 
 }
 
@@ -82,16 +82,16 @@ std::string DescribeDBClusterResourcePoolPerformanceResult::getEndTime()const
 	return endTime_;
 }
 
-std::string DescribeDBClusterResourcePoolPerformanceResult::getDBClusterId()const
-{
-	return dBClusterId_;
-}
-
 std::string DescribeDBClusterResourcePoolPerformanceResult::getStartTime()const
 {
 	return startTime_;
 }
 
+std::string DescribeDBClusterResourcePoolPerformanceResult::getDBClusterId()const
+{
+	return dBClusterId_;
+}
+
 std::vector<DescribeDBClusterResourcePoolPerformanceResult::PerformanceItem> DescribeDBClusterResourcePoolPerformanceResult::getPerformances()const
 {
 	return performances_;

adb/src/model/DescribeDBClustersRequest.cc

@@ -1,177 +1,149 @@
 /*
  * 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/adb/model/DescribeDBClustersRequest.h>
-
-using AlibabaCloud::Adb::Model::DescribeDBClustersRequest;
-
-DescribeDBClustersRequest::DescribeDBClustersRequest() :
-	RpcServiceRequest("adb", "2019-03-15", "DescribeDBClusters")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeDBClustersRequest::~DescribeDBClustersRequest()
-{}
-
-long DescribeDBClustersRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/adb/model/DescribeDBClustersRequest.h>
+
+using AlibabaCloud::Adb::Model::DescribeDBClustersRequest;
+
+DescribeDBClustersRequest::DescribeDBClustersRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DescribeDBClusters") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeDBClustersRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+DescribeDBClustersRequest::~DescribeDBClustersRequest() {}
+
+long DescribeDBClustersRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string DescribeDBClustersRequest::getDBClusterDescription()const
-{
-	return dBClusterDescription_;
+void DescribeDBClustersRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void DescribeDBClustersRequest::setDBClusterDescription(const std::string& dBClusterDescription)
-{
-	dBClusterDescription_ = dBClusterDescription;
-	setParameter("DBClusterDescription", dBClusterDescription);
+std::string DescribeDBClustersRequest::getDBClusterDescription() const {
+  return dBClusterDescription_;
 }
 
-std::string DescribeDBClustersRequest::getDBClusterStatus()const
-{
-	return dBClusterStatus_;
+void DescribeDBClustersRequest::setDBClusterDescription(const std::string &dBClusterDescription) {
+  dBClusterDescription_ = dBClusterDescription;
+  setParameter(std::string("DBClusterDescription"), dBClusterDescription);
 }
 
-void DescribeDBClustersRequest::setDBClusterStatus(const std::string& dBClusterStatus)
-{
-	dBClusterStatus_ = dBClusterStatus;
-	setParameter("DBClusterStatus", dBClusterStatus);
+std::string DescribeDBClustersRequest::getDBClusterStatus() const {
+  return dBClusterStatus_;
 }
 
-int DescribeDBClustersRequest::getPageNumber()const
-{
-	return pageNumber_;
+void DescribeDBClustersRequest::setDBClusterStatus(const std::string &dBClusterStatus) {
+  dBClusterStatus_ = dBClusterStatus;
+  setParameter(std::string("DBClusterStatus"), dBClusterStatus);
 }
 
-void DescribeDBClustersRequest::setPageNumber(int pageNumber)
-{
-	pageNumber_ = pageNumber;
-	setParameter("PageNumber", std::to_string(pageNumber));
+int DescribeDBClustersRequest::getPageNumber() const {
+  return pageNumber_;
 }
 
-std::string DescribeDBClustersRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
+void DescribeDBClustersRequest::setPageNumber(int pageNumber) {
+  pageNumber_ = pageNumber;
+  setParameter(std::string("PageNumber"), std::to_string(pageNumber));
 }
 
-void DescribeDBClustersRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+std::string DescribeDBClustersRequest::getAccessKeyId() const {
+  return accessKeyId_;
 }
 
-std::string DescribeDBClustersRequest::getResourceGroupId()const
-{
-	return resourceGroupId_;
+void DescribeDBClustersRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-void DescribeDBClustersRequest::setResourceGroupId(const std::string& resourceGroupId)
-{
-	resourceGroupId_ = resourceGroupId;
-	setParameter("ResourceGroupId", resourceGroupId);
+std::string DescribeDBClustersRequest::getResourceGroupId() const {
+  return resourceGroupId_;
 }
 
-std::string DescribeDBClustersRequest::getRegionId()const
-{
-	return regionId_;
+void DescribeDBClustersRequest::setResourceGroupId(const std::string &resourceGroupId) {
+  resourceGroupId_ = resourceGroupId;
+  setParameter(std::string("ResourceGroupId"), resourceGroupId);
 }
 
-void DescribeDBClustersRequest::setRegionId(const std::string& regionId)
-{
-	regionId_ = regionId;
-	setParameter("RegionId", regionId);
+std::string DescribeDBClustersRequest::getRegionId() const {
+  return regionId_;
 }
 
-int DescribeDBClustersRequest::getPageSize()const
-{
-	return pageSize_;
+void DescribeDBClustersRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
 }
 
-void DescribeDBClustersRequest::setPageSize(int pageSize)
-{
-	pageSize_ = pageSize;
-	setParameter("PageSize", std::to_string(pageSize));
+int DescribeDBClustersRequest::getPageSize() const {
+  return pageSize_;
 }
 
-std::vector<DescribeDBClustersRequest::Tag> DescribeDBClustersRequest::getTag()const
-{
-	return tag_;
+void DescribeDBClustersRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
 }
 
-void DescribeDBClustersRequest::setTag(const std::vector<Tag>& tag)
-{
-	tag_ = tag;
-	for(int dep1 = 0; dep1!= tag.size(); dep1++) {
-		auto tagObj = tag.at(dep1);
-		std::string tagObjStr = "Tag." + std::to_string(dep1 + 1);
-		setParameter(tagObjStr + ".Value", tagObj.value);
-		setParameter(tagObjStr + ".Key", tagObj.key);
-	}
+std::vector<DescribeDBClustersRequest::Tag> DescribeDBClustersRequest::getTag() const {
+  return tag_;
 }
 
-std::string DescribeDBClustersRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void DescribeDBClustersRequest::setTag(const std::vector<DescribeDBClustersRequest::Tag> &tag) {
+  tag_ = tag;
+  for(int dep1 = 0; dep1 != tag.size(); dep1++) {
+  auto tagObj = tag.at(dep1);
+  std::string tagObjStr = std::string("Tag") + "." + std::to_string(dep1 + 1);
+    setParameter(tagObjStr + ".Value", tagObj.value);
+    setParameter(tagObjStr + ".Key", tagObj.key);
+  }
 }
 
-void DescribeDBClustersRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string DescribeDBClustersRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string DescribeDBClustersRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void DescribeDBClustersRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void DescribeDBClustersRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string DescribeDBClustersRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long DescribeDBClustersRequest::getOwnerId()const
-{
-	return ownerId_;
+void DescribeDBClustersRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void DescribeDBClustersRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long DescribeDBClustersRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string DescribeDBClustersRequest::getDBClusterIds()const
-{
-	return dBClusterIds_;
+void DescribeDBClustersRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void DescribeDBClustersRequest::setDBClusterIds(const std::string& dBClusterIds)
-{
-	dBClusterIds_ = dBClusterIds;
-	setParameter("DBClusterIds", dBClusterIds);
+std::string DescribeDBClustersRequest::getDBClusterIds() const {
+  return dBClusterIds_;
+}
+
+void DescribeDBClustersRequest::setDBClusterIds(const std::string &dBClusterIds) {
+  dBClusterIds_ = dBClusterIds;
+  setParameter(std::string("DBClusterIds"), dBClusterIds);
 }
 

adb/src/model/DescribeDBClustersResult.cc

@@ -43,74 +43,74 @@ void DescribeDBClustersResult::parse(const std::string &payload)
 	for (auto valueItemsDBCluster : allItemsNode)
 	{
 		DBCluster itemsObject;
-		if(!valueItemsDBCluster["DBClusterId"].isNull())
-			itemsObject.dBClusterId = valueItemsDBCluster["DBClusterId"].asString();
-		if(!valueItemsDBCluster["DBClusterType"].isNull())
-			itemsObject.dBClusterType = valueItemsDBCluster["DBClusterType"].asString();
-		if(!valueItemsDBCluster["DBClusterDescription"].isNull())
-			itemsObject.dBClusterDescription = valueItemsDBCluster["DBClusterDescription"].asString();
-		if(!valueItemsDBCluster["PayType"].isNull())
-			itemsObject.payType = valueItemsDBCluster["PayType"].asString();
-		if(!valueItemsDBCluster["RegionId"].isNull())
-			itemsObject.regionId = valueItemsDBCluster["RegionId"].asString();
-		if(!valueItemsDBCluster["ExpireTime"].isNull())
-			itemsObject.expireTime = valueItemsDBCluster["ExpireTime"].asString();
+		if(!valueItemsDBCluster["DtsJobId"].isNull())
+			itemsObject.dtsJobId = valueItemsDBCluster["DtsJobId"].asString();
+		if(!valueItemsDBCluster["DBNodeCount"].isNull())
+			itemsObject.dBNodeCount = std::stol(valueItemsDBCluster["DBNodeCount"].asString());
 		if(!valueItemsDBCluster["Expired"].isNull())
 			itemsObject.expired = valueItemsDBCluster["Expired"].asString();
-		if(!valueItemsDBCluster["DBClusterStatus"].isNull())
-			itemsObject.dBClusterStatus = valueItemsDBCluster["DBClusterStatus"].asString();
-		if(!valueItemsDBCluster["DBVersion"].isNull())
-			itemsObject.dBVersion = valueItemsDBCluster["DBVersion"].asString();
-		if(!valueItemsDBCluster["LockMode"].isNull())
-			itemsObject.lockMode = valueItemsDBCluster["LockMode"].asString();
-		if(!valueItemsDBCluster["LockReason"].isNull())
-			itemsObject.lockReason = valueItemsDBCluster["LockReason"].asString();
 		if(!valueItemsDBCluster["CreateTime"].isNull())
 			itemsObject.createTime = valueItemsDBCluster["CreateTime"].asString();
+		if(!valueItemsDBCluster["PayType"].isNull())
+			itemsObject.payType = valueItemsDBCluster["PayType"].asString();
+		if(!valueItemsDBCluster["DiskType"].isNull())
+			itemsObject.diskType = valueItemsDBCluster["DiskType"].asString();
+		if(!valueItemsDBCluster["Mode"].isNull())
+			itemsObject.mode = valueItemsDBCluster["Mode"].asString();
+		if(!valueItemsDBCluster["Port"].isNull())
+			itemsObject.port = valueItemsDBCluster["Port"].asString();
+		if(!valueItemsDBCluster["LockMode"].isNull())
+			itemsObject.lockMode = valueItemsDBCluster["LockMode"].asString();
+		if(!valueItemsDBCluster["StorageResource"].isNull())
+			itemsObject.storageResource = valueItemsDBCluster["StorageResource"].asString();
+		if(!valueItemsDBCluster["ExecutorCount"].isNull())
+			itemsObject.executorCount = valueItemsDBCluster["ExecutorCount"].asString();
+		if(!valueItemsDBCluster["DBClusterId"].isNull())
+			itemsObject.dBClusterId = valueItemsDBCluster["DBClusterId"].asString();
+		if(!valueItemsDBCluster["ConnectionString"].isNull())
+			itemsObject.connectionString = valueItemsDBCluster["ConnectionString"].asString();
+		if(!valueItemsDBCluster["RdsInstanceId"].isNull())
+			itemsObject.rdsInstanceId = valueItemsDBCluster["RdsInstanceId"].asString();
+		if(!valueItemsDBCluster["DBClusterType"].isNull())
+			itemsObject.dBClusterType = valueItemsDBCluster["DBClusterType"].asString();
+		if(!valueItemsDBCluster["CommodityCode"].isNull())
+			itemsObject.commodityCode = valueItemsDBCluster["CommodityCode"].asString();
+		if(!valueItemsDBCluster["ExpireTime"].isNull())
+			itemsObject.expireTime = valueItemsDBCluster["ExpireTime"].asString();
 		if(!valueItemsDBCluster["DBNodeStorage"].isNull())
 			itemsObject.dBNodeStorage = std::stol(valueItemsDBCluster["DBNodeStorage"].asString());
 		if(!valueItemsDBCluster["DBNodeClass"].isNull())
 			itemsObject.dBNodeClass = valueItemsDBCluster["DBNodeClass"].asString();
-		if(!valueItemsDBCluster["DBNodeCount"].isNull())
-			itemsObject.dBNodeCount = std::stol(valueItemsDBCluster["DBNodeCount"].asString());
-		if(!valueItemsDBCluster["CommodityCode"].isNull())
-			itemsObject.commodityCode = valueItemsDBCluster["CommodityCode"].asString();
-		if(!valueItemsDBCluster["Category"].isNull())
-			itemsObject.category = valueItemsDBCluster["Category"].asString();
-		if(!valueItemsDBCluster["RdsInstanceId"].isNull())
-			itemsObject.rdsInstanceId = valueItemsDBCluster["RdsInstanceId"].asString();
-		if(!valueItemsDBCluster["DtsJobId"].isNull())
-			itemsObject.dtsJobId = valueItemsDBCluster["DtsJobId"].asString();
-		if(!valueItemsDBCluster["ExecutorCount"].isNull())
-			itemsObject.executorCount = valueItemsDBCluster["ExecutorCount"].asString();
-		if(!valueItemsDBCluster["DiskType"].isNull())
-			itemsObject.diskType = valueItemsDBCluster["DiskType"].asString();
-		if(!valueItemsDBCluster["VPCCloudInstanceId"].isNull())
-			itemsObject.vPCCloudInstanceId = valueItemsDBCluster["VPCCloudInstanceId"].asString();
-		if(!valueItemsDBCluster["Engine"].isNull())
-			itemsObject.engine = valueItemsDBCluster["Engine"].asString();
-		if(!valueItemsDBCluster["DBClusterNetworkType"].isNull())
-			itemsObject.dBClusterNetworkType = valueItemsDBCluster["DBClusterNetworkType"].asString();
+		if(!valueItemsDBCluster["LockReason"].isNull())
+			itemsObject.lockReason = valueItemsDBCluster["LockReason"].asString();
 		if(!valueItemsDBCluster["VPCId"].isNull())
 			itemsObject.vPCId = valueItemsDBCluster["VPCId"].asString();
-		if(!valueItemsDBCluster["VSwitchId"].isNull())
-			itemsObject.vSwitchId = valueItemsDBCluster["VSwitchId"].asString();
-		if(!valueItemsDBCluster["ZoneId"].isNull())
-			itemsObject.zoneId = valueItemsDBCluster["ZoneId"].asString();
-		if(!valueItemsDBCluster["ConnectionString"].isNull())
-			itemsObject.connectionString = valueItemsDBCluster["ConnectionString"].asString();
-		if(!valueItemsDBCluster["Port"].isNull())
-			itemsObject.port = valueItemsDBCluster["Port"].asString();
+		if(!valueItemsDBCluster["RegionId"].isNull())
+			itemsObject.regionId = valueItemsDBCluster["RegionId"].asString();
 		if(!valueItemsDBCluster["ComputeResource"].isNull())
 			itemsObject.computeResource = valueItemsDBCluster["ComputeResource"].asString();
-		if(!valueItemsDBCluster["StorageResource"].isNull())
-			itemsObject.storageResource = valueItemsDBCluster["StorageResource"].asString();
-		if(!valueItemsDBCluster["Mode"].isNull())
-			itemsObject.mode = valueItemsDBCluster["Mode"].asString();
-		if(!valueItemsDBCluster["ResourceGroupId"].isNull())
-			itemsObject.resourceGroupId = valueItemsDBCluster["ResourceGroupId"].asString();
 		if(!valueItemsDBCluster["ElasticIOResource"].isNull())
 			itemsObject.elasticIOResource = std::stoi(valueItemsDBCluster["ElasticIOResource"].asString());
+		if(!valueItemsDBCluster["VSwitchId"].isNull())
+			itemsObject.vSwitchId = valueItemsDBCluster["VSwitchId"].asString();
+		if(!valueItemsDBCluster["DBVersion"].isNull())
+			itemsObject.dBVersion = valueItemsDBCluster["DBVersion"].asString();
+		if(!valueItemsDBCluster["VPCCloudInstanceId"].isNull())
+			itemsObject.vPCCloudInstanceId = valueItemsDBCluster["VPCCloudInstanceId"].asString();
+		if(!valueItemsDBCluster["DBClusterStatus"].isNull())
+			itemsObject.dBClusterStatus = valueItemsDBCluster["DBClusterStatus"].asString();
+		if(!valueItemsDBCluster["ResourceGroupId"].isNull())
+			itemsObject.resourceGroupId = valueItemsDBCluster["ResourceGroupId"].asString();
+		if(!valueItemsDBCluster["DBClusterNetworkType"].isNull())
+			itemsObject.dBClusterNetworkType = valueItemsDBCluster["DBClusterNetworkType"].asString();
+		if(!valueItemsDBCluster["DBClusterDescription"].isNull())
+			itemsObject.dBClusterDescription = valueItemsDBCluster["DBClusterDescription"].asString();
+		if(!valueItemsDBCluster["ZoneId"].isNull())
+			itemsObject.zoneId = valueItemsDBCluster["ZoneId"].asString();
+		if(!valueItemsDBCluster["Category"].isNull())
+			itemsObject.category = valueItemsDBCluster["Category"].asString();
+		if(!valueItemsDBCluster["Engine"].isNull())
+			itemsObject.engine = valueItemsDBCluster["Engine"].asString();
 		auto allTagsNode = valueItemsDBCluster["Tags"]["Tag"];
 		for (auto valueItemsDBClusterTagsTag : allTagsNode)
 		{
@@ -123,12 +123,12 @@ void DescribeDBClustersResult::parse(const std::string &payload)
 		}
 		items_.push_back(itemsObject);
 	}
-	if(!value["PageNumber"].isNull())
-		pageNumber_ = std::stoi(value["PageNumber"].asString());
 	if(!value["TotalCount"].isNull())
 		totalCount_ = std::stoi(value["TotalCount"].asString());
 	if(!value["PageSize"].isNull())
 		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
 
 }
 

adb/src/model/DescribeDBResourceGroupRequest.cc

@@ -0,0 +1,90 @@
+/*
+ * 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/adb/model/DescribeDBResourceGroupRequest.h>
+
+using AlibabaCloud::Adb::Model::DescribeDBResourceGroupRequest;
+
+DescribeDBResourceGroupRequest::DescribeDBResourceGroupRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DescribeDBResourceGroup") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDBResourceGroupRequest::~DescribeDBResourceGroupRequest() {}
+
+long DescribeDBResourceGroupRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void DescribeDBResourceGroupRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+std::string DescribeDBResourceGroupRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void DescribeDBResourceGroupRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+std::string DescribeDBResourceGroupRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void DescribeDBResourceGroupRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string DescribeDBResourceGroupRequest::getDBClusterId() const {
+  return dBClusterId_;
+}
+
+void DescribeDBResourceGroupRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
+}
+
+std::string DescribeDBResourceGroupRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void DescribeDBResourceGroupRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long DescribeDBResourceGroupRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DescribeDBResourceGroupRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string DescribeDBResourceGroupRequest::getGroupName() const {
+  return groupName_;
+}
+
+void DescribeDBResourceGroupRequest::setGroupName(const std::string &groupName) {
+  groupName_ = groupName;
+  setParameter(std::string("GroupName"), groupName);
+}
+

adb/src/model/DescribeDBResourceGroupResult.cc

@@ -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.
+ */
+
+#include <alibabacloud/adb/model/DescribeDBResourceGroupResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Adb;
+using namespace AlibabaCloud::Adb::Model;
+
+DescribeDBResourceGroupResult::DescribeDBResourceGroupResult() :
+	ServiceResult()
+{}
+
+DescribeDBResourceGroupResult::DescribeDBResourceGroupResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDBResourceGroupResult::~DescribeDBResourceGroupResult()
+{}
+
+void DescribeDBResourceGroupResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allGroupsInfoNode = value["GroupsInfo"]["PoolInfo"];
+	for (auto valueGroupsInfoPoolInfo : allGroupsInfoNode)
+	{
+		PoolInfo groupsInfoObject;
+		if(!valueGroupsInfoPoolInfo["GroupType"].isNull())
+			groupsInfoObject.groupType = valueGroupsInfoPoolInfo["GroupType"].asString();
+		if(!valueGroupsInfoPoolInfo["UpdateTime"].isNull())
+			groupsInfoObject.updateTime = valueGroupsInfoPoolInfo["UpdateTime"].asString();
+		if(!valueGroupsInfoPoolInfo["GroupName"].isNull())
+			groupsInfoObject.groupName = valueGroupsInfoPoolInfo["GroupName"].asString();
+		if(!valueGroupsInfoPoolInfo["CreateTime"].isNull())
+			groupsInfoObject.createTime = valueGroupsInfoPoolInfo["CreateTime"].asString();
+		if(!valueGroupsInfoPoolInfo["GroupUsers"].isNull())
+			groupsInfoObject.groupUsers = valueGroupsInfoPoolInfo["GroupUsers"].asString();
+		if(!valueGroupsInfoPoolInfo["NodeNum"].isNull())
+			groupsInfoObject.nodeNum = std::stoi(valueGroupsInfoPoolInfo["NodeNum"].asString());
+		groupsInfo_.push_back(groupsInfoObject);
+	}
+
+}
+
+std::vector<DescribeDBResourceGroupResult::PoolInfo> DescribeDBResourceGroupResult::getGroupsInfo()const
+{
+	return groupsInfo_;
+}
+

adb/src/model/DescribeDBResourcePoolRequest.cc

@@ -1,106 +1,90 @@
 /*
  * 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/adb/model/DescribeDBResourcePoolRequest.h>
-
-using AlibabaCloud::Adb::Model::DescribeDBResourcePoolRequest;
-
-DescribeDBResourcePoolRequest::DescribeDBResourcePoolRequest() :
-	RpcServiceRequest("adb", "2019-03-15", "DescribeDBResourcePool")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeDBResourcePoolRequest::~DescribeDBResourcePoolRequest()
-{}
-
-std::string DescribeDBResourcePoolRequest::getPoolName()const
-{
-	return poolName_;
+ */
+
+#include <alibabacloud/adb/model/DescribeDBResourcePoolRequest.h>
+
+using AlibabaCloud::Adb::Model::DescribeDBResourcePoolRequest;
+
+DescribeDBResourcePoolRequest::DescribeDBResourcePoolRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DescribeDBResourcePool") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeDBResourcePoolRequest::setPoolName(const std::string& poolName)
-{
-	poolName_ = poolName;
-	setParameter("PoolName", poolName);
+DescribeDBResourcePoolRequest::~DescribeDBResourcePoolRequest() {}
+
+std::string DescribeDBResourcePoolRequest::getPoolName() const {
+  return poolName_;
 }
 
-long DescribeDBResourcePoolRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+void DescribeDBResourcePoolRequest::setPoolName(const std::string &poolName) {
+  poolName_ = poolName;
+  setParameter(std::string("PoolName"), poolName);
 }
 
-void DescribeDBResourcePoolRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+long DescribeDBResourcePoolRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string DescribeDBResourcePoolRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
+void DescribeDBResourcePoolRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void DescribeDBResourcePoolRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+std::string DescribeDBResourcePoolRequest::getAccessKeyId() const {
+  return accessKeyId_;
 }
 
-std::string DescribeDBResourcePoolRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void DescribeDBResourcePoolRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-void DescribeDBResourcePoolRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string DescribeDBResourcePoolRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string DescribeDBResourcePoolRequest::getDBClusterId()const
-{
-	return dBClusterId_;
+void DescribeDBResourcePoolRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void DescribeDBResourcePoolRequest::setDBClusterId(const std::string& dBClusterId)
-{
-	dBClusterId_ = dBClusterId;
-	setParameter("DBClusterId", dBClusterId);
+std::string DescribeDBResourcePoolRequest::getDBClusterId() const {
+  return dBClusterId_;
 }
 
-std::string DescribeDBResourcePoolRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void DescribeDBResourcePoolRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
 }
 
-void DescribeDBResourcePoolRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string DescribeDBResourcePoolRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long DescribeDBResourcePoolRequest::getOwnerId()const
-{
-	return ownerId_;
+void DescribeDBResourcePoolRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void DescribeDBResourcePoolRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long DescribeDBResourcePoolRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DescribeDBResourcePoolRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 

adb/src/model/DescribeDBResourcePoolResult.cc

@@ -43,18 +43,18 @@ void DescribeDBResourcePoolResult::parse(const std::string &payload)
 	for (auto valuePoolsInfoPoolInfo : allPoolsInfoNode)
 	{
 		PoolInfo poolsInfoObject;
-		if(!valuePoolsInfoPoolInfo["PoolName"].isNull())
-			poolsInfoObject.poolName = valuePoolsInfoPoolInfo["PoolName"].asString();
 		if(!valuePoolsInfoPoolInfo["QueryType"].isNull())
 			poolsInfoObject.queryType = valuePoolsInfoPoolInfo["QueryType"].asString();
-		if(!valuePoolsInfoPoolInfo["NodeNum"].isNull())
-			poolsInfoObject.nodeNum = std::stoi(valuePoolsInfoPoolInfo["NodeNum"].asString());
-		if(!valuePoolsInfoPoolInfo["PoolUsers"].isNull())
-			poolsInfoObject.poolUsers = valuePoolsInfoPoolInfo["PoolUsers"].asString();
-		if(!valuePoolsInfoPoolInfo["CreateTime"].isNull())
-			poolsInfoObject.createTime = valuePoolsInfoPoolInfo["CreateTime"].asString();
 		if(!valuePoolsInfoPoolInfo["UpdateTime"].isNull())
 			poolsInfoObject.updateTime = valuePoolsInfoPoolInfo["UpdateTime"].asString();
+		if(!valuePoolsInfoPoolInfo["PoolName"].isNull())
+			poolsInfoObject.poolName = valuePoolsInfoPoolInfo["PoolName"].asString();
+		if(!valuePoolsInfoPoolInfo["CreateTime"].isNull())
+			poolsInfoObject.createTime = valuePoolsInfoPoolInfo["CreateTime"].asString();
+		if(!valuePoolsInfoPoolInfo["PoolUsers"].isNull())
+			poolsInfoObject.poolUsers = valuePoolsInfoPoolInfo["PoolUsers"].asString();
+		if(!valuePoolsInfoPoolInfo["NodeNum"].isNull())
+			poolsInfoObject.nodeNum = std::stoi(valuePoolsInfoPoolInfo["NodeNum"].asString());
 		poolsInfo_.push_back(poolsInfoObject);
 	}
 

adb/src/model/DescribeDiagnosisDimensionsRequest.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/adb/model/DescribeDiagnosisDimensionsRequest.h>
+
+using AlibabaCloud::Adb::Model::DescribeDiagnosisDimensionsRequest;
+
+DescribeDiagnosisDimensionsRequest::DescribeDiagnosisDimensionsRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DescribeDiagnosisDimensions") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDiagnosisDimensionsRequest::~DescribeDiagnosisDimensionsRequest() {}
+
+std::string DescribeDiagnosisDimensionsRequest::getDBClusterId() const {
+  return dBClusterId_;
+}
+
+void DescribeDiagnosisDimensionsRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
+}
+
+std::string DescribeDiagnosisDimensionsRequest::getQueryCondition() const {
+  return queryCondition_;
+}
+
+void DescribeDiagnosisDimensionsRequest::setQueryCondition(const std::string &queryCondition) {
+  queryCondition_ = queryCondition;
+  setParameter(std::string("QueryCondition"), queryCondition);
+}
+
+std::string DescribeDiagnosisDimensionsRequest::getEndTime() const {
+  return endTime_;
+}
+
+void DescribeDiagnosisDimensionsRequest::setEndTime(const std::string &endTime) {
+  endTime_ = endTime;
+  setParameter(std::string("EndTime"), endTime);
+}
+
+std::string DescribeDiagnosisDimensionsRequest::getStartTime() const {
+  return startTime_;
+}
+
+void DescribeDiagnosisDimensionsRequest::setStartTime(const std::string &startTime) {
+  startTime_ = startTime;
+  setParameter(std::string("StartTime"), startTime);
+}
+
+std::string DescribeDiagnosisDimensionsRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeDiagnosisDimensionsRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string DescribeDiagnosisDimensionsRequest::getLang() const {
+  return lang_;
+}
+
+void DescribeDiagnosisDimensionsRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
+}
+

adb/src/model/DescribeDiagnosisDimensionsResult.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/adb/model/DescribeDiagnosisDimensionsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Adb;
+using namespace AlibabaCloud::Adb::Model;
+
+DescribeDiagnosisDimensionsResult::DescribeDiagnosisDimensionsResult() :
+	ServiceResult()
+{}
+
+DescribeDiagnosisDimensionsResult::DescribeDiagnosisDimensionsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDiagnosisDimensionsResult::~DescribeDiagnosisDimensionsResult()
+{}
+
+void DescribeDiagnosisDimensionsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allClientIps = value["ClientIps"]["ClientIps"];
+	for (const auto &item : allClientIps)
+		clientIps_.push_back(item.asString());
+	auto allResourceGroups = value["ResourceGroups"]["ResourceGroups"];
+	for (const auto &item : allResourceGroups)
+		resourceGroups_.push_back(item.asString());
+	auto allUserNames = value["UserNames"]["UserNames"];
+	for (const auto &item : allUserNames)
+		userNames_.push_back(item.asString());
+	auto allDatabases = value["Databases"]["Databases"];
+	for (const auto &item : allDatabases)
+		databases_.push_back(item.asString());
+
+}
+
+std::vector<std::string> DescribeDiagnosisDimensionsResult::getClientIps()const
+{
+	return clientIps_;
+}
+
+std::vector<std::string> DescribeDiagnosisDimensionsResult::getDatabases()const
+{
+	return databases_;
+}
+
+std::vector<std::string> DescribeDiagnosisDimensionsResult::getResourceGroups()const
+{
+	return resourceGroups_;
+}
+
+std::vector<std::string> DescribeDiagnosisDimensionsResult::getUserNames()const
+{
+	return userNames_;
+}
+

adb/src/model/DescribeDiagnosisRecordsRequest.cc

@@ -0,0 +1,216 @@
+/*
+ * 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/adb/model/DescribeDiagnosisRecordsRequest.h>
+
+using AlibabaCloud::Adb::Model::DescribeDiagnosisRecordsRequest;
+
+DescribeDiagnosisRecordsRequest::DescribeDiagnosisRecordsRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DescribeDiagnosisRecords") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDiagnosisRecordsRequest::~DescribeDiagnosisRecordsRequest() {}
+
+std::string DescribeDiagnosisRecordsRequest::getQueryCondition() const {
+  return queryCondition_;
+}
+
+void DescribeDiagnosisRecordsRequest::setQueryCondition(const std::string &queryCondition) {
+  queryCondition_ = queryCondition;
+  setParameter(std::string("QueryCondition"), queryCondition);
+}
+
+std::string DescribeDiagnosisRecordsRequest::getStartTime() const {
+  return startTime_;
+}
+
+void DescribeDiagnosisRecordsRequest::setStartTime(const std::string &startTime) {
+  startTime_ = startTime;
+  setParameter(std::string("StartTime"), startTime);
+}
+
+std::string DescribeDiagnosisRecordsRequest::getRawStartTime() const {
+  return rawStartTime_;
+}
+
+void DescribeDiagnosisRecordsRequest::setRawStartTime(const std::string &rawStartTime) {
+  rawStartTime_ = rawStartTime;
+  setParameter(std::string("RawStartTime"), rawStartTime);
+}
+
+int DescribeDiagnosisRecordsRequest::getPageNumber() const {
+  return pageNumber_;
+}
+
+void DescribeDiagnosisRecordsRequest::setPageNumber(int pageNumber) {
+  pageNumber_ = pageNumber;
+  setParameter(std::string("PageNumber"), std::to_string(pageNumber));
+}
+
+std::string DescribeDiagnosisRecordsRequest::getRawEndTime() const {
+  return rawEndTime_;
+}
+
+void DescribeDiagnosisRecordsRequest::setRawEndTime(const std::string &rawEndTime) {
+  rawEndTime_ = rawEndTime;
+  setParameter(std::string("RawEndTime"), rawEndTime);
+}
+
+std::string DescribeDiagnosisRecordsRequest::getDatabase() const {
+  return database_;
+}
+
+void DescribeDiagnosisRecordsRequest::setDatabase(const std::string &database) {
+  database_ = database;
+  setParameter(std::string("Database"), database);
+}
+
+std::string DescribeDiagnosisRecordsRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeDiagnosisRecordsRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string DescribeDiagnosisRecordsRequest::getClientIp() const {
+  return clientIp_;
+}
+
+void DescribeDiagnosisRecordsRequest::setClientIp(const std::string &clientIp) {
+  clientIp_ = clientIp;
+  setParameter(std::string("ClientIp"), clientIp);
+}
+
+int DescribeDiagnosisRecordsRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void DescribeDiagnosisRecordsRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+
+std::string DescribeDiagnosisRecordsRequest::getKeyword() const {
+  return keyword_;
+}
+
+void DescribeDiagnosisRecordsRequest::setKeyword(const std::string &keyword) {
+  keyword_ = keyword;
+  setParameter(std::string("Keyword"), keyword);
+}
+
+std::string DescribeDiagnosisRecordsRequest::getLang() const {
+  return lang_;
+}
+
+void DescribeDiagnosisRecordsRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
+}
+
+std::string DescribeDiagnosisRecordsRequest::getOrder() const {
+  return order_;
+}
+
+void DescribeDiagnosisRecordsRequest::setOrder(const std::string &order) {
+  order_ = order;
+  setParameter(std::string("Order"), order);
+}
+
+long DescribeDiagnosisRecordsRequest::getMaxScanSize() const {
+  return maxScanSize_;
+}
+
+void DescribeDiagnosisRecordsRequest::setMaxScanSize(long maxScanSize) {
+  maxScanSize_ = maxScanSize;
+  setParameter(std::string("MaxScanSize"), std::to_string(maxScanSize));
+}
+
+std::string DescribeDiagnosisRecordsRequest::getResourceGroup() const {
+  return resourceGroup_;
+}
+
+void DescribeDiagnosisRecordsRequest::setResourceGroup(const std::string &resourceGroup) {
+  resourceGroup_ = resourceGroup;
+  setParameter(std::string("ResourceGroup"), resourceGroup);
+}
+
+std::string DescribeDiagnosisRecordsRequest::getDBClusterId() const {
+  return dBClusterId_;
+}
+
+void DescribeDiagnosisRecordsRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
+}
+
+long DescribeDiagnosisRecordsRequest::getPatternId() const {
+  return patternId_;
+}
+
+void DescribeDiagnosisRecordsRequest::setPatternId(long patternId) {
+  patternId_ = patternId;
+  setParameter(std::string("PatternId"), std::to_string(patternId));
+}
+
+std::string DescribeDiagnosisRecordsRequest::getEndTime() const {
+  return endTime_;
+}
+
+void DescribeDiagnosisRecordsRequest::setEndTime(const std::string &endTime) {
+  endTime_ = endTime;
+  setParameter(std::string("EndTime"), endTime);
+}
+
+long DescribeDiagnosisRecordsRequest::getMinPeakMemory() const {
+  return minPeakMemory_;
+}
+
+void DescribeDiagnosisRecordsRequest::setMinPeakMemory(long minPeakMemory) {
+  minPeakMemory_ = minPeakMemory;
+  setParameter(std::string("MinPeakMemory"), std::to_string(minPeakMemory));
+}
+
+long DescribeDiagnosisRecordsRequest::getMinScanSize() const {
+  return minScanSize_;
+}
+
+void DescribeDiagnosisRecordsRequest::setMinScanSize(long minScanSize) {
+  minScanSize_ = minScanSize;
+  setParameter(std::string("MinScanSize"), std::to_string(minScanSize));
+}
+
+long DescribeDiagnosisRecordsRequest::getMaxPeakMemory() const {
+  return maxPeakMemory_;
+}
+
+void DescribeDiagnosisRecordsRequest::setMaxPeakMemory(long maxPeakMemory) {
+  maxPeakMemory_ = maxPeakMemory;
+  setParameter(std::string("MaxPeakMemory"), std::to_string(maxPeakMemory));
+}
+
+std::string DescribeDiagnosisRecordsRequest::getUserName() const {
+  return userName_;
+}
+
+void DescribeDiagnosisRecordsRequest::setUserName(const std::string &userName) {
+  userName_ = userName;
+  setParameter(std::string("UserName"), userName);
+}
+

adb/src/model/DescribeDiagnosisRecordsResult.cc

@@ -0,0 +1,122 @@
+/*
+ * 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/adb/model/DescribeDiagnosisRecordsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Adb;
+using namespace AlibabaCloud::Adb::Model;
+
+DescribeDiagnosisRecordsResult::DescribeDiagnosisRecordsResult() :
+	ServiceResult()
+{}
+
+DescribeDiagnosisRecordsResult::DescribeDiagnosisRecordsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDiagnosisRecordsResult::~DescribeDiagnosisRecordsResult()
+{}
+
+void DescribeDiagnosisRecordsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allQuerysNode = value["Querys"]["Items"];
+	for (auto valueQuerysItems : allQuerysNode)
+	{
+		Items querysObject;
+		if(!valueQuerysItems["SQL"].isNull())
+			querysObject.sQL = valueQuerysItems["SQL"].asString();
+		if(!valueQuerysItems["SQLTruncatedThreshold"].isNull())
+			querysObject.sQLTruncatedThreshold = std::stol(valueQuerysItems["SQLTruncatedThreshold"].asString());
+		if(!valueQuerysItems["Status"].isNull())
+			querysObject.status = valueQuerysItems["Status"].asString();
+		if(!valueQuerysItems["OutputDataSize"].isNull())
+			querysObject.outputDataSize = std::stol(valueQuerysItems["OutputDataSize"].asString());
+		if(!valueQuerysItems["Cost"].isNull())
+			querysObject.cost = std::stol(valueQuerysItems["Cost"].asString());
+		if(!valueQuerysItems["OutputRows"].isNull())
+			querysObject.outputRows = std::stol(valueQuerysItems["OutputRows"].asString());
+		if(!valueQuerysItems["RcHost"].isNull())
+			querysObject.rcHost = valueQuerysItems["RcHost"].asString();
+		if(!valueQuerysItems["ScanSize"].isNull())
+			querysObject.scanSize = std::stol(valueQuerysItems["ScanSize"].asString());
+		if(!valueQuerysItems["ProcessId"].isNull())
+			querysObject.processId = valueQuerysItems["ProcessId"].asString();
+		if(!valueQuerysItems["StartTime"].isNull())
+			querysObject.startTime = std::stol(valueQuerysItems["StartTime"].asString());
+		if(!valueQuerysItems["SQLTruncated"].isNull())
+			querysObject.sQLTruncated = valueQuerysItems["SQLTruncated"].asString() == "true";
+		if(!valueQuerysItems["Database"].isNull())
+			querysObject.database = valueQuerysItems["Database"].asString();
+		if(!valueQuerysItems["ScanRows"].isNull())
+			querysObject.scanRows = std::stol(valueQuerysItems["ScanRows"].asString());
+		if(!valueQuerysItems["ResourceCostRank"].isNull())
+			querysObject.resourceCostRank = std::stoi(valueQuerysItems["ResourceCostRank"].asString());
+		if(!valueQuerysItems["ClientIp"].isNull())
+			querysObject.clientIp = valueQuerysItems["ClientIp"].asString();
+		if(!valueQuerysItems["PeakMemory"].isNull())
+			querysObject.peakMemory = std::stol(valueQuerysItems["PeakMemory"].asString());
+		if(!valueQuerysItems["QueueTime"].isNull())
+			querysObject.queueTime = std::stol(valueQuerysItems["QueueTime"].asString());
+		if(!valueQuerysItems["ResourceGroup"].isNull())
+			querysObject.resourceGroup = valueQuerysItems["ResourceGroup"].asString();
+		if(!valueQuerysItems["UserName"].isNull())
+			querysObject.userName = valueQuerysItems["UserName"].asString();
+		if(!valueQuerysItems["ExecutionTime"].isNull())
+			querysObject.executionTime = std::stol(valueQuerysItems["ExecutionTime"].asString());
+		if(!valueQuerysItems["TotalPlanningTime"].isNull())
+			querysObject.totalPlanningTime = std::stol(valueQuerysItems["TotalPlanningTime"].asString());
+		if(!valueQuerysItems["EtlWriteRows"].isNull())
+			querysObject.etlWriteRows = std::stol(valueQuerysItems["EtlWriteRows"].asString());
+		if(!valueQuerysItems["TotalStages"].isNull())
+			querysObject.totalStages = std::stoi(valueQuerysItems["TotalStages"].asString());
+		querys_.push_back(querysObject);
+	}
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
+
+}
+
+int DescribeDiagnosisRecordsResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+std::vector<DescribeDiagnosisRecordsResult::Items> DescribeDiagnosisRecordsResult::getQuerys()const
+{
+	return querys_;
+}
+
+int DescribeDiagnosisRecordsResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int DescribeDiagnosisRecordsResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+

adb/src/model/DescribeDownloadRecordsRequest.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/adb/model/DescribeDownloadRecordsRequest.h>
+
+using AlibabaCloud::Adb::Model::DescribeDownloadRecordsRequest;
+
+DescribeDownloadRecordsRequest::DescribeDownloadRecordsRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DescribeDownloadRecords") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDownloadRecordsRequest::~DescribeDownloadRecordsRequest() {}
+
+std::string DescribeDownloadRecordsRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeDownloadRecordsRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string DescribeDownloadRecordsRequest::getDBClusterId() const {
+  return dBClusterId_;
+}
+
+void DescribeDownloadRecordsRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
+}
+
+std::string DescribeDownloadRecordsRequest::getLang() const {
+  return lang_;
+}
+
+void DescribeDownloadRecordsRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
+}
+

adb/src/model/DescribeDownloadRecordsResult.cc

@@ -0,0 +1,65 @@
+/*
+ * 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/adb/model/DescribeDownloadRecordsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Adb;
+using namespace AlibabaCloud::Adb::Model;
+
+DescribeDownloadRecordsResult::DescribeDownloadRecordsResult() :
+	ServiceResult()
+{}
+
+DescribeDownloadRecordsResult::DescribeDownloadRecordsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDownloadRecordsResult::~DescribeDownloadRecordsResult()
+{}
+
+void DescribeDownloadRecordsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allRecordsNode = value["Records"]["Items"];
+	for (auto valueRecordsItems : allRecordsNode)
+	{
+		Items recordsObject;
+		if(!valueRecordsItems["Status"].isNull())
+			recordsObject.status = valueRecordsItems["Status"].asString();
+		if(!valueRecordsItems["DownloadId"].isNull())
+			recordsObject.downloadId = std::stol(valueRecordsItems["DownloadId"].asString());
+		if(!valueRecordsItems["ExceptionMsg"].isNull())
+			recordsObject.exceptionMsg = valueRecordsItems["ExceptionMsg"].asString();
+		if(!valueRecordsItems["Url"].isNull())
+			recordsObject.url = valueRecordsItems["Url"].asString();
+		if(!valueRecordsItems["FileName"].isNull())
+			recordsObject.fileName = valueRecordsItems["FileName"].asString();
+		records_.push_back(recordsObject);
+	}
+
+}
+
+std::vector<DescribeDownloadRecordsResult::Items> DescribeDownloadRecordsResult::getRecords()const
+{
+	return records_;
+}
+

adb/src/model/DescribeElasticDailyPlanRequest.cc

@@ -1,139 +1,117 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
-
-#include <alibabacloud/adb/model/DescribeElasticDailyPlanRequest.h>
-
-using AlibabaCloud::Adb::Model::DescribeElasticDailyPlanRequest;
-
-DescribeElasticDailyPlanRequest::DescribeElasticDailyPlanRequest() :
-	RpcServiceRequest("adb", "2019-03-15", "DescribeElasticDailyPlan")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeElasticDailyPlanRequest::~DescribeElasticDailyPlanRequest()
-{}
-
-long DescribeElasticDailyPlanRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/adb/model/DescribeElasticDailyPlanRequest.h>
+
+using AlibabaCloud::Adb::Model::DescribeElasticDailyPlanRequest;
+
+DescribeElasticDailyPlanRequest::DescribeElasticDailyPlanRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DescribeElasticDailyPlan") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeElasticDailyPlanRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+DescribeElasticDailyPlanRequest::~DescribeElasticDailyPlanRequest() {}
+
+long DescribeElasticDailyPlanRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string DescribeElasticDailyPlanRequest::getElasticDailyPlanStatusList()const
-{
-	return elasticDailyPlanStatusList_;
+void DescribeElasticDailyPlanRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void DescribeElasticDailyPlanRequest::setElasticDailyPlanStatusList(const std::string& elasticDailyPlanStatusList)
-{
-	elasticDailyPlanStatusList_ = elasticDailyPlanStatusList;
-	setParameter("ElasticDailyPlanStatusList", elasticDailyPlanStatusList);
+std::string DescribeElasticDailyPlanRequest::getElasticDailyPlanStatusList() const {
+  return elasticDailyPlanStatusList_;
 }
 
-std::string DescribeElasticDailyPlanRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
+void DescribeElasticDailyPlanRequest::setElasticDailyPlanStatusList(const std::string &elasticDailyPlanStatusList) {
+  elasticDailyPlanStatusList_ = elasticDailyPlanStatusList;
+  setParameter(std::string("ElasticDailyPlanStatusList"), elasticDailyPlanStatusList);
 }
 
-void DescribeElasticDailyPlanRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+std::string DescribeElasticDailyPlanRequest::getAccessKeyId() const {
+  return accessKeyId_;
 }
 
-std::string DescribeElasticDailyPlanRequest::getElasticDailyPlanDay()const
-{
-	return elasticDailyPlanDay_;
+void DescribeElasticDailyPlanRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-void DescribeElasticDailyPlanRequest::setElasticDailyPlanDay(const std::string& elasticDailyPlanDay)
-{
-	elasticDailyPlanDay_ = elasticDailyPlanDay;
-	setParameter("ElasticDailyPlanDay", elasticDailyPlanDay);
+std::string DescribeElasticDailyPlanRequest::getElasticDailyPlanDay() const {
+  return elasticDailyPlanDay_;
 }
 
-std::string DescribeElasticDailyPlanRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void DescribeElasticDailyPlanRequest::setElasticDailyPlanDay(const std::string &elasticDailyPlanDay) {
+  elasticDailyPlanDay_ = elasticDailyPlanDay;
+  setParameter(std::string("ElasticDailyPlanDay"), elasticDailyPlanDay);
 }
 
-void DescribeElasticDailyPlanRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string DescribeElasticDailyPlanRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string DescribeElasticDailyPlanRequest::getDBClusterId()const
-{
-	return dBClusterId_;
+void DescribeElasticDailyPlanRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void DescribeElasticDailyPlanRequest::setDBClusterId(const std::string& dBClusterId)
-{
-	dBClusterId_ = dBClusterId;
-	setParameter("DBClusterId", dBClusterId);
+std::string DescribeElasticDailyPlanRequest::getDBClusterId() const {
+  return dBClusterId_;
 }
 
-std::string DescribeElasticDailyPlanRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void DescribeElasticDailyPlanRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
 }
 
-void DescribeElasticDailyPlanRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string DescribeElasticDailyPlanRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long DescribeElasticDailyPlanRequest::getOwnerId()const
-{
-	return ownerId_;
+void DescribeElasticDailyPlanRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void DescribeElasticDailyPlanRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long DescribeElasticDailyPlanRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string DescribeElasticDailyPlanRequest::getElasticPlanName()const
-{
-	return elasticPlanName_;
+void DescribeElasticDailyPlanRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void DescribeElasticDailyPlanRequest::setElasticPlanName(const std::string& elasticPlanName)
-{
-	elasticPlanName_ = elasticPlanName;
-	setParameter("ElasticPlanName", elasticPlanName);
+std::string DescribeElasticDailyPlanRequest::getElasticPlanName() const {
+  return elasticPlanName_;
 }
 
-std::string DescribeElasticDailyPlanRequest::getResourcePoolName()const
-{
-	return resourcePoolName_;
+void DescribeElasticDailyPlanRequest::setElasticPlanName(const std::string &elasticPlanName) {
+  elasticPlanName_ = elasticPlanName;
+  setParameter(std::string("ElasticPlanName"), elasticPlanName);
 }
 
-void DescribeElasticDailyPlanRequest::setResourcePoolName(const std::string& resourcePoolName)
-{
-	resourcePoolName_ = resourcePoolName;
-	setParameter("ResourcePoolName", resourcePoolName);
+std::string DescribeElasticDailyPlanRequest::getResourcePoolName() const {
+  return resourcePoolName_;
+}
+
+void DescribeElasticDailyPlanRequest::setResourcePoolName(const std::string &resourcePoolName) {
+  resourcePoolName_ = resourcePoolName;
+  setParameter(std::string("ResourcePoolName"), resourcePoolName);
 }
 

adb/src/model/DescribeElasticDailyPlanResult.cc

@@ -43,24 +43,24 @@ void DescribeElasticDailyPlanResult::parse(const std::string &payload)
 	for (auto valueElasticDailyPlanListElasticDailyPlanInfo : allElasticDailyPlanListNode)
 	{
 		ElasticDailyPlanInfo elasticDailyPlanListObject;
-		if(!valueElasticDailyPlanListElasticDailyPlanInfo["PlanName"].isNull())
-			elasticDailyPlanListObject.planName = valueElasticDailyPlanListElasticDailyPlanInfo["PlanName"].asString();
-		if(!valueElasticDailyPlanListElasticDailyPlanInfo["ResourcePoolName"].isNull())
-			elasticDailyPlanListObject.resourcePoolName = valueElasticDailyPlanListElasticDailyPlanInfo["ResourcePoolName"].asString();
-		if(!valueElasticDailyPlanListElasticDailyPlanInfo["ElasticNodeNum"].isNull())
-			elasticDailyPlanListObject.elasticNodeNum = std::stoi(valueElasticDailyPlanListElasticDailyPlanInfo["ElasticNodeNum"].asString());
-		if(!valueElasticDailyPlanListElasticDailyPlanInfo["PlanStartTs"].isNull())
-			elasticDailyPlanListObject.planStartTs = valueElasticDailyPlanListElasticDailyPlanInfo["PlanStartTs"].asString();
-		if(!valueElasticDailyPlanListElasticDailyPlanInfo["PlanEndTs"].isNull())
-			elasticDailyPlanListObject.planEndTs = valueElasticDailyPlanListElasticDailyPlanInfo["PlanEndTs"].asString();
-		if(!valueElasticDailyPlanListElasticDailyPlanInfo["StartTs"].isNull())
-			elasticDailyPlanListObject.startTs = valueElasticDailyPlanListElasticDailyPlanInfo["StartTs"].asString();
-		if(!valueElasticDailyPlanListElasticDailyPlanInfo["EndTs"].isNull())
-			elasticDailyPlanListObject.endTs = valueElasticDailyPlanListElasticDailyPlanInfo["EndTs"].asString();
-		if(!valueElasticDailyPlanListElasticDailyPlanInfo["Day"].isNull())
-			elasticDailyPlanListObject.day = valueElasticDailyPlanListElasticDailyPlanInfo["Day"].asString();
 		if(!valueElasticDailyPlanListElasticDailyPlanInfo["Status"].isNull())
 			elasticDailyPlanListObject.status = std::stoi(valueElasticDailyPlanListElasticDailyPlanInfo["Status"].asString());
+		if(!valueElasticDailyPlanListElasticDailyPlanInfo["Day"].isNull())
+			elasticDailyPlanListObject.day = valueElasticDailyPlanListElasticDailyPlanInfo["Day"].asString();
+		if(!valueElasticDailyPlanListElasticDailyPlanInfo["ResourcePoolName"].isNull())
+			elasticDailyPlanListObject.resourcePoolName = valueElasticDailyPlanListElasticDailyPlanInfo["ResourcePoolName"].asString();
+		if(!valueElasticDailyPlanListElasticDailyPlanInfo["StartTs"].isNull())
+			elasticDailyPlanListObject.startTs = valueElasticDailyPlanListElasticDailyPlanInfo["StartTs"].asString();
+		if(!valueElasticDailyPlanListElasticDailyPlanInfo["PlanEndTs"].isNull())
+			elasticDailyPlanListObject.planEndTs = valueElasticDailyPlanListElasticDailyPlanInfo["PlanEndTs"].asString();
+		if(!valueElasticDailyPlanListElasticDailyPlanInfo["PlanStartTs"].isNull())
+			elasticDailyPlanListObject.planStartTs = valueElasticDailyPlanListElasticDailyPlanInfo["PlanStartTs"].asString();
+		if(!valueElasticDailyPlanListElasticDailyPlanInfo["ElasticNodeNum"].isNull())
+			elasticDailyPlanListObject.elasticNodeNum = std::stoi(valueElasticDailyPlanListElasticDailyPlanInfo["ElasticNodeNum"].asString());
+		if(!valueElasticDailyPlanListElasticDailyPlanInfo["EndTs"].isNull())
+			elasticDailyPlanListObject.endTs = valueElasticDailyPlanListElasticDailyPlanInfo["EndTs"].asString();
+		if(!valueElasticDailyPlanListElasticDailyPlanInfo["PlanName"].isNull())
+			elasticDailyPlanListObject.planName = valueElasticDailyPlanListElasticDailyPlanInfo["PlanName"].asString();
 		elasticDailyPlanList_.push_back(elasticDailyPlanListObject);
 	}
 

adb/src/model/DescribeElasticPlanRequest.cc

@@ -1,128 +1,108 @@
 /*
  * 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/adb/model/DescribeElasticPlanRequest.h>
-
-using AlibabaCloud::Adb::Model::DescribeElasticPlanRequest;
-
-DescribeElasticPlanRequest::DescribeElasticPlanRequest() :
-	RpcServiceRequest("adb", "2019-03-15", "DescribeElasticPlan")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeElasticPlanRequest::~DescribeElasticPlanRequest()
-{}
-
-long DescribeElasticPlanRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/adb/model/DescribeElasticPlanRequest.h>
+
+using AlibabaCloud::Adb::Model::DescribeElasticPlanRequest;
+
+DescribeElasticPlanRequest::DescribeElasticPlanRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DescribeElasticPlan") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeElasticPlanRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+DescribeElasticPlanRequest::~DescribeElasticPlanRequest() {}
+
+long DescribeElasticPlanRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string DescribeElasticPlanRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
+void DescribeElasticPlanRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void DescribeElasticPlanRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+std::string DescribeElasticPlanRequest::getAccessKeyId() const {
+  return accessKeyId_;
 }
 
-bool DescribeElasticPlanRequest::getElasticPlanEnable()const
-{
-	return elasticPlanEnable_;
+void DescribeElasticPlanRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-void DescribeElasticPlanRequest::setElasticPlanEnable(bool elasticPlanEnable)
-{
-	elasticPlanEnable_ = elasticPlanEnable;
-	setParameter("ElasticPlanEnable", elasticPlanEnable ? "true" : "false");
+bool DescribeElasticPlanRequest::getElasticPlanEnable() const {
+  return elasticPlanEnable_;
 }
 
-std::string DescribeElasticPlanRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void DescribeElasticPlanRequest::setElasticPlanEnable(bool elasticPlanEnable) {
+  elasticPlanEnable_ = elasticPlanEnable;
+  setParameter(std::string("ElasticPlanEnable"), elasticPlanEnable ? "true" : "false");
 }
 
-void DescribeElasticPlanRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string DescribeElasticPlanRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string DescribeElasticPlanRequest::getDBClusterId()const
-{
-	return dBClusterId_;
+void DescribeElasticPlanRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void DescribeElasticPlanRequest::setDBClusterId(const std::string& dBClusterId)
-{
-	dBClusterId_ = dBClusterId;
-	setParameter("DBClusterId", dBClusterId);
+std::string DescribeElasticPlanRequest::getDBClusterId() const {
+  return dBClusterId_;
 }
 
-std::string DescribeElasticPlanRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void DescribeElasticPlanRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
 }
 
-void DescribeElasticPlanRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string DescribeElasticPlanRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long DescribeElasticPlanRequest::getOwnerId()const
-{
-	return ownerId_;
+void DescribeElasticPlanRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void DescribeElasticPlanRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long DescribeElasticPlanRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string DescribeElasticPlanRequest::getElasticPlanName()const
-{
-	return elasticPlanName_;
+void DescribeElasticPlanRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void DescribeElasticPlanRequest::setElasticPlanName(const std::string& elasticPlanName)
-{
-	elasticPlanName_ = elasticPlanName;
-	setParameter("ElasticPlanName", elasticPlanName);
+std::string DescribeElasticPlanRequest::getElasticPlanName() const {
+  return elasticPlanName_;
 }
 
-std::string DescribeElasticPlanRequest::getResourcePoolName()const
-{
-	return resourcePoolName_;
+void DescribeElasticPlanRequest::setElasticPlanName(const std::string &elasticPlanName) {
+  elasticPlanName_ = elasticPlanName;
+  setParameter(std::string("ElasticPlanName"), elasticPlanName);
 }
 
-void DescribeElasticPlanRequest::setResourcePoolName(const std::string& resourcePoolName)
-{
-	resourcePoolName_ = resourcePoolName;
-	setParameter("ResourcePoolName", resourcePoolName);
+std::string DescribeElasticPlanRequest::getResourcePoolName() const {
+  return resourcePoolName_;
+}
+
+void DescribeElasticPlanRequest::setResourcePoolName(const std::string &resourcePoolName) {
+  resourcePoolName_ = resourcePoolName;
+  setParameter(std::string("ResourcePoolName"), resourcePoolName);
 }
 

adb/src/model/DescribeElasticPlanResult.cc

@@ -43,24 +43,24 @@ void DescribeElasticPlanResult::parse(const std::string &payload)
 	for (auto valueElasticPlanListElasticPlanInfo : allElasticPlanListNode)
 	{
 		ElasticPlanInfo elasticPlanListObject;
-		if(!valueElasticPlanListElasticPlanInfo["PlanName"].isNull())
-			elasticPlanListObject.planName = valueElasticPlanListElasticPlanInfo["PlanName"].asString();
-		if(!valueElasticPlanListElasticPlanInfo["ResourcePoolName"].isNull())
-			elasticPlanListObject.resourcePoolName = valueElasticPlanListElasticPlanInfo["ResourcePoolName"].asString();
-		if(!valueElasticPlanListElasticPlanInfo["ElasticNodeNum"].isNull())
-			elasticPlanListObject.elasticNodeNum = std::stoi(valueElasticPlanListElasticPlanInfo["ElasticNodeNum"].asString());
-		if(!valueElasticPlanListElasticPlanInfo["StartTime"].isNull())
-			elasticPlanListObject.startTime = valueElasticPlanListElasticPlanInfo["StartTime"].asString();
 		if(!valueElasticPlanListElasticPlanInfo["EndTime"].isNull())
 			elasticPlanListObject.endTime = valueElasticPlanListElasticPlanInfo["EndTime"].asString();
 		if(!valueElasticPlanListElasticPlanInfo["WeeklyRepeat"].isNull())
 			elasticPlanListObject.weeklyRepeat = valueElasticPlanListElasticPlanInfo["WeeklyRepeat"].asString();
+		if(!valueElasticPlanListElasticPlanInfo["StartTime"].isNull())
+			elasticPlanListObject.startTime = valueElasticPlanListElasticPlanInfo["StartTime"].asString();
+		if(!valueElasticPlanListElasticPlanInfo["ResourcePoolName"].isNull())
+			elasticPlanListObject.resourcePoolName = valueElasticPlanListElasticPlanInfo["ResourcePoolName"].asString();
 		if(!valueElasticPlanListElasticPlanInfo["StartDay"].isNull())
 			elasticPlanListObject.startDay = valueElasticPlanListElasticPlanInfo["StartDay"].asString();
-		if(!valueElasticPlanListElasticPlanInfo["EndDay"].isNull())
-			elasticPlanListObject.endDay = valueElasticPlanListElasticPlanInfo["EndDay"].asString();
+		if(!valueElasticPlanListElasticPlanInfo["ElasticNodeNum"].isNull())
+			elasticPlanListObject.elasticNodeNum = std::stoi(valueElasticPlanListElasticPlanInfo["ElasticNodeNum"].asString());
 		if(!valueElasticPlanListElasticPlanInfo["Enable"].isNull())
 			elasticPlanListObject.enable = valueElasticPlanListElasticPlanInfo["Enable"].asString() == "true";
+		if(!valueElasticPlanListElasticPlanInfo["EndDay"].isNull())
+			elasticPlanListObject.endDay = valueElasticPlanListElasticPlanInfo["EndDay"].asString();
+		if(!valueElasticPlanListElasticPlanInfo["PlanName"].isNull())
+			elasticPlanListObject.planName = valueElasticPlanListElasticPlanInfo["PlanName"].asString();
 		elasticPlanList_.push_back(elasticPlanListObject);
 	}
 

adb/src/model/DescribeInclinedTablesRequest.cc

@@ -1,139 +1,117 @@
 /*
  * Copyright 2009-2017 Alibaba Cloud All rights reserved.
- * 
+ *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
- * 
+ *
  *      http://www.apache.org/licenses/LICENSE-2.0
- * 
+ *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
- */
-
-#include <alibabacloud/adb/model/DescribeInclinedTablesRequest.h>
-
-using AlibabaCloud::Adb::Model::DescribeInclinedTablesRequest;
-
-DescribeInclinedTablesRequest::DescribeInclinedTablesRequest() :
-	RpcServiceRequest("adb", "2019-03-15", "DescribeInclinedTables")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeInclinedTablesRequest::~DescribeInclinedTablesRequest()
-{}
-
-std::string DescribeInclinedTablesRequest::getTableType()const
-{
-	return tableType_;
+ */
+
+#include <alibabacloud/adb/model/DescribeInclinedTablesRequest.h>
+
+using AlibabaCloud::Adb::Model::DescribeInclinedTablesRequest;
+
+DescribeInclinedTablesRequest::DescribeInclinedTablesRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DescribeInclinedTables") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeInclinedTablesRequest::setTableType(const std::string& tableType)
-{
-	tableType_ = tableType;
-	setParameter("TableType", tableType);
+DescribeInclinedTablesRequest::~DescribeInclinedTablesRequest() {}
+
+std::string DescribeInclinedTablesRequest::getTableType() const {
+  return tableType_;
 }
 
-long DescribeInclinedTablesRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+void DescribeInclinedTablesRequest::setTableType(const std::string &tableType) {
+  tableType_ = tableType;
+  setParameter(std::string("TableType"), tableType);
 }
 
-void DescribeInclinedTablesRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+long DescribeInclinedTablesRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-int DescribeInclinedTablesRequest::getPageNumber()const
-{
-	return pageNumber_;
+void DescribeInclinedTablesRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void DescribeInclinedTablesRequest::setPageNumber(int pageNumber)
-{
-	pageNumber_ = pageNumber;
-	setParameter("PageNumber", std::to_string(pageNumber));
+int DescribeInclinedTablesRequest::getPageNumber() const {
+  return pageNumber_;
 }
 
-std::string DescribeInclinedTablesRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
+void DescribeInclinedTablesRequest::setPageNumber(int pageNumber) {
+  pageNumber_ = pageNumber;
+  setParameter(std::string("PageNumber"), std::to_string(pageNumber));
 }
 
-void DescribeInclinedTablesRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+std::string DescribeInclinedTablesRequest::getAccessKeyId() const {
+  return accessKeyId_;
 }
 
-int DescribeInclinedTablesRequest::getPageSize()const
-{
-	return pageSize_;
+void DescribeInclinedTablesRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-void DescribeInclinedTablesRequest::setPageSize(int pageSize)
-{
-	pageSize_ = pageSize;
-	setParameter("PageSize", std::to_string(pageSize));
+int DescribeInclinedTablesRequest::getPageSize() const {
+  return pageSize_;
 }
 
-std::string DescribeInclinedTablesRequest::getOrder()const
-{
-	return order_;
+void DescribeInclinedTablesRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
 }
 
-void DescribeInclinedTablesRequest::setOrder(const std::string& order)
-{
-	order_ = order;
-	setParameter("Order", order);
+std::string DescribeInclinedTablesRequest::getOrder() const {
+  return order_;
 }
 
-std::string DescribeInclinedTablesRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void DescribeInclinedTablesRequest::setOrder(const std::string &order) {
+  order_ = order;
+  setParameter(std::string("Order"), order);
 }
 
-void DescribeInclinedTablesRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string DescribeInclinedTablesRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string DescribeInclinedTablesRequest::getDBClusterId()const
-{
-	return dBClusterId_;
+void DescribeInclinedTablesRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void DescribeInclinedTablesRequest::setDBClusterId(const std::string& dBClusterId)
-{
-	dBClusterId_ = dBClusterId;
-	setParameter("DBClusterId", dBClusterId);
+std::string DescribeInclinedTablesRequest::getDBClusterId() const {
+  return dBClusterId_;
 }
 
-std::string DescribeInclinedTablesRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void DescribeInclinedTablesRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
 }
 
-void DescribeInclinedTablesRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string DescribeInclinedTablesRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long DescribeInclinedTablesRequest::getOwnerId()const
-{
-	return ownerId_;
+void DescribeInclinedTablesRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void DescribeInclinedTablesRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long DescribeInclinedTablesRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DescribeInclinedTablesRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 

adb/src/model/DescribeInclinedTablesResult.cc

@@ -43,24 +43,24 @@ void DescribeInclinedTablesResult::parse(const std::string &payload)
 	for (auto valueItemsTable : allItemsNode)
 	{
 		Table itemsObject;
-		if(!valueItemsTable["Schema"].isNull())
-			itemsObject.schema = valueItemsTable["Schema"].asString();
-		if(!valueItemsTable["Name"].isNull())
-			itemsObject.name = valueItemsTable["Name"].asString();
 		if(!valueItemsTable["Type"].isNull())
 			itemsObject.type = valueItemsTable["Type"].asString();
+		if(!valueItemsTable["Schema"].isNull())
+			itemsObject.schema = valueItemsTable["Schema"].asString();
 		if(!valueItemsTable["Size"].isNull())
 			itemsObject.size = std::stol(valueItemsTable["Size"].asString());
+		if(!valueItemsTable["Name"].isNull())
+			itemsObject.name = valueItemsTable["Name"].asString();
 		if(!valueItemsTable["IsIncline"].isNull())
 			itemsObject.isIncline = valueItemsTable["IsIncline"].asString() == "true";
 		items_.push_back(itemsObject);
 	}
 	if(!value["TotalCount"].isNull())
 		totalCount_ = value["TotalCount"].asString();
-	if(!value["PageNumber"].isNull())
-		pageNumber_ = value["PageNumber"].asString();
 	if(!value["PageSize"].isNull())
 		pageSize_ = value["PageSize"].asString();
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = value["PageNumber"].asString();
 
 }
 

adb/src/model/DescribeLoadTasksRecordsRequest.cc

@@ -1,183 +1,153 @@
 /*
  * 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/adb/model/DescribeLoadTasksRecordsRequest.h>
-
-using AlibabaCloud::Adb::Model::DescribeLoadTasksRecordsRequest;
-
-DescribeLoadTasksRecordsRequest::DescribeLoadTasksRecordsRequest() :
-	RpcServiceRequest("adb", "2019-03-15", "DescribeLoadTasksRecords")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeLoadTasksRecordsRequest::~DescribeLoadTasksRecordsRequest()
-{}
-
-long DescribeLoadTasksRecordsRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/adb/model/DescribeLoadTasksRecordsRequest.h>
+
+using AlibabaCloud::Adb::Model::DescribeLoadTasksRecordsRequest;
+
+DescribeLoadTasksRecordsRequest::DescribeLoadTasksRecordsRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DescribeLoadTasksRecords") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeLoadTasksRecordsRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+DescribeLoadTasksRecordsRequest::~DescribeLoadTasksRecordsRequest() {}
+
+long DescribeLoadTasksRecordsRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string DescribeLoadTasksRecordsRequest::getRange()const
-{
-	return range_;
+void DescribeLoadTasksRecordsRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void DescribeLoadTasksRecordsRequest::setRange(const std::string& range)
-{
-	range_ = range;
-	setParameter("Range", range);
+std::string DescribeLoadTasksRecordsRequest::getRange() const {
+  return range_;
 }
 
-std::string DescribeLoadTasksRecordsRequest::getStartTime()const
-{
-	return startTime_;
+void DescribeLoadTasksRecordsRequest::setRange(const std::string &range) {
+  range_ = range;
+  setParameter(std::string("Range"), range);
 }
 
-void DescribeLoadTasksRecordsRequest::setStartTime(const std::string& startTime)
-{
-	startTime_ = startTime;
-	setParameter("StartTime", startTime);
+std::string DescribeLoadTasksRecordsRequest::getStartTime() const {
+  return startTime_;
 }
 
-int DescribeLoadTasksRecordsRequest::getPageNumber()const
-{
-	return pageNumber_;
+void DescribeLoadTasksRecordsRequest::setStartTime(const std::string &startTime) {
+  startTime_ = startTime;
+  setParameter(std::string("StartTime"), startTime);
 }
 
-void DescribeLoadTasksRecordsRequest::setPageNumber(int pageNumber)
-{
-	pageNumber_ = pageNumber;
-	setParameter("PageNumber", std::to_string(pageNumber));
+int DescribeLoadTasksRecordsRequest::getPageNumber() const {
+  return pageNumber_;
 }
 
-std::string DescribeLoadTasksRecordsRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
+void DescribeLoadTasksRecordsRequest::setPageNumber(int pageNumber) {
+  pageNumber_ = pageNumber;
+  setParameter(std::string("PageNumber"), std::to_string(pageNumber));
 }
 
-void DescribeLoadTasksRecordsRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+std::string DescribeLoadTasksRecordsRequest::getAccessKeyId() const {
+  return accessKeyId_;
 }
 
-int DescribeLoadTasksRecordsRequest::getPageSize()const
-{
-	return pageSize_;
+void DescribeLoadTasksRecordsRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-void DescribeLoadTasksRecordsRequest::setPageSize(int pageSize)
-{
-	pageSize_ = pageSize;
-	setParameter("PageSize", std::to_string(pageSize));
+int DescribeLoadTasksRecordsRequest::getPageSize() const {
+  return pageSize_;
 }
 
-std::string DescribeLoadTasksRecordsRequest::getState()const
-{
-	return state_;
+void DescribeLoadTasksRecordsRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
 }
 
-void DescribeLoadTasksRecordsRequest::setState(const std::string& state)
-{
-	state_ = state;
-	setParameter("State", state);
+std::string DescribeLoadTasksRecordsRequest::getState() const {
+  return state_;
 }
 
-std::string DescribeLoadTasksRecordsRequest::getOrder()const
-{
-	return order_;
+void DescribeLoadTasksRecordsRequest::setState(const std::string &state) {
+  state_ = state;
+  setParameter(std::string("State"), state);
 }
 
-void DescribeLoadTasksRecordsRequest::setOrder(const std::string& order)
-{
-	order_ = order;
-	setParameter("Order", order);
+std::string DescribeLoadTasksRecordsRequest::getOrder() const {
+  return order_;
 }
 
-std::string DescribeLoadTasksRecordsRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void DescribeLoadTasksRecordsRequest::setOrder(const std::string &order) {
+  order_ = order;
+  setParameter(std::string("Order"), order);
 }
 
-void DescribeLoadTasksRecordsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string DescribeLoadTasksRecordsRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string DescribeLoadTasksRecordsRequest::getDBClusterId()const
-{
-	return dBClusterId_;
+void DescribeLoadTasksRecordsRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void DescribeLoadTasksRecordsRequest::setDBClusterId(const std::string& dBClusterId)
-{
-	dBClusterId_ = dBClusterId;
-	setParameter("DBClusterId", dBClusterId);
+std::string DescribeLoadTasksRecordsRequest::getDBClusterId() const {
+  return dBClusterId_;
 }
 
-std::string DescribeLoadTasksRecordsRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void DescribeLoadTasksRecordsRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
 }
 
-void DescribeLoadTasksRecordsRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string DescribeLoadTasksRecordsRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-std::string DescribeLoadTasksRecordsRequest::getEndTime()const
-{
-	return endTime_;
+void DescribeLoadTasksRecordsRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void DescribeLoadTasksRecordsRequest::setEndTime(const std::string& endTime)
-{
-	endTime_ = endTime;
-	setParameter("EndTime", endTime);
+std::string DescribeLoadTasksRecordsRequest::getEndTime() const {
+  return endTime_;
 }
 
-long DescribeLoadTasksRecordsRequest::getOwnerId()const
-{
-	return ownerId_;
+void DescribeLoadTasksRecordsRequest::setEndTime(const std::string &endTime) {
+  endTime_ = endTime;
+  setParameter(std::string("EndTime"), endTime);
 }
 
-void DescribeLoadTasksRecordsRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long DescribeLoadTasksRecordsRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string DescribeLoadTasksRecordsRequest::getDBName()const
-{
-	return dBName_;
+void DescribeLoadTasksRecordsRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void DescribeLoadTasksRecordsRequest::setDBName(const std::string& dBName)
-{
-	dBName_ = dBName;
-	setParameter("DBName", dBName);
+std::string DescribeLoadTasksRecordsRequest::getDBName() const {
+  return dBName_;
+}
+
+void DescribeLoadTasksRecordsRequest::setDBName(const std::string &dBName) {
+  dBName_ = dBName;
+  setParameter(std::string("DBName"), dBName);
 }
 

adb/src/model/DescribeLoadTasksRecordsResult.cc

@@ -43,22 +43,22 @@ void DescribeLoadTasksRecordsResult::parse(const std::string &payload)
 	for (auto valueLoadTasksRecordsLoadTaskRecord : allLoadTasksRecordsNode)
 	{
 		LoadTaskRecord loadTasksRecordsObject;
-		if(!valueLoadTasksRecordsLoadTaskRecord["ProcessRows"].isNull())
-			loadTasksRecordsObject.processRows = std::stol(valueLoadTasksRecordsLoadTaskRecord["ProcessRows"].asString());
+		if(!valueLoadTasksRecordsLoadTaskRecord["Sql"].isNull())
+			loadTasksRecordsObject.sql = valueLoadTasksRecordsLoadTaskRecord["Sql"].asString();
 		if(!valueLoadTasksRecordsLoadTaskRecord["State"].isNull())
 			loadTasksRecordsObject.state = valueLoadTasksRecordsLoadTaskRecord["State"].asString();
 		if(!valueLoadTasksRecordsLoadTaskRecord["CreateTime"].isNull())
 			loadTasksRecordsObject.createTime = valueLoadTasksRecordsLoadTaskRecord["CreateTime"].asString();
-		if(!valueLoadTasksRecordsLoadTaskRecord["JobName"].isNull())
-			loadTasksRecordsObject.jobName = valueLoadTasksRecordsLoadTaskRecord["JobName"].asString();
-		if(!valueLoadTasksRecordsLoadTaskRecord["UpdateTime"].isNull())
-			loadTasksRecordsObject.updateTime = valueLoadTasksRecordsLoadTaskRecord["UpdateTime"].asString();
 		if(!valueLoadTasksRecordsLoadTaskRecord["DBName"].isNull())
 			loadTasksRecordsObject.dBName = valueLoadTasksRecordsLoadTaskRecord["DBName"].asString();
 		if(!valueLoadTasksRecordsLoadTaskRecord["ProcessID"].isNull())
 			loadTasksRecordsObject.processID = valueLoadTasksRecordsLoadTaskRecord["ProcessID"].asString();
-		if(!valueLoadTasksRecordsLoadTaskRecord["Sql"].isNull())
-			loadTasksRecordsObject.sql = valueLoadTasksRecordsLoadTaskRecord["Sql"].asString();
+		if(!valueLoadTasksRecordsLoadTaskRecord["UpdateTime"].isNull())
+			loadTasksRecordsObject.updateTime = valueLoadTasksRecordsLoadTaskRecord["UpdateTime"].asString();
+		if(!valueLoadTasksRecordsLoadTaskRecord["JobName"].isNull())
+			loadTasksRecordsObject.jobName = valueLoadTasksRecordsLoadTaskRecord["JobName"].asString();
+		if(!valueLoadTasksRecordsLoadTaskRecord["ProcessRows"].isNull())
+			loadTasksRecordsObject.processRows = std::stol(valueLoadTasksRecordsLoadTaskRecord["ProcessRows"].asString());
 		loadTasksRecords_.push_back(loadTasksRecordsObject);
 	}
 	if(!value["TotalCount"].isNull())

adb/src/model/DescribeMaintenanceActionRequest.cc

@@ -0,0 +1,126 @@
+/*
+ * 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/adb/model/DescribeMaintenanceActionRequest.h>
+
+using AlibabaCloud::Adb::Model::DescribeMaintenanceActionRequest;
+
+DescribeMaintenanceActionRequest::DescribeMaintenanceActionRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DescribeMaintenanceAction") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeMaintenanceActionRequest::~DescribeMaintenanceActionRequest() {}
+
+long DescribeMaintenanceActionRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
+}
+
+void DescribeMaintenanceActionRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
+}
+
+int DescribeMaintenanceActionRequest::getPageNumber() const {
+  return pageNumber_;
+}
+
+void DescribeMaintenanceActionRequest::setPageNumber(int pageNumber) {
+  pageNumber_ = pageNumber;
+  setParameter(std::string("PageNumber"), std::to_string(pageNumber));
+}
+
+std::string DescribeMaintenanceActionRequest::getAccessKeyId() const {
+  return accessKeyId_;
+}
+
+void DescribeMaintenanceActionRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
+}
+
+int DescribeMaintenanceActionRequest::getIsHistory() const {
+  return isHistory_;
+}
+
+void DescribeMaintenanceActionRequest::setIsHistory(int isHistory) {
+  isHistory_ = isHistory;
+  setParameter(std::string("IsHistory"), std::to_string(isHistory));
+}
+
+std::string DescribeMaintenanceActionRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeMaintenanceActionRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+int DescribeMaintenanceActionRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void DescribeMaintenanceActionRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+
+std::string DescribeMaintenanceActionRequest::getTaskType() const {
+  return taskType_;
+}
+
+void DescribeMaintenanceActionRequest::setTaskType(const std::string &taskType) {
+  taskType_ = taskType;
+  setParameter(std::string("TaskType"), taskType);
+}
+
+std::string DescribeMaintenanceActionRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
+}
+
+void DescribeMaintenanceActionRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
+}
+
+std::string DescribeMaintenanceActionRequest::getOwnerAccount() const {
+  return ownerAccount_;
+}
+
+void DescribeMaintenanceActionRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
+}
+
+long DescribeMaintenanceActionRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DescribeMaintenanceActionRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
+}
+
+std::string DescribeMaintenanceActionRequest::getRegion() const {
+  return region_;
+}
+
+void DescribeMaintenanceActionRequest::setRegion(const std::string &region) {
+  region_ = region;
+  setParameter(std::string("Region"), region);
+}
+

adb/src/model/DescribeMaintenanceActionResult.cc

@@ -0,0 +1,104 @@
+/*
+ * 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/adb/model/DescribeMaintenanceActionResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Adb;
+using namespace AlibabaCloud::Adb::Model;
+
+DescribeMaintenanceActionResult::DescribeMaintenanceActionResult() :
+	ServiceResult()
+{}
+
+DescribeMaintenanceActionResult::DescribeMaintenanceActionResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeMaintenanceActionResult::~DescribeMaintenanceActionResult()
+{}
+
+void DescribeMaintenanceActionResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allItemsNode = value["Items"]["ItemsItem"];
+	for (auto valueItemsItemsItem : allItemsNode)
+	{
+		ItemsItem itemsObject;
+		if(!valueItemsItemsItem["Status"].isNull())
+			itemsObject.status = valueItemsItemsItem["Status"].asString();
+		if(!valueItemsItemsItem["Deadline"].isNull())
+			itemsObject.deadline = valueItemsItemsItem["Deadline"].asString();
+		if(!valueItemsItemsItem["PrepareInterval"].isNull())
+			itemsObject.prepareInterval = valueItemsItemsItem["PrepareInterval"].asString();
+		if(!valueItemsItemsItem["DBType"].isNull())
+			itemsObject.dBType = valueItemsItemsItem["DBType"].asString();
+		if(!valueItemsItemsItem["StartTime"].isNull())
+			itemsObject.startTime = valueItemsItemsItem["StartTime"].asString();
+		if(!valueItemsItemsItem["TaskType"].isNull())
+			itemsObject.taskType = valueItemsItemsItem["TaskType"].asString();
+		if(!valueItemsItemsItem["DBVersion"].isNull())
+			itemsObject.dBVersion = valueItemsItemsItem["DBVersion"].asString();
+		if(!valueItemsItemsItem["DBClusterId"].isNull())
+			itemsObject.dBClusterId = valueItemsItemsItem["DBClusterId"].asString();
+		if(!valueItemsItemsItem["ModifiedTime"].isNull())
+			itemsObject.modifiedTime = valueItemsItemsItem["ModifiedTime"].asString();
+		if(!valueItemsItemsItem["Region"].isNull())
+			itemsObject.region = valueItemsItemsItem["Region"].asString();
+		if(!valueItemsItemsItem["ResultInfo"].isNull())
+			itemsObject.resultInfo = valueItemsItemsItem["ResultInfo"].asString();
+		if(!valueItemsItemsItem["CreatedTime"].isNull())
+			itemsObject.createdTime = valueItemsItemsItem["CreatedTime"].asString();
+		if(!valueItemsItemsItem["Id"].isNull())
+			itemsObject.id = std::stoi(valueItemsItemsItem["Id"].asString());
+		if(!valueItemsItemsItem["SwitchTime"].isNull())
+			itemsObject.switchTime = valueItemsItemsItem["SwitchTime"].asString();
+		items_.push_back(itemsObject);
+	}
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["TotalRecordCount"].isNull())
+		totalRecordCount_ = std::stoi(value["TotalRecordCount"].asString());
+
+}
+
+int DescribeMaintenanceActionResult::getTotalRecordCount()const
+{
+	return totalRecordCount_;
+}
+
+int DescribeMaintenanceActionResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int DescribeMaintenanceActionResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::vector<DescribeMaintenanceActionResult::ItemsItem> DescribeMaintenanceActionResult::getItems()const
+{
+	return items_;
+}
+

adb/src/model/DescribeOperatorPermissionRequest.cc

@@ -1,95 +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/adb/model/DescribeOperatorPermissionRequest.h>
-
-using AlibabaCloud::Adb::Model::DescribeOperatorPermissionRequest;
-
-DescribeOperatorPermissionRequest::DescribeOperatorPermissionRequest() :
-	RpcServiceRequest("adb", "2019-03-15", "DescribeOperatorPermission")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeOperatorPermissionRequest::~DescribeOperatorPermissionRequest()
-{}
-
-long DescribeOperatorPermissionRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/adb/model/DescribeOperatorPermissionRequest.h>
+
+using AlibabaCloud::Adb::Model::DescribeOperatorPermissionRequest;
+
+DescribeOperatorPermissionRequest::DescribeOperatorPermissionRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DescribeOperatorPermission") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeOperatorPermissionRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+DescribeOperatorPermissionRequest::~DescribeOperatorPermissionRequest() {}
+
+long DescribeOperatorPermissionRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string DescribeOperatorPermissionRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
+void DescribeOperatorPermissionRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void DescribeOperatorPermissionRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+std::string DescribeOperatorPermissionRequest::getAccessKeyId() const {
+  return accessKeyId_;
 }
 
-std::string DescribeOperatorPermissionRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void DescribeOperatorPermissionRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-void DescribeOperatorPermissionRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string DescribeOperatorPermissionRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string DescribeOperatorPermissionRequest::getDBClusterId()const
-{
-	return dBClusterId_;
+void DescribeOperatorPermissionRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void DescribeOperatorPermissionRequest::setDBClusterId(const std::string& dBClusterId)
-{
-	dBClusterId_ = dBClusterId;
-	setParameter("DBClusterId", dBClusterId);
+std::string DescribeOperatorPermissionRequest::getDBClusterId() const {
+  return dBClusterId_;
 }
 
-std::string DescribeOperatorPermissionRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void DescribeOperatorPermissionRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
 }
 
-void DescribeOperatorPermissionRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string DescribeOperatorPermissionRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long DescribeOperatorPermissionRequest::getOwnerId()const
-{
-	return ownerId_;
+void DescribeOperatorPermissionRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void DescribeOperatorPermissionRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long DescribeOperatorPermissionRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DescribeOperatorPermissionRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 

adb/src/model/DescribeOperatorPermissionResult.cc

@@ -39,10 +39,10 @@ void DescribeOperatorPermissionResult::parse(const std::string &payload)
 	Json::Value value;
 	reader.parse(payload, value);
 	setRequestId(value["RequestId"].asString());
-	if(!value["Privileges"].isNull())
-		privileges_ = value["Privileges"].asString();
 	if(!value["CreatedTime"].isNull())
 		createdTime_ = value["CreatedTime"].asString();
+	if(!value["Privileges"].isNull())
+		privileges_ = value["Privileges"].asString();
 	if(!value["ExpiredTime"].isNull())
 		expiredTime_ = value["ExpiredTime"].asString();
 	if(!value["DBClusterId"].isNull())

adb/src/model/DescribePatternPerformanceRequest.cc

@@ -0,0 +1,72 @@
+/*
+ * 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/adb/model/DescribePatternPerformanceRequest.h>
+
+using AlibabaCloud::Adb::Model::DescribePatternPerformanceRequest;
+
+DescribePatternPerformanceRequest::DescribePatternPerformanceRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DescribePatternPerformance") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribePatternPerformanceRequest::~DescribePatternPerformanceRequest() {}
+
+std::string DescribePatternPerformanceRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribePatternPerformanceRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string DescribePatternPerformanceRequest::getDBClusterId() const {
+  return dBClusterId_;
+}
+
+void DescribePatternPerformanceRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
+}
+
+std::string DescribePatternPerformanceRequest::getPatternId() const {
+  return patternId_;
+}
+
+void DescribePatternPerformanceRequest::setPatternId(const std::string &patternId) {
+  patternId_ = patternId;
+  setParameter(std::string("PatternId"), patternId);
+}
+
+std::string DescribePatternPerformanceRequest::getEndTime() const {
+  return endTime_;
+}
+
+void DescribePatternPerformanceRequest::setEndTime(const std::string &endTime) {
+  endTime_ = endTime;
+  setParameter(std::string("EndTime"), endTime);
+}
+
+std::string DescribePatternPerformanceRequest::getStartTime() const {
+  return startTime_;
+}
+
+void DescribePatternPerformanceRequest::setStartTime(const std::string &startTime) {
+  startTime_ = startTime;
+  setParameter(std::string("StartTime"), startTime);
+}
+

adb/src/model/DescribePatternPerformanceResult.cc

@@ -0,0 +1,84 @@
+/*
+ * 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/adb/model/DescribePatternPerformanceResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Adb;
+using namespace AlibabaCloud::Adb::Model;
+
+DescribePatternPerformanceResult::DescribePatternPerformanceResult() :
+	ServiceResult()
+{}
+
+DescribePatternPerformanceResult::DescribePatternPerformanceResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribePatternPerformanceResult::~DescribePatternPerformanceResult()
+{}
+
+void DescribePatternPerformanceResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allPerformancesNode = value["Performances"]["PerformanceItem"];
+	for (auto valuePerformancesPerformanceItem : allPerformancesNode)
+	{
+		PerformanceItem performancesObject;
+		if(!valuePerformancesPerformanceItem["Key"].isNull())
+			performancesObject.key = valuePerformancesPerformanceItem["Key"].asString();
+		if(!valuePerformancesPerformanceItem["Unit"].isNull())
+			performancesObject.unit = valuePerformancesPerformanceItem["Unit"].asString();
+		auto allSeriesNode = valuePerformancesPerformanceItem["Series"]["SeriesItem"];
+		for (auto valuePerformancesPerformanceItemSeriesSeriesItem : allSeriesNode)
+		{
+			PerformanceItem::SeriesItem seriesObject;
+			if(!valuePerformancesPerformanceItemSeriesSeriesItem["Name"].isNull())
+				seriesObject.name = valuePerformancesPerformanceItemSeriesSeriesItem["Name"].asString();
+			auto allValues = value["Values"]["values"];
+			for (auto value : allValues)
+				seriesObject.values.push_back(value.asString());
+			performancesObject.series.push_back(seriesObject);
+		}
+		performances_.push_back(performancesObject);
+	}
+	if(!value["EndTime"].isNull())
+		endTime_ = value["EndTime"].asString();
+	if(!value["StartTime"].isNull())
+		startTime_ = value["StartTime"].asString();
+
+}
+
+std::string DescribePatternPerformanceResult::getEndTime()const
+{
+	return endTime_;
+}
+
+std::string DescribePatternPerformanceResult::getStartTime()const
+{
+	return startTime_;
+}
+
+std::vector<DescribePatternPerformanceResult::PerformanceItem> DescribePatternPerformanceResult::getPerformances()const
+{
+	return performances_;
+}
+

adb/src/model/DescribeProcessListRequest.cc

@@ -1,172 +1,144 @@
 /*
  * 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/adb/model/DescribeProcessListRequest.h>
-
-using AlibabaCloud::Adb::Model::DescribeProcessListRequest;
-
-DescribeProcessListRequest::DescribeProcessListRequest() :
-	RpcServiceRequest("adb", "2019-03-15", "DescribeProcessList")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeProcessListRequest::~DescribeProcessListRequest()
-{}
-
-long DescribeProcessListRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/adb/model/DescribeProcessListRequest.h>
+
+using AlibabaCloud::Adb::Model::DescribeProcessListRequest;
+
+DescribeProcessListRequest::DescribeProcessListRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DescribeProcessList") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeProcessListRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+DescribeProcessListRequest::~DescribeProcessListRequest() {}
+
+long DescribeProcessListRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-int DescribeProcessListRequest::getPageNumber()const
-{
-	return pageNumber_;
+void DescribeProcessListRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void DescribeProcessListRequest::setPageNumber(int pageNumber)
-{
-	pageNumber_ = pageNumber;
-	setParameter("PageNumber", std::to_string(pageNumber));
+int DescribeProcessListRequest::getPageNumber() const {
+  return pageNumber_;
 }
 
-std::string DescribeProcessListRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
+void DescribeProcessListRequest::setPageNumber(int pageNumber) {
+  pageNumber_ = pageNumber;
+  setParameter(std::string("PageNumber"), std::to_string(pageNumber));
 }
 
-void DescribeProcessListRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+std::string DescribeProcessListRequest::getAccessKeyId() const {
+  return accessKeyId_;
 }
 
-int DescribeProcessListRequest::getPageSize()const
-{
-	return pageSize_;
+void DescribeProcessListRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-void DescribeProcessListRequest::setPageSize(int pageSize)
-{
-	pageSize_ = pageSize;
-	setParameter("PageSize", std::to_string(pageSize));
+int DescribeProcessListRequest::getPageSize() const {
+  return pageSize_;
 }
 
-bool DescribeProcessListRequest::getShowFull()const
-{
-	return showFull_;
+void DescribeProcessListRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
 }
 
-void DescribeProcessListRequest::setShowFull(bool showFull)
-{
-	showFull_ = showFull;
-	setParameter("ShowFull", showFull ? "true" : "false");
+bool DescribeProcessListRequest::getShowFull() const {
+  return showFull_;
 }
 
-int DescribeProcessListRequest::getRunningTime()const
-{
-	return runningTime_;
+void DescribeProcessListRequest::setShowFull(bool showFull) {
+  showFull_ = showFull;
+  setParameter(std::string("ShowFull"), showFull ? "true" : "false");
 }
 
-void DescribeProcessListRequest::setRunningTime(int runningTime)
-{
-	runningTime_ = runningTime;
-	setParameter("RunningTime", std::to_string(runningTime));
+int DescribeProcessListRequest::getRunningTime() const {
+  return runningTime_;
 }
 
-std::string DescribeProcessListRequest::getKeyword()const
-{
-	return keyword_;
+void DescribeProcessListRequest::setRunningTime(int runningTime) {
+  runningTime_ = runningTime;
+  setParameter(std::string("RunningTime"), std::to_string(runningTime));
 }
 
-void DescribeProcessListRequest::setKeyword(const std::string& keyword)
-{
-	keyword_ = keyword;
-	setParameter("Keyword", keyword);
+std::string DescribeProcessListRequest::getKeyword() const {
+  return keyword_;
 }
 
-std::string DescribeProcessListRequest::getOrder()const
-{
-	return order_;
+void DescribeProcessListRequest::setKeyword(const std::string &keyword) {
+  keyword_ = keyword;
+  setParameter(std::string("Keyword"), keyword);
 }
 
-void DescribeProcessListRequest::setOrder(const std::string& order)
-{
-	order_ = order;
-	setParameter("Order", order);
+std::string DescribeProcessListRequest::getOrder() const {
+  return order_;
 }
 
-std::string DescribeProcessListRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void DescribeProcessListRequest::setOrder(const std::string &order) {
+  order_ = order;
+  setParameter(std::string("Order"), order);
 }
 
-void DescribeProcessListRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string DescribeProcessListRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string DescribeProcessListRequest::getDBClusterId()const
-{
-	return dBClusterId_;
+void DescribeProcessListRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void DescribeProcessListRequest::setDBClusterId(const std::string& dBClusterId)
-{
-	dBClusterId_ = dBClusterId;
-	setParameter("DBClusterId", dBClusterId);
+std::string DescribeProcessListRequest::getDBClusterId() const {
+  return dBClusterId_;
 }
 
-std::string DescribeProcessListRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void DescribeProcessListRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
 }
 
-void DescribeProcessListRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string DescribeProcessListRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long DescribeProcessListRequest::getOwnerId()const
-{
-	return ownerId_;
+void DescribeProcessListRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void DescribeProcessListRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long DescribeProcessListRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string DescribeProcessListRequest::getUser()const
-{
-	return user_;
+void DescribeProcessListRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void DescribeProcessListRequest::setUser(const std::string& user)
-{
-	user_ = user;
-	setParameter("User", user);
+std::string DescribeProcessListRequest::getUser() const {
+  return user_;
+}
+
+void DescribeProcessListRequest::setUser(const std::string &user) {
+  user_ = user;
+  setParameter(std::string("User"), user);
 }
 

adb/src/model/DescribeProcessListResult.cc

@@ -43,32 +43,32 @@ void DescribeProcessListResult::parse(const std::string &payload)
 	for (auto valueItemsProcess : allItemsNode)
 	{
 		Process itemsObject;
-		if(!valueItemsProcess["Id"].isNull())
-			itemsObject.id = std::stoi(valueItemsProcess["Id"].asString());
+		if(!valueItemsProcess["StartTime"].isNull())
+			itemsObject.startTime = valueItemsProcess["StartTime"].asString();
+		if(!valueItemsProcess["Time"].isNull())
+			itemsObject.time = std::stoi(valueItemsProcess["Time"].asString());
 		if(!valueItemsProcess["ProcessId"].isNull())
 			itemsObject.processId = valueItemsProcess["ProcessId"].asString();
-		if(!valueItemsProcess["User"].isNull())
-			itemsObject.user = valueItemsProcess["User"].asString();
 		if(!valueItemsProcess["Host"].isNull())
 			itemsObject.host = valueItemsProcess["Host"].asString();
 		if(!valueItemsProcess["DB"].isNull())
 			itemsObject.dB = valueItemsProcess["DB"].asString();
 		if(!valueItemsProcess["Command"].isNull())
 			itemsObject.command = valueItemsProcess["Command"].asString();
-		if(!valueItemsProcess["Time"].isNull())
-			itemsObject.time = std::stoi(valueItemsProcess["Time"].asString());
-		if(!valueItemsProcess["StartTime"].isNull())
-			itemsObject.startTime = valueItemsProcess["StartTime"].asString();
+		if(!valueItemsProcess["User"].isNull())
+			itemsObject.user = valueItemsProcess["User"].asString();
+		if(!valueItemsProcess["Id"].isNull())
+			itemsObject.id = std::stoi(valueItemsProcess["Id"].asString());
 		if(!valueItemsProcess["Info"].isNull())
 			itemsObject.info = valueItemsProcess["Info"].asString();
 		items_.push_back(itemsObject);
 	}
 	if(!value["TotalCount"].isNull())
 		totalCount_ = value["TotalCount"].asString();
-	if(!value["PageNumber"].isNull())
-		pageNumber_ = value["PageNumber"].asString();
 	if(!value["PageSize"].isNull())
 		pageSize_ = value["PageSize"].asString();
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = value["PageNumber"].asString();
 
 }
 

adb/src/model/DescribeRegionsRequest.cc

@@ -1,95 +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/adb/model/DescribeRegionsRequest.h>
-
-using AlibabaCloud::Adb::Model::DescribeRegionsRequest;
-
-DescribeRegionsRequest::DescribeRegionsRequest() :
-	RpcServiceRequest("adb", "2019-03-15", "DescribeRegions")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeRegionsRequest::~DescribeRegionsRequest()
-{}
-
-long DescribeRegionsRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/adb/model/DescribeRegionsRequest.h>
+
+using AlibabaCloud::Adb::Model::DescribeRegionsRequest;
+
+DescribeRegionsRequest::DescribeRegionsRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DescribeRegions") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeRegionsRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+DescribeRegionsRequest::~DescribeRegionsRequest() {}
+
+long DescribeRegionsRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string DescribeRegionsRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
+void DescribeRegionsRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void DescribeRegionsRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+std::string DescribeRegionsRequest::getAccessKeyId() const {
+  return accessKeyId_;
 }
 
-std::string DescribeRegionsRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void DescribeRegionsRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-void DescribeRegionsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string DescribeRegionsRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string DescribeRegionsRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void DescribeRegionsRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void DescribeRegionsRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string DescribeRegionsRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long DescribeRegionsRequest::getOwnerId()const
-{
-	return ownerId_;
+void DescribeRegionsRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void DescribeRegionsRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long DescribeRegionsRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string DescribeRegionsRequest::getAcceptLanguage()const
-{
-	return acceptLanguage_;
+void DescribeRegionsRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void DescribeRegionsRequest::setAcceptLanguage(const std::string& acceptLanguage)
-{
-	acceptLanguage_ = acceptLanguage;
-	setParameter("AcceptLanguage", acceptLanguage);
+std::string DescribeRegionsRequest::getAcceptLanguage() const {
+  return acceptLanguage_;
+}
+
+void DescribeRegionsRequest::setAcceptLanguage(const std::string &acceptLanguage) {
+  acceptLanguage_ = acceptLanguage;
+  setParameter(std::string("AcceptLanguage"), acceptLanguage);
 }
 

adb/src/model/DescribeRegionsResult.cc

@@ -43,12 +43,12 @@ void DescribeRegionsResult::parse(const std::string &payload)
 	for (auto valueRegionsRegion : allRegionsNode)
 	{
 		Region regionsObject;
-		if(!valueRegionsRegion["RegionId"].isNull())
-			regionsObject.regionId = valueRegionsRegion["RegionId"].asString();
-		if(!valueRegionsRegion["LocalName"].isNull())
-			regionsObject.localName = valueRegionsRegion["LocalName"].asString();
 		if(!valueRegionsRegion["RegionEndpoint"].isNull())
 			regionsObject.regionEndpoint = valueRegionsRegion["RegionEndpoint"].asString();
+		if(!valueRegionsRegion["LocalName"].isNull())
+			regionsObject.localName = valueRegionsRegion["LocalName"].asString();
+		if(!valueRegionsRegion["RegionId"].isNull())
+			regionsObject.regionId = valueRegionsRegion["RegionId"].asString();
 		auto allZonesNode = valueRegionsRegion["Zones"]["Zone"];
 		for (auto valueRegionsRegionZonesZone : allZonesNode)
 		{

adb/src/model/DescribeSQLPatternAttributeRequest.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/adb/model/DescribeSQLPatternAttributeRequest.h>
+
+using AlibabaCloud::Adb::Model::DescribeSQLPatternAttributeRequest;
+
+DescribeSQLPatternAttributeRequest::DescribeSQLPatternAttributeRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DescribeSQLPatternAttribute") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeSQLPatternAttributeRequest::~DescribeSQLPatternAttributeRequest() {}
+
+std::string DescribeSQLPatternAttributeRequest::getDBClusterId() const {
+  return dBClusterId_;
+}
+
+void DescribeSQLPatternAttributeRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
+}
+
+long DescribeSQLPatternAttributeRequest::getPatternId() const {
+  return patternId_;
+}
+
+void DescribeSQLPatternAttributeRequest::setPatternId(long patternId) {
+  patternId_ = patternId;
+  setParameter(std::string("PatternId"), std::to_string(patternId));
+}
+
+std::string DescribeSQLPatternAttributeRequest::getEndTime() const {
+  return endTime_;
+}
+
+void DescribeSQLPatternAttributeRequest::setEndTime(const std::string &endTime) {
+  endTime_ = endTime;
+  setParameter(std::string("EndTime"), endTime);
+}
+
+std::string DescribeSQLPatternAttributeRequest::getStartTime() const {
+  return startTime_;
+}
+
+void DescribeSQLPatternAttributeRequest::setStartTime(const std::string &startTime) {
+  startTime_ = startTime;
+  setParameter(std::string("StartTime"), startTime);
+}
+
+std::string DescribeSQLPatternAttributeRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeSQLPatternAttributeRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+std::string DescribeSQLPatternAttributeRequest::getLang() const {
+  return lang_;
+}
+
+void DescribeSQLPatternAttributeRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
+}
+

adb/src/model/DescribeSQLPatternAttributeResult.cc

@@ -0,0 +1,60 @@
+/*
+ * 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/adb/model/DescribeSQLPatternAttributeResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Adb;
+using namespace AlibabaCloud::Adb::Model;
+
+DescribeSQLPatternAttributeResult::DescribeSQLPatternAttributeResult() :
+	ServiceResult()
+{}
+
+DescribeSQLPatternAttributeResult::DescribeSQLPatternAttributeResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeSQLPatternAttributeResult::~DescribeSQLPatternAttributeResult()
+{}
+
+void DescribeSQLPatternAttributeResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto patternDetailNode = value["PatternDetail"];
+	if(!patternDetailNode["SQLPattern"].isNull())
+		patternDetail_.sQLPattern = patternDetailNode["SQLPattern"].asString();
+	if(!patternDetailNode["QueryCount"].isNull())
+		patternDetail_.queryCount = std::stol(patternDetailNode["QueryCount"].asString());
+	if(!patternDetailNode["TotalQueryTime"].isNull())
+		patternDetail_.totalQueryTime = patternDetailNode["TotalQueryTime"].asString();
+	if(!patternDetailNode["AverageQueryTime"].isNull())
+		patternDetail_.averageQueryTime = patternDetailNode["AverageQueryTime"].asString();
+	if(!patternDetailNode["AverageMemory"].isNull())
+		patternDetail_.averageMemory = patternDetailNode["AverageMemory"].asString();
+
+}
+
+DescribeSQLPatternAttributeResult::PatternDetail DescribeSQLPatternAttributeResult::getPatternDetail()const
+{
+	return patternDetail_;
+}
+

adb/src/model/DescribeSQLPatternsRequest.cc

@@ -0,0 +1,108 @@
+/*
+ * 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/adb/model/DescribeSQLPatternsRequest.h>
+
+using AlibabaCloud::Adb::Model::DescribeSQLPatternsRequest;
+
+DescribeSQLPatternsRequest::DescribeSQLPatternsRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DescribeSQLPatterns") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeSQLPatternsRequest::~DescribeSQLPatternsRequest() {}
+
+std::string DescribeSQLPatternsRequest::getDBClusterId() const {
+  return dBClusterId_;
+}
+
+void DescribeSQLPatternsRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
+}
+
+std::string DescribeSQLPatternsRequest::getEndTime() const {
+  return endTime_;
+}
+
+void DescribeSQLPatternsRequest::setEndTime(const std::string &endTime) {
+  endTime_ = endTime;
+  setParameter(std::string("EndTime"), endTime);
+}
+
+std::string DescribeSQLPatternsRequest::getStartTime() const {
+  return startTime_;
+}
+
+void DescribeSQLPatternsRequest::setStartTime(const std::string &startTime) {
+  startTime_ = startTime;
+  setParameter(std::string("StartTime"), startTime);
+}
+
+int DescribeSQLPatternsRequest::getPageNumber() const {
+  return pageNumber_;
+}
+
+void DescribeSQLPatternsRequest::setPageNumber(int pageNumber) {
+  pageNumber_ = pageNumber;
+  setParameter(std::string("PageNumber"), std::to_string(pageNumber));
+}
+
+std::string DescribeSQLPatternsRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeSQLPatternsRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+int DescribeSQLPatternsRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void DescribeSQLPatternsRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+
+std::string DescribeSQLPatternsRequest::getKeyword() const {
+  return keyword_;
+}
+
+void DescribeSQLPatternsRequest::setKeyword(const std::string &keyword) {
+  keyword_ = keyword;
+  setParameter(std::string("Keyword"), keyword);
+}
+
+std::string DescribeSQLPatternsRequest::getLang() const {
+  return lang_;
+}
+
+void DescribeSQLPatternsRequest::setLang(const std::string &lang) {
+  lang_ = lang;
+  setParameter(std::string("Lang"), lang);
+}
+
+std::string DescribeSQLPatternsRequest::getOrder() const {
+  return order_;
+}
+
+void DescribeSQLPatternsRequest::setOrder(const std::string &order) {
+  order_ = order;
+  setParameter(std::string("Order"), order);
+}
+

adb/src/model/DescribeSQLPatternsResult.cc

@@ -0,0 +1,110 @@
+/*
+ * 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/adb/model/DescribeSQLPatternsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Adb;
+using namespace AlibabaCloud::Adb::Model;
+
+DescribeSQLPatternsResult::DescribeSQLPatternsResult() :
+	ServiceResult()
+{}
+
+DescribeSQLPatternsResult::DescribeSQLPatternsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeSQLPatternsResult::~DescribeSQLPatternsResult()
+{}
+
+void DescribeSQLPatternsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allPatternDetailsNode = value["PatternDetails"]["patternDetailsItem"];
+	for (auto valuePatternDetailspatternDetailsItem : allPatternDetailsNode)
+	{
+		PatternDetailsItem patternDetailsObject;
+		if(!valuePatternDetailspatternDetailsItem["SQLPattern"].isNull())
+			patternDetailsObject.sQLPattern = valuePatternDetailspatternDetailsItem["SQLPattern"].asString();
+		if(!valuePatternDetailspatternDetailsItem["PatternId"].isNull())
+			patternDetailsObject.patternId = valuePatternDetailspatternDetailsItem["PatternId"].asString();
+		if(!valuePatternDetailspatternDetailsItem["User"].isNull())
+			patternDetailsObject.user = valuePatternDetailspatternDetailsItem["User"].asString();
+		if(!valuePatternDetailspatternDetailsItem["AccessIp"].isNull())
+			patternDetailsObject.accessIp = valuePatternDetailspatternDetailsItem["AccessIp"].asString();
+		if(!valuePatternDetailspatternDetailsItem["Tables"].isNull())
+			patternDetailsObject.tables = valuePatternDetailspatternDetailsItem["Tables"].asString();
+		if(!valuePatternDetailspatternDetailsItem["PatternCreationTime"].isNull())
+			patternDetailsObject.patternCreationTime = valuePatternDetailspatternDetailsItem["PatternCreationTime"].asString();
+		if(!valuePatternDetailspatternDetailsItem["AverageQueryTime"].isNull())
+			patternDetailsObject.averageQueryTime = valuePatternDetailspatternDetailsItem["AverageQueryTime"].asString();
+		if(!valuePatternDetailspatternDetailsItem["MaxQueryTime"].isNull())
+			patternDetailsObject.maxQueryTime = std::stol(valuePatternDetailspatternDetailsItem["MaxQueryTime"].asString());
+		if(!valuePatternDetailspatternDetailsItem["AverageExecutionTime"].isNull())
+			patternDetailsObject.averageExecutionTime = valuePatternDetailspatternDetailsItem["AverageExecutionTime"].asString();
+		if(!valuePatternDetailspatternDetailsItem["MaxExecutionTime"].isNull())
+			patternDetailsObject.maxExecutionTime = std::stol(valuePatternDetailspatternDetailsItem["MaxExecutionTime"].asString());
+		if(!valuePatternDetailspatternDetailsItem["AveragePeakMemory"].isNull())
+			patternDetailsObject.averagePeakMemory = valuePatternDetailspatternDetailsItem["AveragePeakMemory"].asString();
+		if(!valuePatternDetailspatternDetailsItem["MaxPeakMemory"].isNull())
+			patternDetailsObject.maxPeakMemory = std::stol(valuePatternDetailspatternDetailsItem["MaxPeakMemory"].asString());
+		if(!valuePatternDetailspatternDetailsItem["AverageScanSize"].isNull())
+			patternDetailsObject.averageScanSize = valuePatternDetailspatternDetailsItem["AverageScanSize"].asString();
+		if(!valuePatternDetailspatternDetailsItem["MaxScanSize"].isNull())
+			patternDetailsObject.maxScanSize = std::stol(valuePatternDetailspatternDetailsItem["MaxScanSize"].asString());
+		if(!valuePatternDetailspatternDetailsItem["QueryCount"].isNull())
+			patternDetailsObject.queryCount = std::stol(valuePatternDetailspatternDetailsItem["QueryCount"].asString());
+		if(!valuePatternDetailspatternDetailsItem["FailedCount"].isNull())
+			patternDetailsObject.failedCount = std::stol(valuePatternDetailspatternDetailsItem["FailedCount"].asString());
+		if(!valuePatternDetailspatternDetailsItem["Blockable"].isNull())
+			patternDetailsObject.blockable = valuePatternDetailspatternDetailsItem["Blockable"].asString() == "true";
+		patternDetails_.push_back(patternDetailsObject);
+	}
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
+
+}
+
+int DescribeSQLPatternsResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+int DescribeSQLPatternsResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int DescribeSQLPatternsResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::vector<DescribeSQLPatternsResult::PatternDetailsItem> DescribeSQLPatternsResult::getPatternDetails()const
+{
+	return patternDetails_;
+}
+

adb/src/model/DescribeSQLPlanRequest.cc

@@ -1,106 +1,90 @@
 /*
  * 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/adb/model/DescribeSQLPlanRequest.h>
-
-using AlibabaCloud::Adb::Model::DescribeSQLPlanRequest;
-
-DescribeSQLPlanRequest::DescribeSQLPlanRequest() :
-	RpcServiceRequest("adb", "2019-03-15", "DescribeSQLPlan")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeSQLPlanRequest::~DescribeSQLPlanRequest()
-{}
-
-long DescribeSQLPlanRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/adb/model/DescribeSQLPlanRequest.h>
+
+using AlibabaCloud::Adb::Model::DescribeSQLPlanRequest;
+
+DescribeSQLPlanRequest::DescribeSQLPlanRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DescribeSQLPlan") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeSQLPlanRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+DescribeSQLPlanRequest::~DescribeSQLPlanRequest() {}
+
+long DescribeSQLPlanRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string DescribeSQLPlanRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
+void DescribeSQLPlanRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void DescribeSQLPlanRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+std::string DescribeSQLPlanRequest::getAccessKeyId() const {
+  return accessKeyId_;
 }
 
-std::string DescribeSQLPlanRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void DescribeSQLPlanRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-void DescribeSQLPlanRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string DescribeSQLPlanRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string DescribeSQLPlanRequest::getDBClusterId()const
-{
-	return dBClusterId_;
+void DescribeSQLPlanRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void DescribeSQLPlanRequest::setDBClusterId(const std::string& dBClusterId)
-{
-	dBClusterId_ = dBClusterId;
-	setParameter("DBClusterId", dBClusterId);
+std::string DescribeSQLPlanRequest::getDBClusterId() const {
+  return dBClusterId_;
 }
 
-std::string DescribeSQLPlanRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void DescribeSQLPlanRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
 }
 
-void DescribeSQLPlanRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string DescribeSQLPlanRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long DescribeSQLPlanRequest::getOwnerId()const
-{
-	return ownerId_;
+void DescribeSQLPlanRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void DescribeSQLPlanRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long DescribeSQLPlanRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string DescribeSQLPlanRequest::getProcessId()const
-{
-	return processId_;
+void DescribeSQLPlanRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void DescribeSQLPlanRequest::setProcessId(const std::string& processId)
-{
-	processId_ = processId;
-	setParameter("ProcessId", processId);
+std::string DescribeSQLPlanRequest::getProcessId() const {
+  return processId_;
+}
+
+void DescribeSQLPlanRequest::setProcessId(const std::string &processId) {
+  processId_ = processId;
+  setParameter(std::string("ProcessId"), processId);
 }
 

adb/src/model/DescribeSQLPlanResult.cc

@@ -43,71 +43,71 @@ void DescribeSQLPlanResult::parse(const std::string &payload)
 	for (auto valueStageListSqlPlanStage : allStageListNode)
 	{
 		SqlPlanStage stageListObject;
-		if(!valueStageListSqlPlanStage["StageId"].isNull())
-			stageListObject.stageId = std::stoi(valueStageListSqlPlanStage["StageId"].asString());
 		if(!valueStageListSqlPlanStage["State"].isNull())
 			stageListObject.state = valueStageListSqlPlanStage["State"].asString();
-		if(!valueStageListSqlPlanStage["OperatorCost"].isNull())
-			stageListObject.operatorCost = std::stol(valueStageListSqlPlanStage["OperatorCost"].asString());
-		if(!valueStageListSqlPlanStage["PeakMemory"].isNull())
-			stageListObject.peakMemory = std::stol(valueStageListSqlPlanStage["PeakMemory"].asString());
-		if(!valueStageListSqlPlanStage["CPUTimeMin"].isNull())
-			stageListObject.cPUTimeMin = std::stol(valueStageListSqlPlanStage["CPUTimeMin"].asString());
-		if(!valueStageListSqlPlanStage["CPUTimeMax"].isNull())
-			stageListObject.cPUTimeMax = std::stol(valueStageListSqlPlanStage["CPUTimeMax"].asString());
 		if(!valueStageListSqlPlanStage["CPUTimeAvg"].isNull())
 			stageListObject.cPUTimeAvg = std::stol(valueStageListSqlPlanStage["CPUTimeAvg"].asString());
-		if(!valueStageListSqlPlanStage["InputSizeMin"].isNull())
-			stageListObject.inputSizeMin = std::stol(valueStageListSqlPlanStage["InputSizeMin"].asString());
-		if(!valueStageListSqlPlanStage["InputSizeMax"].isNull())
-			stageListObject.inputSizeMax = std::stol(valueStageListSqlPlanStage["InputSizeMax"].asString());
-		if(!valueStageListSqlPlanStage["InputSizeAvg"].isNull())
-			stageListObject.inputSizeAvg = std::stol(valueStageListSqlPlanStage["InputSizeAvg"].asString());
-		if(!valueStageListSqlPlanStage["ScanSizeMin"].isNull())
-			stageListObject.scanSizeMin = std::stol(valueStageListSqlPlanStage["ScanSizeMin"].asString());
-		if(!valueStageListSqlPlanStage["ScanSizeMax"].isNull())
-			stageListObject.scanSizeMax = std::stol(valueStageListSqlPlanStage["ScanSizeMax"].asString());
-		if(!valueStageListSqlPlanStage["ScanSizeAvg"].isNull())
-			stageListObject.scanSizeAvg = std::stol(valueStageListSqlPlanStage["ScanSizeAvg"].asString());
-		if(!valueStageListSqlPlanStage["ScanTimeMin"].isNull())
-			stageListObject.scanTimeMin = std::stol(valueStageListSqlPlanStage["ScanTimeMin"].asString());
+		if(!valueStageListSqlPlanStage["CPUTimeMax"].isNull())
+			stageListObject.cPUTimeMax = std::stol(valueStageListSqlPlanStage["CPUTimeMax"].asString());
+		if(!valueStageListSqlPlanStage["OperatorCost"].isNull())
+			stageListObject.operatorCost = std::stol(valueStageListSqlPlanStage["OperatorCost"].asString());
 		if(!valueStageListSqlPlanStage["ScanTimeMax"].isNull())
 			stageListObject.scanTimeMax = std::stol(valueStageListSqlPlanStage["ScanTimeMax"].asString());
+		if(!valueStageListSqlPlanStage["InputSizeMax"].isNull())
+			stageListObject.inputSizeMax = std::stol(valueStageListSqlPlanStage["InputSizeMax"].asString());
+		if(!valueStageListSqlPlanStage["StageId"].isNull())
+			stageListObject.stageId = std::stoi(valueStageListSqlPlanStage["StageId"].asString());
+		if(!valueStageListSqlPlanStage["ScanSizeMax"].isNull())
+			stageListObject.scanSizeMax = std::stol(valueStageListSqlPlanStage["ScanSizeMax"].asString());
+		if(!valueStageListSqlPlanStage["CPUTimeMin"].isNull())
+			stageListObject.cPUTimeMin = std::stol(valueStageListSqlPlanStage["CPUTimeMin"].asString());
+		if(!valueStageListSqlPlanStage["ScanTimeMin"].isNull())
+			stageListObject.scanTimeMin = std::stol(valueStageListSqlPlanStage["ScanTimeMin"].asString());
+		if(!valueStageListSqlPlanStage["ScanSizeMin"].isNull())
+			stageListObject.scanSizeMin = std::stol(valueStageListSqlPlanStage["ScanSizeMin"].asString());
+		if(!valueStageListSqlPlanStage["InputSizeMin"].isNull())
+			stageListObject.inputSizeMin = std::stol(valueStageListSqlPlanStage["InputSizeMin"].asString());
+		if(!valueStageListSqlPlanStage["PeakMemory"].isNull())
+			stageListObject.peakMemory = std::stol(valueStageListSqlPlanStage["PeakMemory"].asString());
 		if(!valueStageListSqlPlanStage["ScanTimeAvg"].isNull())
 			stageListObject.scanTimeAvg = std::stol(valueStageListSqlPlanStage["ScanTimeAvg"].asString());
+		if(!valueStageListSqlPlanStage["ScanSizeAvg"].isNull())
+			stageListObject.scanSizeAvg = std::stol(valueStageListSqlPlanStage["ScanSizeAvg"].asString());
+		if(!valueStageListSqlPlanStage["InputSizeAvg"].isNull())
+			stageListObject.inputSizeAvg = std::stol(valueStageListSqlPlanStage["InputSizeAvg"].asString());
 		stageList_.push_back(stageListObject);
 	}
 	auto detailNode = value["Detail"];
 	if(!detailNode["SQL"].isNull())
 		detail_.sQL = detailNode["SQL"].asString();
-	if(!detailNode["State"].isNull())
-		detail_.state = detailNode["State"].asString();
-	if(!detailNode["User"].isNull())
-		detail_.user = detailNode["User"].asString();
-	if(!detailNode["ClientIP"].isNull())
-		detail_.clientIP = detailNode["ClientIP"].asString();
-	if(!detailNode["Database"].isNull())
-		detail_.database = detailNode["Database"].asString();
-	if(!detailNode["TotalStage"].isNull())
-		detail_.totalStage = std::stol(detailNode["TotalStage"].asString());
-	if(!detailNode["TotalTask"].isNull())
-		detail_.totalTask = std::stol(detailNode["TotalTask"].asString());
-	if(!detailNode["OutputRows"].isNull())
-		detail_.outputRows = std::stol(detailNode["OutputRows"].asString());
 	if(!detailNode["OutputSize"].isNull())
 		detail_.outputSize = std::stol(detailNode["OutputSize"].asString());
+	if(!detailNode["State"].isNull())
+		detail_.state = detailNode["State"].asString();
+	if(!detailNode["OutputRows"].isNull())
+		detail_.outputRows = std::stol(detailNode["OutputRows"].asString());
+	if(!detailNode["User"].isNull())
+		detail_.user = detailNode["User"].asString();
 	if(!detailNode["StartTime"].isNull())
 		detail_.startTime = detailNode["StartTime"].asString();
-	if(!detailNode["TotalTime"].isNull())
-		detail_.totalTime = std::stol(detailNode["TotalTime"].asString());
+	if(!detailNode["TotalStage"].isNull())
+		detail_.totalStage = std::stol(detailNode["TotalStage"].asString());
 	if(!detailNode["QueuedTime"].isNull())
 		detail_.queuedTime = std::stol(detailNode["QueuedTime"].asString());
+	if(!detailNode["TotalTime"].isNull())
+		detail_.totalTime = std::stol(detailNode["TotalTime"].asString());
+	if(!detailNode["TotalTask"].isNull())
+		detail_.totalTask = std::stol(detailNode["TotalTask"].asString());
+	if(!detailNode["Database"].isNull())
+		detail_.database = detailNode["Database"].asString();
+	if(!detailNode["PeakMemory"].isNull())
+		detail_.peakMemory = std::stol(detailNode["PeakMemory"].asString());
+	if(!detailNode["ClientIP"].isNull())
+		detail_.clientIP = detailNode["ClientIP"].asString();
 	if(!detailNode["PlanningTime"].isNull())
 		detail_.planningTime = std::stol(detailNode["PlanningTime"].asString());
 	if(!detailNode["CPUTime"].isNull())
 		detail_.cPUTime = std::stol(detailNode["CPUTime"].asString());
-	if(!detailNode["PeakMemory"].isNull())
-		detail_.peakMemory = std::stol(detailNode["PeakMemory"].asString());
 	if(!value["OriginInfo"].isNull())
 		originInfo_ = value["OriginInfo"].asString();
 

adb/src/model/DescribeSQLPlanTaskRequest.cc

@@ -1,117 +1,99 @@
 /*
  * 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/adb/model/DescribeSQLPlanTaskRequest.h>
-
-using AlibabaCloud::Adb::Model::DescribeSQLPlanTaskRequest;
-
-DescribeSQLPlanTaskRequest::DescribeSQLPlanTaskRequest() :
-	RpcServiceRequest("adb", "2019-03-15", "DescribeSQLPlanTask")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeSQLPlanTaskRequest::~DescribeSQLPlanTaskRequest()
-{}
-
-long DescribeSQLPlanTaskRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/adb/model/DescribeSQLPlanTaskRequest.h>
+
+using AlibabaCloud::Adb::Model::DescribeSQLPlanTaskRequest;
+
+DescribeSQLPlanTaskRequest::DescribeSQLPlanTaskRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DescribeSQLPlanTask") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeSQLPlanTaskRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+DescribeSQLPlanTaskRequest::~DescribeSQLPlanTaskRequest() {}
+
+long DescribeSQLPlanTaskRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string DescribeSQLPlanTaskRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
+void DescribeSQLPlanTaskRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void DescribeSQLPlanTaskRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+std::string DescribeSQLPlanTaskRequest::getAccessKeyId() const {
+  return accessKeyId_;
 }
 
-std::string DescribeSQLPlanTaskRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void DescribeSQLPlanTaskRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-void DescribeSQLPlanTaskRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string DescribeSQLPlanTaskRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string DescribeSQLPlanTaskRequest::getDBClusterId()const
-{
-	return dBClusterId_;
+void DescribeSQLPlanTaskRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void DescribeSQLPlanTaskRequest::setDBClusterId(const std::string& dBClusterId)
-{
-	dBClusterId_ = dBClusterId;
-	setParameter("DBClusterId", dBClusterId);
+std::string DescribeSQLPlanTaskRequest::getDBClusterId() const {
+  return dBClusterId_;
 }
 
-std::string DescribeSQLPlanTaskRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void DescribeSQLPlanTaskRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
 }
 
-void DescribeSQLPlanTaskRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string DescribeSQLPlanTaskRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long DescribeSQLPlanTaskRequest::getOwnerId()const
-{
-	return ownerId_;
+void DescribeSQLPlanTaskRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void DescribeSQLPlanTaskRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long DescribeSQLPlanTaskRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string DescribeSQLPlanTaskRequest::getProcessId()const
-{
-	return processId_;
+void DescribeSQLPlanTaskRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void DescribeSQLPlanTaskRequest::setProcessId(const std::string& processId)
-{
-	processId_ = processId;
-	setParameter("ProcessId", processId);
+std::string DescribeSQLPlanTaskRequest::getProcessId() const {
+  return processId_;
 }
 
-std::string DescribeSQLPlanTaskRequest::getStageId()const
-{
-	return stageId_;
+void DescribeSQLPlanTaskRequest::setProcessId(const std::string &processId) {
+  processId_ = processId;
+  setParameter(std::string("ProcessId"), processId);
 }
 
-void DescribeSQLPlanTaskRequest::setStageId(const std::string& stageId)
-{
-	stageId_ = stageId;
-	setParameter("StageId", stageId);
+std::string DescribeSQLPlanTaskRequest::getStageId() const {
+  return stageId_;
+}
+
+void DescribeSQLPlanTaskRequest::setStageId(const std::string &stageId) {
+  stageId_ = stageId;
+  setParameter(std::string("StageId"), stageId);
 }
 

adb/src/model/DescribeSQLPlanTaskResult.cc

@@ -43,30 +43,30 @@ void DescribeSQLPlanTaskResult::parse(const std::string &payload)
 	for (auto valueTaskListSqlPlanTask : allTaskListNode)
 	{
 		SqlPlanTask taskListObject;
-		if(!valueTaskListSqlPlanTask["TaskId"].isNull())
-			taskListObject.taskId = std::stoi(valueTaskListSqlPlanTask["TaskId"].asString());
-		if(!valueTaskListSqlPlanTask["State"].isNull())
-			taskListObject.state = valueTaskListSqlPlanTask["State"].asString();
-		if(!valueTaskListSqlPlanTask["ElapsedTime"].isNull())
-			taskListObject.elapsedTime = std::stol(valueTaskListSqlPlanTask["ElapsedTime"].asString());
-		if(!valueTaskListSqlPlanTask["PeakMemory"].isNull())
-			taskListObject.peakMemory = std::stol(valueTaskListSqlPlanTask["PeakMemory"].asString());
-		if(!valueTaskListSqlPlanTask["OperatorCost"].isNull())
-			taskListObject.operatorCost = std::stol(valueTaskListSqlPlanTask["OperatorCost"].asString());
-		if(!valueTaskListSqlPlanTask["InputRows"].isNull())
-			taskListObject.inputRows = std::stol(valueTaskListSqlPlanTask["InputRows"].asString());
-		if(!valueTaskListSqlPlanTask["InputSize"].isNull())
-			taskListObject.inputSize = std::stol(valueTaskListSqlPlanTask["InputSize"].asString());
-		if(!valueTaskListSqlPlanTask["OutputRows"].isNull())
-			taskListObject.outputRows = std::stol(valueTaskListSqlPlanTask["OutputRows"].asString());
-		if(!valueTaskListSqlPlanTask["OutputSize"].isNull())
-			taskListObject.outputSize = std::stol(valueTaskListSqlPlanTask["OutputSize"].asString());
-		if(!valueTaskListSqlPlanTask["ScanRows"].isNull())
-			taskListObject.scanRows = std::stol(valueTaskListSqlPlanTask["ScanRows"].asString());
-		if(!valueTaskListSqlPlanTask["ScanSize"].isNull())
-			taskListObject.scanSize = std::stol(valueTaskListSqlPlanTask["ScanSize"].asString());
 		if(!valueTaskListSqlPlanTask["ScanCost"].isNull())
 			taskListObject.scanCost = std::stol(valueTaskListSqlPlanTask["ScanCost"].asString());
+		if(!valueTaskListSqlPlanTask["OutputSize"].isNull())
+			taskListObject.outputSize = std::stol(valueTaskListSqlPlanTask["OutputSize"].asString());
+		if(!valueTaskListSqlPlanTask["InputSize"].isNull())
+			taskListObject.inputSize = std::stol(valueTaskListSqlPlanTask["InputSize"].asString());
+		if(!valueTaskListSqlPlanTask["State"].isNull())
+			taskListObject.state = valueTaskListSqlPlanTask["State"].asString();
+		if(!valueTaskListSqlPlanTask["OperatorCost"].isNull())
+			taskListObject.operatorCost = std::stol(valueTaskListSqlPlanTask["OperatorCost"].asString());
+		if(!valueTaskListSqlPlanTask["OutputRows"].isNull())
+			taskListObject.outputRows = std::stol(valueTaskListSqlPlanTask["OutputRows"].asString());
+		if(!valueTaskListSqlPlanTask["ScanSize"].isNull())
+			taskListObject.scanSize = std::stol(valueTaskListSqlPlanTask["ScanSize"].asString());
+		if(!valueTaskListSqlPlanTask["ElapsedTime"].isNull())
+			taskListObject.elapsedTime = std::stol(valueTaskListSqlPlanTask["ElapsedTime"].asString());
+		if(!valueTaskListSqlPlanTask["ScanRows"].isNull())
+			taskListObject.scanRows = std::stol(valueTaskListSqlPlanTask["ScanRows"].asString());
+		if(!valueTaskListSqlPlanTask["PeakMemory"].isNull())
+			taskListObject.peakMemory = std::stol(valueTaskListSqlPlanTask["PeakMemory"].asString());
+		if(!valueTaskListSqlPlanTask["TaskId"].isNull())
+			taskListObject.taskId = std::stoi(valueTaskListSqlPlanTask["TaskId"].asString());
+		if(!valueTaskListSqlPlanTask["InputRows"].isNull())
+			taskListObject.inputRows = std::stol(valueTaskListSqlPlanTask["InputRows"].asString());
 		taskList_.push_back(taskListObject);
 	}
 

adb/src/model/DescribeSchemasRequest.cc

@@ -1,95 +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/adb/model/DescribeSchemasRequest.h>
-
-using AlibabaCloud::Adb::Model::DescribeSchemasRequest;
-
-DescribeSchemasRequest::DescribeSchemasRequest() :
-	RpcServiceRequest("adb", "2019-03-15", "DescribeSchemas")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeSchemasRequest::~DescribeSchemasRequest()
-{}
-
-long DescribeSchemasRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/adb/model/DescribeSchemasRequest.h>
+
+using AlibabaCloud::Adb::Model::DescribeSchemasRequest;
+
+DescribeSchemasRequest::DescribeSchemasRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DescribeSchemas") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeSchemasRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+DescribeSchemasRequest::~DescribeSchemasRequest() {}
+
+long DescribeSchemasRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string DescribeSchemasRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
+void DescribeSchemasRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void DescribeSchemasRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+std::string DescribeSchemasRequest::getAccessKeyId() const {
+  return accessKeyId_;
 }
 
-std::string DescribeSchemasRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void DescribeSchemasRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-void DescribeSchemasRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string DescribeSchemasRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string DescribeSchemasRequest::getDBClusterId()const
-{
-	return dBClusterId_;
+void DescribeSchemasRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void DescribeSchemasRequest::setDBClusterId(const std::string& dBClusterId)
-{
-	dBClusterId_ = dBClusterId;
-	setParameter("DBClusterId", dBClusterId);
+std::string DescribeSchemasRequest::getDBClusterId() const {
+  return dBClusterId_;
 }
 
-std::string DescribeSchemasRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void DescribeSchemasRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
 }
 
-void DescribeSchemasRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string DescribeSchemasRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-long DescribeSchemasRequest::getOwnerId()const
-{
-	return ownerId_;
+void DescribeSchemasRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void DescribeSchemasRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long DescribeSchemasRequest::getOwnerId() const {
+  return ownerId_;
+}
+
+void DescribeSchemasRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 

adb/src/model/DescribeSlowLogRecordsRequest.cc

@@ -1,194 +1,162 @@
 /*
  * 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/adb/model/DescribeSlowLogRecordsRequest.h>
-
-using AlibabaCloud::Adb::Model::DescribeSlowLogRecordsRequest;
-
-DescribeSlowLogRecordsRequest::DescribeSlowLogRecordsRequest() :
-	RpcServiceRequest("adb", "2019-03-15", "DescribeSlowLogRecords")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeSlowLogRecordsRequest::~DescribeSlowLogRecordsRequest()
-{}
-
-long DescribeSlowLogRecordsRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/adb/model/DescribeSlowLogRecordsRequest.h>
+
+using AlibabaCloud::Adb::Model::DescribeSlowLogRecordsRequest;
+
+DescribeSlowLogRecordsRequest::DescribeSlowLogRecordsRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DescribeSlowLogRecords") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeSlowLogRecordsRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+DescribeSlowLogRecordsRequest::~DescribeSlowLogRecordsRequest() {}
+
+long DescribeSlowLogRecordsRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string DescribeSlowLogRecordsRequest::getRange()const
-{
-	return range_;
+void DescribeSlowLogRecordsRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void DescribeSlowLogRecordsRequest::setRange(const std::string& range)
-{
-	range_ = range;
-	setParameter("Range", range);
+std::string DescribeSlowLogRecordsRequest::getRange() const {
+  return range_;
 }
 
-std::string DescribeSlowLogRecordsRequest::getStartTime()const
-{
-	return startTime_;
+void DescribeSlowLogRecordsRequest::setRange(const std::string &range) {
+  range_ = range;
+  setParameter(std::string("Range"), range);
 }
 
-void DescribeSlowLogRecordsRequest::setStartTime(const std::string& startTime)
-{
-	startTime_ = startTime;
-	setParameter("StartTime", startTime);
+std::string DescribeSlowLogRecordsRequest::getStartTime() const {
+  return startTime_;
 }
 
-int DescribeSlowLogRecordsRequest::getPageNumber()const
-{
-	return pageNumber_;
+void DescribeSlowLogRecordsRequest::setStartTime(const std::string &startTime) {
+  startTime_ = startTime;
+  setParameter(std::string("StartTime"), startTime);
 }
 
-void DescribeSlowLogRecordsRequest::setPageNumber(int pageNumber)
-{
-	pageNumber_ = pageNumber;
-	setParameter("PageNumber", std::to_string(pageNumber));
+int DescribeSlowLogRecordsRequest::getPageNumber() const {
+  return pageNumber_;
 }
 
-std::string DescribeSlowLogRecordsRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
+void DescribeSlowLogRecordsRequest::setPageNumber(int pageNumber) {
+  pageNumber_ = pageNumber;
+  setParameter(std::string("PageNumber"), std::to_string(pageNumber));
 }
 
-void DescribeSlowLogRecordsRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+std::string DescribeSlowLogRecordsRequest::getAccessKeyId() const {
+  return accessKeyId_;
 }
 
-int DescribeSlowLogRecordsRequest::getPageSize()const
-{
-	return pageSize_;
+void DescribeSlowLogRecordsRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-void DescribeSlowLogRecordsRequest::setPageSize(int pageSize)
-{
-	pageSize_ = pageSize;
-	setParameter("PageSize", std::to_string(pageSize));
+int DescribeSlowLogRecordsRequest::getPageSize() const {
+  return pageSize_;
 }
 
-std::string DescribeSlowLogRecordsRequest::getState()const
-{
-	return state_;
+void DescribeSlowLogRecordsRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
 }
 
-void DescribeSlowLogRecordsRequest::setState(const std::string& state)
-{
-	state_ = state;
-	setParameter("State", state);
+std::string DescribeSlowLogRecordsRequest::getState() const {
+  return state_;
 }
 
-std::string DescribeSlowLogRecordsRequest::getOrder()const
-{
-	return order_;
+void DescribeSlowLogRecordsRequest::setState(const std::string &state) {
+  state_ = state;
+  setParameter(std::string("State"), state);
 }
 
-void DescribeSlowLogRecordsRequest::setOrder(const std::string& order)
-{
-	order_ = order;
-	setParameter("Order", order);
+std::string DescribeSlowLogRecordsRequest::getOrder() const {
+  return order_;
 }
 
-std::string DescribeSlowLogRecordsRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void DescribeSlowLogRecordsRequest::setOrder(const std::string &order) {
+  order_ = order;
+  setParameter(std::string("Order"), order);
 }
 
-void DescribeSlowLogRecordsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string DescribeSlowLogRecordsRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string DescribeSlowLogRecordsRequest::getDBClusterId()const
-{
-	return dBClusterId_;
+void DescribeSlowLogRecordsRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void DescribeSlowLogRecordsRequest::setDBClusterId(const std::string& dBClusterId)
-{
-	dBClusterId_ = dBClusterId;
-	setParameter("DBClusterId", dBClusterId);
+std::string DescribeSlowLogRecordsRequest::getDBClusterId() const {
+  return dBClusterId_;
 }
 
-std::string DescribeSlowLogRecordsRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void DescribeSlowLogRecordsRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
 }
 
-void DescribeSlowLogRecordsRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string DescribeSlowLogRecordsRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-std::string DescribeSlowLogRecordsRequest::getEndTime()const
-{
-	return endTime_;
+void DescribeSlowLogRecordsRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void DescribeSlowLogRecordsRequest::setEndTime(const std::string& endTime)
-{
-	endTime_ = endTime;
-	setParameter("EndTime", endTime);
+std::string DescribeSlowLogRecordsRequest::getEndTime() const {
+  return endTime_;
 }
 
-long DescribeSlowLogRecordsRequest::getOwnerId()const
-{
-	return ownerId_;
+void DescribeSlowLogRecordsRequest::setEndTime(const std::string &endTime) {
+  endTime_ = endTime;
+  setParameter(std::string("EndTime"), endTime);
 }
 
-void DescribeSlowLogRecordsRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long DescribeSlowLogRecordsRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string DescribeSlowLogRecordsRequest::getDBName()const
-{
-	return dBName_;
+void DescribeSlowLogRecordsRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void DescribeSlowLogRecordsRequest::setDBName(const std::string& dBName)
-{
-	dBName_ = dBName;
-	setParameter("DBName", dBName);
+std::string DescribeSlowLogRecordsRequest::getDBName() const {
+  return dBName_;
 }
 
-std::string DescribeSlowLogRecordsRequest::getProcessID()const
-{
-	return processID_;
+void DescribeSlowLogRecordsRequest::setDBName(const std::string &dBName) {
+  dBName_ = dBName;
+  setParameter(std::string("DBName"), dBName);
 }
 
-void DescribeSlowLogRecordsRequest::setProcessID(const std::string& processID)
-{
-	processID_ = processID;
-	setParameter("ProcessID", processID);
+std::string DescribeSlowLogRecordsRequest::getProcessID() const {
+  return processID_;
+}
+
+void DescribeSlowLogRecordsRequest::setProcessID(const std::string &processID) {
+  processID_ = processID;
+  setParameter(std::string("ProcessID"), processID);
 }
 

adb/src/model/DescribeSlowLogRecordsResult.cc

@@ -43,42 +43,42 @@ void DescribeSlowLogRecordsResult::parse(const std::string &payload)
 	for (auto valueItemsSlowLogRecord : allItemsNode)
 	{
 		SlowLogRecord itemsObject;
-		if(!valueItemsSlowLogRecord["OutputSize"].isNull())
-			itemsObject.outputSize = valueItemsSlowLogRecord["OutputSize"].asString();
-		if(!valueItemsSlowLogRecord["UserName"].isNull())
-			itemsObject.userName = valueItemsSlowLogRecord["UserName"].asString();
-		if(!valueItemsSlowLogRecord["PeakMemoryUsage"].isNull())
-			itemsObject.peakMemoryUsage = valueItemsSlowLogRecord["PeakMemoryUsage"].asString();
-		if(!valueItemsSlowLogRecord["ExecutionStartTime"].isNull())
-			itemsObject.executionStartTime = valueItemsSlowLogRecord["ExecutionStartTime"].asString();
-		if(!valueItemsSlowLogRecord["ParseRowCounts"].isNull())
-			itemsObject.parseRowCounts = std::stol(valueItemsSlowLogRecord["ParseRowCounts"].asString());
-		if(!valueItemsSlowLogRecord["QueryTime"].isNull())
-			itemsObject.queryTime = std::stol(valueItemsSlowLogRecord["QueryTime"].asString());
-		if(!valueItemsSlowLogRecord["ScanTime"].isNull())
-			itemsObject.scanTime = std::stol(valueItemsSlowLogRecord["ScanTime"].asString());
 		if(!valueItemsSlowLogRecord["HostAddress"].isNull())
 			itemsObject.hostAddress = valueItemsSlowLogRecord["HostAddress"].asString();
+		if(!valueItemsSlowLogRecord["ScanTime"].isNull())
+			itemsObject.scanTime = std::stol(valueItemsSlowLogRecord["ScanTime"].asString());
 		if(!valueItemsSlowLogRecord["SQLText"].isNull())
 			itemsObject.sQLText = valueItemsSlowLogRecord["SQLText"].asString();
-		if(!valueItemsSlowLogRecord["WallTime"].isNull())
-			itemsObject.wallTime = std::stol(valueItemsSlowLogRecord["WallTime"].asString());
-		if(!valueItemsSlowLogRecord["ScanRows"].isNull())
-			itemsObject.scanRows = std::stol(valueItemsSlowLogRecord["ScanRows"].asString());
+		if(!valueItemsSlowLogRecord["OutputSize"].isNull())
+			itemsObject.outputSize = valueItemsSlowLogRecord["OutputSize"].asString();
+		if(!valueItemsSlowLogRecord["PeakMemoryUsage"].isNull())
+			itemsObject.peakMemoryUsage = valueItemsSlowLogRecord["PeakMemoryUsage"].asString();
 		if(!valueItemsSlowLogRecord["State"].isNull())
 			itemsObject.state = valueItemsSlowLogRecord["State"].asString();
-		if(!valueItemsSlowLogRecord["ReturnRowCounts"].isNull())
-			itemsObject.returnRowCounts = std::stol(valueItemsSlowLogRecord["ReturnRowCounts"].asString());
-		if(!valueItemsSlowLogRecord["PlanningTime"].isNull())
-			itemsObject.planningTime = std::stol(valueItemsSlowLogRecord["PlanningTime"].asString());
-		if(!valueItemsSlowLogRecord["DBName"].isNull())
-			itemsObject.dBName = valueItemsSlowLogRecord["DBName"].asString();
-		if(!valueItemsSlowLogRecord["QueueTime"].isNull())
-			itemsObject.queueTime = std::stol(valueItemsSlowLogRecord["QueueTime"].asString());
-		if(!valueItemsSlowLogRecord["ProcessID"].isNull())
-			itemsObject.processID = valueItemsSlowLogRecord["ProcessID"].asString();
+		if(!valueItemsSlowLogRecord["WallTime"].isNull())
+			itemsObject.wallTime = std::stol(valueItemsSlowLogRecord["WallTime"].asString());
 		if(!valueItemsSlowLogRecord["ScanSize"].isNull())
 			itemsObject.scanSize = valueItemsSlowLogRecord["ScanSize"].asString();
+		if(!valueItemsSlowLogRecord["ExecutionStartTime"].isNull())
+			itemsObject.executionStartTime = valueItemsSlowLogRecord["ExecutionStartTime"].asString();
+		if(!valueItemsSlowLogRecord["QueryTime"].isNull())
+			itemsObject.queryTime = std::stol(valueItemsSlowLogRecord["QueryTime"].asString());
+		if(!valueItemsSlowLogRecord["ReturnRowCounts"].isNull())
+			itemsObject.returnRowCounts = std::stol(valueItemsSlowLogRecord["ReturnRowCounts"].asString());
+		if(!valueItemsSlowLogRecord["ScanRows"].isNull())
+			itemsObject.scanRows = std::stol(valueItemsSlowLogRecord["ScanRows"].asString());
+		if(!valueItemsSlowLogRecord["ParseRowCounts"].isNull())
+			itemsObject.parseRowCounts = std::stol(valueItemsSlowLogRecord["ParseRowCounts"].asString());
+		if(!valueItemsSlowLogRecord["DBName"].isNull())
+			itemsObject.dBName = valueItemsSlowLogRecord["DBName"].asString();
+		if(!valueItemsSlowLogRecord["PlanningTime"].isNull())
+			itemsObject.planningTime = std::stol(valueItemsSlowLogRecord["PlanningTime"].asString());
+		if(!valueItemsSlowLogRecord["QueueTime"].isNull())
+			itemsObject.queueTime = std::stol(valueItemsSlowLogRecord["QueueTime"].asString());
+		if(!valueItemsSlowLogRecord["UserName"].isNull())
+			itemsObject.userName = valueItemsSlowLogRecord["UserName"].asString();
+		if(!valueItemsSlowLogRecord["ProcessID"].isNull())
+			itemsObject.processID = valueItemsSlowLogRecord["ProcessID"].asString();
 		items_.push_back(itemsObject);
 	}
 	if(!value["TotalCount"].isNull())

adb/src/model/DescribeSlowLogTrendRequest.cc

@@ -1,128 +1,108 @@
 /*
  * 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/adb/model/DescribeSlowLogTrendRequest.h>
-
-using AlibabaCloud::Adb::Model::DescribeSlowLogTrendRequest;
-
-DescribeSlowLogTrendRequest::DescribeSlowLogTrendRequest() :
-	RpcServiceRequest("adb", "2019-03-15", "DescribeSlowLogTrend")
-{
-	setMethod(HttpRequest::Method::Post);
-}
-
-DescribeSlowLogTrendRequest::~DescribeSlowLogTrendRequest()
-{}
-
-long DescribeSlowLogTrendRequest::getResourceOwnerId()const
-{
-	return resourceOwnerId_;
+ */
+
+#include <alibabacloud/adb/model/DescribeSlowLogTrendRequest.h>
+
+using AlibabaCloud::Adb::Model::DescribeSlowLogTrendRequest;
+
+DescribeSlowLogTrendRequest::DescribeSlowLogTrendRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DescribeSlowLogTrend") {
+  setMethod(HttpRequest::Method::Post);
 }
 
-void DescribeSlowLogTrendRequest::setResourceOwnerId(long resourceOwnerId)
-{
-	resourceOwnerId_ = resourceOwnerId;
-	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+DescribeSlowLogTrendRequest::~DescribeSlowLogTrendRequest() {}
+
+long DescribeSlowLogTrendRequest::getResourceOwnerId() const {
+  return resourceOwnerId_;
 }
 
-std::string DescribeSlowLogTrendRequest::getStartTime()const
-{
-	return startTime_;
+void DescribeSlowLogTrendRequest::setResourceOwnerId(long resourceOwnerId) {
+  resourceOwnerId_ = resourceOwnerId;
+  setParameter(std::string("ResourceOwnerId"), std::to_string(resourceOwnerId));
 }
 
-void DescribeSlowLogTrendRequest::setStartTime(const std::string& startTime)
-{
-	startTime_ = startTime;
-	setParameter("StartTime", startTime);
+std::string DescribeSlowLogTrendRequest::getStartTime() const {
+  return startTime_;
 }
 
-std::string DescribeSlowLogTrendRequest::getAccessKeyId()const
-{
-	return accessKeyId_;
+void DescribeSlowLogTrendRequest::setStartTime(const std::string &startTime) {
+  startTime_ = startTime;
+  setParameter(std::string("StartTime"), startTime);
 }
 
-void DescribeSlowLogTrendRequest::setAccessKeyId(const std::string& accessKeyId)
-{
-	accessKeyId_ = accessKeyId;
-	setParameter("AccessKeyId", accessKeyId);
+std::string DescribeSlowLogTrendRequest::getAccessKeyId() const {
+  return accessKeyId_;
 }
 
-std::string DescribeSlowLogTrendRequest::getResourceOwnerAccount()const
-{
-	return resourceOwnerAccount_;
+void DescribeSlowLogTrendRequest::setAccessKeyId(const std::string &accessKeyId) {
+  accessKeyId_ = accessKeyId;
+  setParameter(std::string("AccessKeyId"), accessKeyId);
 }
 
-void DescribeSlowLogTrendRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
-{
-	resourceOwnerAccount_ = resourceOwnerAccount;
-	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+std::string DescribeSlowLogTrendRequest::getResourceOwnerAccount() const {
+  return resourceOwnerAccount_;
 }
 
-std::string DescribeSlowLogTrendRequest::getDBClusterId()const
-{
-	return dBClusterId_;
+void DescribeSlowLogTrendRequest::setResourceOwnerAccount(const std::string &resourceOwnerAccount) {
+  resourceOwnerAccount_ = resourceOwnerAccount;
+  setParameter(std::string("ResourceOwnerAccount"), resourceOwnerAccount);
 }
 
-void DescribeSlowLogTrendRequest::setDBClusterId(const std::string& dBClusterId)
-{
-	dBClusterId_ = dBClusterId;
-	setParameter("DBClusterId", dBClusterId);
+std::string DescribeSlowLogTrendRequest::getDBClusterId() const {
+  return dBClusterId_;
 }
 
-std::string DescribeSlowLogTrendRequest::getOwnerAccount()const
-{
-	return ownerAccount_;
+void DescribeSlowLogTrendRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
 }
 
-void DescribeSlowLogTrendRequest::setOwnerAccount(const std::string& ownerAccount)
-{
-	ownerAccount_ = ownerAccount;
-	setParameter("OwnerAccount", ownerAccount);
+std::string DescribeSlowLogTrendRequest::getOwnerAccount() const {
+  return ownerAccount_;
 }
 
-std::string DescribeSlowLogTrendRequest::getEndTime()const
-{
-	return endTime_;
+void DescribeSlowLogTrendRequest::setOwnerAccount(const std::string &ownerAccount) {
+  ownerAccount_ = ownerAccount;
+  setParameter(std::string("OwnerAccount"), ownerAccount);
 }
 
-void DescribeSlowLogTrendRequest::setEndTime(const std::string& endTime)
-{
-	endTime_ = endTime;
-	setParameter("EndTime", endTime);
+std::string DescribeSlowLogTrendRequest::getEndTime() const {
+  return endTime_;
 }
 
-long DescribeSlowLogTrendRequest::getOwnerId()const
-{
-	return ownerId_;
+void DescribeSlowLogTrendRequest::setEndTime(const std::string &endTime) {
+  endTime_ = endTime;
+  setParameter(std::string("EndTime"), endTime);
 }
 
-void DescribeSlowLogTrendRequest::setOwnerId(long ownerId)
-{
-	ownerId_ = ownerId;
-	setParameter("OwnerId", std::to_string(ownerId));
+long DescribeSlowLogTrendRequest::getOwnerId() const {
+  return ownerId_;
 }
 
-std::string DescribeSlowLogTrendRequest::getDBName()const
-{
-	return dBName_;
+void DescribeSlowLogTrendRequest::setOwnerId(long ownerId) {
+  ownerId_ = ownerId;
+  setParameter(std::string("OwnerId"), std::to_string(ownerId));
 }
 
-void DescribeSlowLogTrendRequest::setDBName(const std::string& dBName)
-{
-	dBName_ = dBName;
-	setParameter("DBName", dBName);
+std::string DescribeSlowLogTrendRequest::getDBName() const {
+  return dBName_;
+}
+
+void DescribeSlowLogTrendRequest::setDBName(const std::string &dBName) {
+  dBName_ = dBName;
+  setParameter(std::string("DBName"), dBName);
 }
 

adb/src/model/DescribeSlowLogTrendResult.cc

@@ -51,20 +51,20 @@ void DescribeSlowLogTrendResult::parse(const std::string &payload)
 		for (auto valueItemsSlowLogTrendItemSeriesSeriesItem : allSeriesNode)
 		{
 			SlowLogTrendItem::SeriesItem seriesObject;
-			if(!valueItemsSlowLogTrendItemSeriesSeriesItem["Name"].isNull())
-				seriesObject.name = valueItemsSlowLogTrendItemSeriesSeriesItem["Name"].asString();
 			if(!valueItemsSlowLogTrendItemSeriesSeriesItem["Values"].isNull())
 				seriesObject.values = valueItemsSlowLogTrendItemSeriesSeriesItem["Values"].asString();
+			if(!valueItemsSlowLogTrendItemSeriesSeriesItem["Name"].isNull())
+				seriesObject.name = valueItemsSlowLogTrendItemSeriesSeriesItem["Name"].asString();
 			itemsObject.series.push_back(seriesObject);
 		}
 		items_.push_back(itemsObject);
 	}
-	if(!value["DBClusterId"].isNull())
-		dBClusterId_ = value["DBClusterId"].asString();
-	if(!value["StartTime"].isNull())
-		startTime_ = value["StartTime"].asString();
 	if(!value["EndTime"].isNull())
 		endTime_ = value["EndTime"].asString();
+	if(!value["StartTime"].isNull())
+		startTime_ = value["StartTime"].asString();
+	if(!value["DBClusterId"].isNull())
+		dBClusterId_ = value["DBClusterId"].asString();
 
 }
 
@@ -73,16 +73,16 @@ std::string DescribeSlowLogTrendResult::getEndTime()const
 	return endTime_;
 }
 
-std::string DescribeSlowLogTrendResult::getDBClusterId()const
-{
-	return dBClusterId_;
-}
-
 std::string DescribeSlowLogTrendResult::getStartTime()const
 {
 	return startTime_;
 }
 
+std::string DescribeSlowLogTrendResult::getDBClusterId()const
+{
+	return dBClusterId_;
+}
+
 std::vector<DescribeSlowLogTrendResult::SlowLogTrendItem> DescribeSlowLogTrendResult::getItems()const
 {
 	return items_;

adb/src/model/DescribeSqlPatternRequest.cc

@@ -0,0 +1,99 @@
+/*
+ * 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/adb/model/DescribeSqlPatternRequest.h>
+
+using AlibabaCloud::Adb::Model::DescribeSqlPatternRequest;
+
+DescribeSqlPatternRequest::DescribeSqlPatternRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DescribeSqlPattern") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeSqlPatternRequest::~DescribeSqlPatternRequest() {}
+
+std::string DescribeSqlPatternRequest::getDBClusterId() const {
+  return dBClusterId_;
+}
+
+void DescribeSqlPatternRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
+}
+
+std::string DescribeSqlPatternRequest::getSqlPattern() const {
+  return sqlPattern_;
+}
+
+void DescribeSqlPatternRequest::setSqlPattern(const std::string &sqlPattern) {
+  sqlPattern_ = sqlPattern;
+  setParameter(std::string("SqlPattern"), sqlPattern);
+}
+
+std::string DescribeSqlPatternRequest::getStartTime() const {
+  return startTime_;
+}
+
+void DescribeSqlPatternRequest::setStartTime(const std::string &startTime) {
+  startTime_ = startTime;
+  setParameter(std::string("StartTime"), startTime);
+}
+
+std::string DescribeSqlPatternRequest::getType() const {
+  return type_;
+}
+
+void DescribeSqlPatternRequest::setType(const std::string &type) {
+  type_ = type;
+  setParameter(std::string("Type"), type);
+}
+
+int DescribeSqlPatternRequest::getPageNumber() const {
+  return pageNumber_;
+}
+
+void DescribeSqlPatternRequest::setPageNumber(int pageNumber) {
+  pageNumber_ = pageNumber;
+  setParameter(std::string("PageNumber"), std::to_string(pageNumber));
+}
+
+std::string DescribeSqlPatternRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeSqlPatternRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+int DescribeSqlPatternRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void DescribeSqlPatternRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+
+std::string DescribeSqlPatternRequest::getOrder() const {
+  return order_;
+}
+
+void DescribeSqlPatternRequest::setOrder(const std::string &order) {
+  order_ = order;
+  setParameter(std::string("Order"), order);
+}
+

adb/src/model/DescribeSqlPatternResult.cc

@@ -0,0 +1,108 @@
+/*
+ * 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/adb/model/DescribeSqlPatternResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Adb;
+using namespace AlibabaCloud::Adb::Model;
+
+DescribeSqlPatternResult::DescribeSqlPatternResult() :
+	ServiceResult()
+{}
+
+DescribeSqlPatternResult::DescribeSqlPatternResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeSqlPatternResult::~DescribeSqlPatternResult()
+{}
+
+void DescribeSqlPatternResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allItemsNode = value["Items"]["ItemsItem"];
+	for (auto valueItemsItemsItem : allItemsNode)
+	{
+		ItemsItem itemsObject;
+		if(!valueItemsItemsItem["AvgStageCount"].isNull())
+			itemsObject.avgStageCount = valueItemsItemsItem["AvgStageCount"].asString();
+		if(!valueItemsItemsItem["MaxCpuTime"].isNull())
+			itemsObject.maxCpuTime = valueItemsItemsItem["MaxCpuTime"].asString();
+		if(!valueItemsItemsItem["AccessIP"].isNull())
+			itemsObject.accessIP = valueItemsItemsItem["AccessIP"].asString();
+		if(!valueItemsItemsItem["AvgScanSize"].isNull())
+			itemsObject.avgScanSize = valueItemsItemsItem["AvgScanSize"].asString();
+		if(!valueItemsItemsItem["MaxScanSize"].isNull())
+			itemsObject.maxScanSize = valueItemsItemsItem["MaxScanSize"].asString();
+		if(!valueItemsItemsItem["MaxPeakMemory"].isNull())
+			itemsObject.maxPeakMemory = valueItemsItemsItem["MaxPeakMemory"].asString();
+		if(!valueItemsItemsItem["AvgCpuTime"].isNull())
+			itemsObject.avgCpuTime = valueItemsItemsItem["AvgCpuTime"].asString();
+		if(!valueItemsItemsItem["User"].isNull())
+			itemsObject.user = valueItemsItemsItem["User"].asString();
+		if(!valueItemsItemsItem["AvgPeakMemory"].isNull())
+			itemsObject.avgPeakMemory = valueItemsItemsItem["AvgPeakMemory"].asString();
+		if(!valueItemsItemsItem["MaxStageCount"].isNull())
+			itemsObject.maxStageCount = valueItemsItemsItem["MaxStageCount"].asString();
+		if(!valueItemsItemsItem["MaxTaskCount"].isNull())
+			itemsObject.maxTaskCount = valueItemsItemsItem["MaxTaskCount"].asString();
+		if(!valueItemsItemsItem["InstanceName"].isNull())
+			itemsObject.instanceName = valueItemsItemsItem["InstanceName"].asString();
+		if(!valueItemsItemsItem["QueryCount"].isNull())
+			itemsObject.queryCount = valueItemsItemsItem["QueryCount"].asString();
+		if(!valueItemsItemsItem["ReportDate"].isNull())
+			itemsObject.reportDate = valueItemsItemsItem["ReportDate"].asString();
+		if(!valueItemsItemsItem["Pattern"].isNull())
+			itemsObject.pattern = valueItemsItemsItem["Pattern"].asString();
+		if(!valueItemsItemsItem["AvgTaskCount"].isNull())
+			itemsObject.avgTaskCount = valueItemsItemsItem["AvgTaskCount"].asString();
+		items_.push_back(itemsObject);
+	}
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
+
+}
+
+int DescribeSqlPatternResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+int DescribeSqlPatternResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int DescribeSqlPatternResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::vector<DescribeSqlPatternResult::ItemsItem> DescribeSqlPatternResult::getItems()const
+{
+	return items_;
+}
+

adb/src/model/DescribeTableAccessCountRequest.cc

@@ -0,0 +1,90 @@
+/*
+ * 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/adb/model/DescribeTableAccessCountRequest.h>
+
+using AlibabaCloud::Adb::Model::DescribeTableAccessCountRequest;
+
+DescribeTableAccessCountRequest::DescribeTableAccessCountRequest()
+    : RpcServiceRequest("adb", "2019-03-15", "DescribeTableAccessCount") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeTableAccessCountRequest::~DescribeTableAccessCountRequest() {}
+
+std::string DescribeTableAccessCountRequest::getDBClusterId() const {
+  return dBClusterId_;
+}
+
+void DescribeTableAccessCountRequest::setDBClusterId(const std::string &dBClusterId) {
+  dBClusterId_ = dBClusterId;
+  setParameter(std::string("DBClusterId"), dBClusterId);
+}
+
+std::string DescribeTableAccessCountRequest::getStartTime() const {
+  return startTime_;
+}
+
+void DescribeTableAccessCountRequest::setStartTime(const std::string &startTime) {
+  startTime_ = startTime;
+  setParameter(std::string("StartTime"), startTime);
+}
+
+int DescribeTableAccessCountRequest::getPageNumber() const {
+  return pageNumber_;
+}
+
+void DescribeTableAccessCountRequest::setPageNumber(int pageNumber) {
+  pageNumber_ = pageNumber;
+  setParameter(std::string("PageNumber"), std::to_string(pageNumber));
+}
+
+std::string DescribeTableAccessCountRequest::getRegionId() const {
+  return regionId_;
+}
+
+void DescribeTableAccessCountRequest::setRegionId(const std::string &regionId) {
+  regionId_ = regionId;
+  setParameter(std::string("RegionId"), regionId);
+}
+
+int DescribeTableAccessCountRequest::getPageSize() const {
+  return pageSize_;
+}
+
+void DescribeTableAccessCountRequest::setPageSize(int pageSize) {
+  pageSize_ = pageSize;
+  setParameter(std::string("PageSize"), std::to_string(pageSize));
+}
+
+std::string DescribeTableAccessCountRequest::getTableName() const {
+  return tableName_;
+}
+
+void DescribeTableAccessCountRequest::setTableName(const std::string &tableName) {
+  tableName_ = tableName;
+  setParameter(std::string("TableName"), tableName);
+}
+
+std::string DescribeTableAccessCountRequest::getOrder() const {
+  return order_;
+}
+
+void DescribeTableAccessCountRequest::setOrder(const std::string &order) {
+  order_ = order;
+  setParameter(std::string("Order"), order);
+}
+

adb/src/model/DescribeTableAccessCountResult.cc

@@ -0,0 +1,86 @@
+/*
+ * 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/adb/model/DescribeTableAccessCountResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Adb;
+using namespace AlibabaCloud::Adb::Model;
+
+DescribeTableAccessCountResult::DescribeTableAccessCountResult() :
+	ServiceResult()
+{}
+
+DescribeTableAccessCountResult::DescribeTableAccessCountResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeTableAccessCountResult::~DescribeTableAccessCountResult()
+{}
+
+void DescribeTableAccessCountResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allItemsNode = value["Items"]["ItemsItem"];
+	for (auto valueItemsItemsItem : allItemsNode)
+	{
+		ItemsItem itemsObject;
+		if(!valueItemsItemsItem["ReportDate"].isNull())
+			itemsObject.reportDate = valueItemsItemsItem["ReportDate"].asString();
+		if(!valueItemsItemsItem["TableSchema"].isNull())
+			itemsObject.tableSchema = valueItemsItemsItem["TableSchema"].asString();
+		if(!valueItemsItemsItem["AccessCount"].isNull())
+			itemsObject.accessCount = valueItemsItemsItem["AccessCount"].asString();
+		if(!valueItemsItemsItem["TableName"].isNull())
+			itemsObject.tableName = valueItemsItemsItem["TableName"].asString();
+		if(!valueItemsItemsItem["InstanceName"].isNull())
+			itemsObject.instanceName = valueItemsItemsItem["InstanceName"].asString();
+		items_.push_back(itemsObject);
+	}
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = std::stoi(value["PageNumber"].asString());
+	if(!value["PageSize"].isNull())
+		pageSize_ = std::stoi(value["PageSize"].asString());
+	if(!value["TotalCount"].isNull())
+		totalCount_ = std::stoi(value["TotalCount"].asString());
+
+}
+
+int DescribeTableAccessCountResult::getTotalCount()const
+{
+	return totalCount_;
+}
+
+int DescribeTableAccessCountResult::getPageSize()const
+{
+	return pageSize_;
+}
+
+int DescribeTableAccessCountResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::vector<DescribeTableAccessCountResult::ItemsItem> DescribeTableAccessCountResult::getItems()const
+{
+	return items_;
+}
+