Support CreationCategory for CreateDBCluster.

CHANGELOG

@@ -1,3 +1,9 @@
+2020-05-11 Version: 1.36.402
+- Support CreationCategory for CreateDBCluster.
+
+2020-05-09 Version: 1.36.401
+- Generated 2019-01-01 for `Cassandra`.
+
 2020-05-09 Version: 1.36.400
 - VideoSearch deploy SDK.
 

VERSION

@@ -1 +1 @@
-1.36.400
+1.36.402

cassandra/CMakeLists.txt

@@ -57,6 +57,8 @@ set(cassandra_public_header_model
 	include/alibabacloud/cassandra/model/DescribeClustersResult.h
 	include/alibabacloud/cassandra/model/DescribeContactPointsRequest.h
 	include/alibabacloud/cassandra/model/DescribeContactPointsResult.h
+	include/alibabacloud/cassandra/model/DescribeDataCenterRequest.h
+	include/alibabacloud/cassandra/model/DescribeDataCenterResult.h
 	include/alibabacloud/cassandra/model/DescribeDataCentersRequest.h
 	include/alibabacloud/cassandra/model/DescribeDataCentersResult.h
 	include/alibabacloud/cassandra/model/DescribeDeletedClustersRequest.h
@@ -160,6 +162,8 @@ set(cassandra_src
 	src/model/DescribeClustersResult.cc
 	src/model/DescribeContactPointsRequest.cc
 	src/model/DescribeContactPointsResult.cc
+	src/model/DescribeDataCenterRequest.cc
+	src/model/DescribeDataCenterResult.cc
 	src/model/DescribeDataCentersRequest.cc
 	src/model/DescribeDataCentersResult.cc
 	src/model/DescribeDeletedClustersRequest.cc

cassandra/include/alibabacloud/cassandra/CassandraClient.h

@@ -58,6 +58,8 @@
 #include "model/DescribeClustersResult.h"
 #include "model/DescribeContactPointsRequest.h"
 #include "model/DescribeContactPointsResult.h"
+#include "model/DescribeDataCenterRequest.h"
+#include "model/DescribeDataCenterResult.h"
 #include "model/DescribeDataCentersRequest.h"
 #include "model/DescribeDataCentersResult.h"
 #include "model/DescribeDeletedClustersRequest.h"
@@ -185,6 +187,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeContactPointsResult> DescribeContactPointsOutcome;
 			typedef std::future<DescribeContactPointsOutcome> DescribeContactPointsOutcomeCallable;
 			typedef std::function<void(const CassandraClient*, const Model::DescribeContactPointsRequest&, const DescribeContactPointsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeContactPointsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDataCenterResult> DescribeDataCenterOutcome;
+			typedef std::future<DescribeDataCenterOutcome> DescribeDataCenterOutcomeCallable;
+			typedef std::function<void(const CassandraClient*, const Model::DescribeDataCenterRequest&, const DescribeDataCenterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDataCenterAsyncHandler;
 			typedef Outcome<Error, Model::DescribeDataCentersResult> DescribeDataCentersOutcome;
 			typedef std::future<DescribeDataCentersOutcome> DescribeDataCentersOutcomeCallable;
 			typedef std::function<void(const CassandraClient*, const Model::DescribeDataCentersRequest&, const DescribeDataCentersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDataCentersAsyncHandler;
@@ -340,6 +345,9 @@ namespace AlibabaCloud
 			DescribeContactPointsOutcome describeContactPoints(const Model::DescribeContactPointsRequest &request)const;
 			void describeContactPointsAsync(const Model::DescribeContactPointsRequest& request, const DescribeContactPointsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeContactPointsOutcomeCallable describeContactPointsCallable(const Model::DescribeContactPointsRequest& request) const;
+			DescribeDataCenterOutcome describeDataCenter(const Model::DescribeDataCenterRequest &request)const;
+			void describeDataCenterAsync(const Model::DescribeDataCenterRequest& request, const DescribeDataCenterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDataCenterOutcomeCallable describeDataCenterCallable(const Model::DescribeDataCenterRequest& request) const;
 			DescribeDataCentersOutcome describeDataCenters(const Model::DescribeDataCentersRequest &request)const;
 			void describeDataCentersAsync(const Model::DescribeDataCentersRequest& request, const DescribeDataCentersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDataCentersOutcomeCallable describeDataCentersCallable(const Model::DescribeDataCentersRequest& request) const;

cassandra/include/alibabacloud/cassandra/model/DescribeDataCenterRequest.h

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_CASSANDRA_MODEL_DESCRIBEDATACENTERREQUEST_H_
+#define ALIBABACLOUD_CASSANDRA_MODEL_DESCRIBEDATACENTERREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/cassandra/CassandraExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Cassandra
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CASSANDRA_EXPORT DescribeDataCenterRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeDataCenterRequest();
+				~DescribeDataCenterRequest();
+
+				std::string getDataCenterId()const;
+				void setDataCenterId(const std::string& dataCenterId);
+				std::string getClusterId()const;
+				void setClusterId(const std::string& clusterId);
+
+            private:
+				std::string dataCenterId_;
+				std::string clusterId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CASSANDRA_MODEL_DESCRIBEDATACENTERREQUEST_H_

cassandra/include/alibabacloud/cassandra/model/DescribeDataCenterResult.h

@@ -0,0 +1,83 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_CASSANDRA_MODEL_DESCRIBEDATACENTERRESULT_H_
+#define ALIBABACLOUD_CASSANDRA_MODEL_DESCRIBEDATACENTERRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/cassandra/CassandraExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Cassandra
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_CASSANDRA_EXPORT DescribeDataCenterResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeDataCenterResult();
+				explicit DescribeDataCenterResult(const std::string &payload);
+				~DescribeDataCenterResult();
+				std::string getStatus()const;
+				std::string getDataCenterId()const;
+				std::string getCreatedTime()const;
+				std::string getCommodityInstance()const;
+				std::string getZoneId()const;
+				int getNodeCount()const;
+				std::string getClusterId()const;
+				std::string getPayType()const;
+				std::string getLockMode()const;
+				std::string getDataCenterName()const;
+				std::string getVswitchId()const;
+				std::string getDiskType()const;
+				std::string getVpcId()const;
+				int getDiskSize()const;
+				std::string getRegionId()const;
+				std::string getInstanceType()const;
+				std::string getExpireTime()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string status_;
+				std::string dataCenterId_;
+				std::string createdTime_;
+				std::string commodityInstance_;
+				std::string zoneId_;
+				int nodeCount_;
+				std::string clusterId_;
+				std::string payType_;
+				std::string lockMode_;
+				std::string dataCenterName_;
+				std::string vswitchId_;
+				std::string diskType_;
+				std::string vpcId_;
+				int diskSize_;
+				std::string regionId_;
+				std::string instanceType_;
+				std::string expireTime_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_CASSANDRA_MODEL_DESCRIBEDATACENTERRESULT_H_

cassandra/src/CassandraClient.cc

@@ -699,6 +699,42 @@ CassandraClient::DescribeContactPointsOutcomeCallable CassandraClient::describeC
 	return task->get_future();
 }
 
+CassandraClient::DescribeDataCenterOutcome CassandraClient::describeDataCenter(const DescribeDataCenterRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDataCenterOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDataCenterOutcome(DescribeDataCenterResult(outcome.result()));
+	else
+		return DescribeDataCenterOutcome(outcome.error());
+}
+
+void CassandraClient::describeDataCenterAsync(const DescribeDataCenterRequest& request, const DescribeDataCenterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDataCenter(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+CassandraClient::DescribeDataCenterOutcomeCallable CassandraClient::describeDataCenterCallable(const DescribeDataCenterRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDataCenterOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDataCenter(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 CassandraClient::DescribeDataCentersOutcome CassandraClient::describeDataCenters(const DescribeDataCentersRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

cassandra/src/model/DescribeDataCenterRequest.cc

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/cassandra/model/DescribeDataCenterRequest.h>
+
+using AlibabaCloud::Cassandra::Model::DescribeDataCenterRequest;
+
+DescribeDataCenterRequest::DescribeDataCenterRequest() :
+	RpcServiceRequest("cassandra", "2019-01-01", "DescribeDataCenter")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDataCenterRequest::~DescribeDataCenterRequest()
+{}
+
+std::string DescribeDataCenterRequest::getDataCenterId()const
+{
+	return dataCenterId_;
+}
+
+void DescribeDataCenterRequest::setDataCenterId(const std::string& dataCenterId)
+{
+	dataCenterId_ = dataCenterId;
+	setParameter("DataCenterId", dataCenterId);
+}
+
+std::string DescribeDataCenterRequest::getClusterId()const
+{
+	return clusterId_;
+}
+
+void DescribeDataCenterRequest::setClusterId(const std::string& clusterId)
+{
+	clusterId_ = clusterId;
+	setParameter("ClusterId", clusterId);
+}
+

cassandra/src/model/DescribeDataCenterResult.cc

@@ -0,0 +1,163 @@
+/*
+ * 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/cassandra/model/DescribeDataCenterResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Cassandra;
+using namespace AlibabaCloud::Cassandra::Model;
+
+DescribeDataCenterResult::DescribeDataCenterResult() :
+	ServiceResult()
+{}
+
+DescribeDataCenterResult::DescribeDataCenterResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDataCenterResult::~DescribeDataCenterResult()
+{}
+
+void DescribeDataCenterResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["DataCenterId"].isNull())
+		dataCenterId_ = value["DataCenterId"].asString();
+	if(!value["RegionId"].isNull())
+		regionId_ = value["RegionId"].asString();
+	if(!value["ZoneId"].isNull())
+		zoneId_ = value["ZoneId"].asString();
+	if(!value["ClusterId"].isNull())
+		clusterId_ = value["ClusterId"].asString();
+	if(!value["DataCenterName"].isNull())
+		dataCenterName_ = value["DataCenterName"].asString();
+	if(!value["Status"].isNull())
+		status_ = value["Status"].asString();
+	if(!value["CreatedTime"].isNull())
+		createdTime_ = value["CreatedTime"].asString();
+	if(!value["InstanceType"].isNull())
+		instanceType_ = value["InstanceType"].asString();
+	if(!value["NodeCount"].isNull())
+		nodeCount_ = std::stoi(value["NodeCount"].asString());
+	if(!value["DiskType"].isNull())
+		diskType_ = value["DiskType"].asString();
+	if(!value["DiskSize"].isNull())
+		diskSize_ = std::stoi(value["DiskSize"].asString());
+	if(!value["VpcId"].isNull())
+		vpcId_ = value["VpcId"].asString();
+	if(!value["VswitchId"].isNull())
+		vswitchId_ = value["VswitchId"].asString();
+	if(!value["PayType"].isNull())
+		payType_ = value["PayType"].asString();
+	if(!value["CommodityInstance"].isNull())
+		commodityInstance_ = value["CommodityInstance"].asString();
+	if(!value["ExpireTime"].isNull())
+		expireTime_ = value["ExpireTime"].asString();
+	if(!value["LockMode"].isNull())
+		lockMode_ = value["LockMode"].asString();
+
+}
+
+std::string DescribeDataCenterResult::getStatus()const
+{
+	return status_;
+}
+
+std::string DescribeDataCenterResult::getDataCenterId()const
+{
+	return dataCenterId_;
+}
+
+std::string DescribeDataCenterResult::getCreatedTime()const
+{
+	return createdTime_;
+}
+
+std::string DescribeDataCenterResult::getCommodityInstance()const
+{
+	return commodityInstance_;
+}
+
+std::string DescribeDataCenterResult::getZoneId()const
+{
+	return zoneId_;
+}
+
+int DescribeDataCenterResult::getNodeCount()const
+{
+	return nodeCount_;
+}
+
+std::string DescribeDataCenterResult::getClusterId()const
+{
+	return clusterId_;
+}
+
+std::string DescribeDataCenterResult::getPayType()const
+{
+	return payType_;
+}
+
+std::string DescribeDataCenterResult::getLockMode()const
+{
+	return lockMode_;
+}
+
+std::string DescribeDataCenterResult::getDataCenterName()const
+{
+	return dataCenterName_;
+}
+
+std::string DescribeDataCenterResult::getVswitchId()const
+{
+	return vswitchId_;
+}
+
+std::string DescribeDataCenterResult::getDiskType()const
+{
+	return diskType_;
+}
+
+std::string DescribeDataCenterResult::getVpcId()const
+{
+	return vpcId_;
+}
+
+int DescribeDataCenterResult::getDiskSize()const
+{
+	return diskSize_;
+}
+
+std::string DescribeDataCenterResult::getRegionId()const
+{
+	return regionId_;
+}
+
+std::string DescribeDataCenterResult::getInstanceType()const
+{
+	return instanceType_;
+}
+
+std::string DescribeDataCenterResult::getExpireTime()const
+{
+	return expireTime_;
+}
+

polardb/CMakeLists.txt

@@ -81,10 +81,16 @@ set(polardb_public_header_model
 	include/alibabacloud/polardb/model/DescribeDBClusterSSLResult.h
 	include/alibabacloud/polardb/model/DescribeDBClustersRequest.h
 	include/alibabacloud/polardb/model/DescribeDBClustersResult.h
+	include/alibabacloud/polardb/model/DescribeDBClustersWithBackupsRequest.h
+	include/alibabacloud/polardb/model/DescribeDBClustersWithBackupsResult.h
 	include/alibabacloud/polardb/model/DescribeDBNodePerformanceRequest.h
 	include/alibabacloud/polardb/model/DescribeDBNodePerformanceResult.h
 	include/alibabacloud/polardb/model/DescribeDatabasesRequest.h
 	include/alibabacloud/polardb/model/DescribeDatabasesResult.h
+	include/alibabacloud/polardb/model/DescribeDetachedBackupsRequest.h
+	include/alibabacloud/polardb/model/DescribeDetachedBackupsResult.h
+	include/alibabacloud/polardb/model/DescribeLogBackupPolicyRequest.h
+	include/alibabacloud/polardb/model/DescribeLogBackupPolicyResult.h
 	include/alibabacloud/polardb/model/DescribeRegionsRequest.h
 	include/alibabacloud/polardb/model/DescribeRegionsResult.h
 	include/alibabacloud/polardb/model/DescribeSlowLogRecordsRequest.h
@@ -127,6 +133,8 @@ set(polardb_public_header_model
 	include/alibabacloud/polardb/model/ModifyDBEndpointAddressResult.h
 	include/alibabacloud/polardb/model/ModifyDBNodeClassRequest.h
 	include/alibabacloud/polardb/model/ModifyDBNodeClassResult.h
+	include/alibabacloud/polardb/model/ModifyLogBackupPolicyRequest.h
+	include/alibabacloud/polardb/model/ModifyLogBackupPolicyResult.h
 	include/alibabacloud/polardb/model/ResetAccountRequest.h
 	include/alibabacloud/polardb/model/ResetAccountResult.h
 	include/alibabacloud/polardb/model/RestartDBNodeRequest.h
@@ -200,10 +208,16 @@ set(polardb_src
 	src/model/DescribeDBClusterSSLResult.cc
 	src/model/DescribeDBClustersRequest.cc
 	src/model/DescribeDBClustersResult.cc
+	src/model/DescribeDBClustersWithBackupsRequest.cc
+	src/model/DescribeDBClustersWithBackupsResult.cc
 	src/model/DescribeDBNodePerformanceRequest.cc
 	src/model/DescribeDBNodePerformanceResult.cc
 	src/model/DescribeDatabasesRequest.cc
 	src/model/DescribeDatabasesResult.cc
+	src/model/DescribeDetachedBackupsRequest.cc
+	src/model/DescribeDetachedBackupsResult.cc
+	src/model/DescribeLogBackupPolicyRequest.cc
+	src/model/DescribeLogBackupPolicyResult.cc
 	src/model/DescribeRegionsRequest.cc
 	src/model/DescribeRegionsResult.cc
 	src/model/DescribeSlowLogRecordsRequest.cc
@@ -246,6 +260,8 @@ set(polardb_src
 	src/model/ModifyDBEndpointAddressResult.cc
 	src/model/ModifyDBNodeClassRequest.cc
 	src/model/ModifyDBNodeClassResult.cc
+	src/model/ModifyLogBackupPolicyRequest.cc
+	src/model/ModifyLogBackupPolicyResult.cc
 	src/model/ResetAccountRequest.cc
 	src/model/ResetAccountResult.cc
 	src/model/RestartDBNodeRequest.cc

polardb/include/alibabacloud/polardb/PolardbClient.h

@@ -82,10 +82,16 @@
 #include "model/DescribeDBClusterSSLResult.h"
 #include "model/DescribeDBClustersRequest.h"
 #include "model/DescribeDBClustersResult.h"
+#include "model/DescribeDBClustersWithBackupsRequest.h"
+#include "model/DescribeDBClustersWithBackupsResult.h"
 #include "model/DescribeDBNodePerformanceRequest.h"
 #include "model/DescribeDBNodePerformanceResult.h"
 #include "model/DescribeDatabasesRequest.h"
 #include "model/DescribeDatabasesResult.h"
+#include "model/DescribeDetachedBackupsRequest.h"
+#include "model/DescribeDetachedBackupsResult.h"
+#include "model/DescribeLogBackupPolicyRequest.h"
+#include "model/DescribeLogBackupPolicyResult.h"
 #include "model/DescribeRegionsRequest.h"
 #include "model/DescribeRegionsResult.h"
 #include "model/DescribeSlowLogRecordsRequest.h"
@@ -128,6 +134,8 @@
 #include "model/ModifyDBEndpointAddressResult.h"
 #include "model/ModifyDBNodeClassRequest.h"
 #include "model/ModifyDBNodeClassResult.h"
+#include "model/ModifyLogBackupPolicyRequest.h"
+#include "model/ModifyLogBackupPolicyResult.h"
 #include "model/ResetAccountRequest.h"
 #include "model/ResetAccountResult.h"
 #include "model/RestartDBNodeRequest.h"
@@ -237,12 +245,21 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeDBClustersResult> DescribeDBClustersOutcome;
 			typedef std::future<DescribeDBClustersOutcome> DescribeDBClustersOutcomeCallable;
 			typedef std::function<void(const PolardbClient*, const Model::DescribeDBClustersRequest&, const DescribeDBClustersOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBClustersAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDBClustersWithBackupsResult> DescribeDBClustersWithBackupsOutcome;
+			typedef std::future<DescribeDBClustersWithBackupsOutcome> DescribeDBClustersWithBackupsOutcomeCallable;
+			typedef std::function<void(const PolardbClient*, const Model::DescribeDBClustersWithBackupsRequest&, const DescribeDBClustersWithBackupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBClustersWithBackupsAsyncHandler;
 			typedef Outcome<Error, Model::DescribeDBNodePerformanceResult> DescribeDBNodePerformanceOutcome;
 			typedef std::future<DescribeDBNodePerformanceOutcome> DescribeDBNodePerformanceOutcomeCallable;
 			typedef std::function<void(const PolardbClient*, const Model::DescribeDBNodePerformanceRequest&, const DescribeDBNodePerformanceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDBNodePerformanceAsyncHandler;
 			typedef Outcome<Error, Model::DescribeDatabasesResult> DescribeDatabasesOutcome;
 			typedef std::future<DescribeDatabasesOutcome> DescribeDatabasesOutcomeCallable;
 			typedef std::function<void(const PolardbClient*, const Model::DescribeDatabasesRequest&, const DescribeDatabasesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDatabasesAsyncHandler;
+			typedef Outcome<Error, Model::DescribeDetachedBackupsResult> DescribeDetachedBackupsOutcome;
+			typedef std::future<DescribeDetachedBackupsOutcome> DescribeDetachedBackupsOutcomeCallable;
+			typedef std::function<void(const PolardbClient*, const Model::DescribeDetachedBackupsRequest&, const DescribeDetachedBackupsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeDetachedBackupsAsyncHandler;
+			typedef Outcome<Error, Model::DescribeLogBackupPolicyResult> DescribeLogBackupPolicyOutcome;
+			typedef std::future<DescribeLogBackupPolicyOutcome> DescribeLogBackupPolicyOutcomeCallable;
+			typedef std::function<void(const PolardbClient*, const Model::DescribeLogBackupPolicyRequest&, const DescribeLogBackupPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeLogBackupPolicyAsyncHandler;
 			typedef Outcome<Error, Model::DescribeRegionsResult> DescribeRegionsOutcome;
 			typedef std::future<DescribeRegionsOutcome> DescribeRegionsOutcomeCallable;
 			typedef std::function<void(const PolardbClient*, const Model::DescribeRegionsRequest&, const DescribeRegionsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeRegionsAsyncHandler;
@@ -306,6 +323,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::ModifyDBNodeClassResult> ModifyDBNodeClassOutcome;
 			typedef std::future<ModifyDBNodeClassOutcome> ModifyDBNodeClassOutcomeCallable;
 			typedef std::function<void(const PolardbClient*, const Model::ModifyDBNodeClassRequest&, const ModifyDBNodeClassOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyDBNodeClassAsyncHandler;
+			typedef Outcome<Error, Model::ModifyLogBackupPolicyResult> ModifyLogBackupPolicyOutcome;
+			typedef std::future<ModifyLogBackupPolicyOutcome> ModifyLogBackupPolicyOutcomeCallable;
+			typedef std::function<void(const PolardbClient*, const Model::ModifyLogBackupPolicyRequest&, const ModifyLogBackupPolicyOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ModifyLogBackupPolicyAsyncHandler;
 			typedef Outcome<Error, Model::ResetAccountResult> ResetAccountOutcome;
 			typedef std::future<ResetAccountOutcome> ResetAccountOutcomeCallable;
 			typedef std::function<void(const PolardbClient*, const Model::ResetAccountRequest&, const ResetAccountOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> ResetAccountAsyncHandler;
@@ -416,12 +436,21 @@ namespace AlibabaCloud
 			DescribeDBClustersOutcome describeDBClusters(const Model::DescribeDBClustersRequest &request)const;
 			void describeDBClustersAsync(const Model::DescribeDBClustersRequest& request, const DescribeDBClustersAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDBClustersOutcomeCallable describeDBClustersCallable(const Model::DescribeDBClustersRequest& request) const;
+			DescribeDBClustersWithBackupsOutcome describeDBClustersWithBackups(const Model::DescribeDBClustersWithBackupsRequest &request)const;
+			void describeDBClustersWithBackupsAsync(const Model::DescribeDBClustersWithBackupsRequest& request, const DescribeDBClustersWithBackupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDBClustersWithBackupsOutcomeCallable describeDBClustersWithBackupsCallable(const Model::DescribeDBClustersWithBackupsRequest& request) const;
 			DescribeDBNodePerformanceOutcome describeDBNodePerformance(const Model::DescribeDBNodePerformanceRequest &request)const;
 			void describeDBNodePerformanceAsync(const Model::DescribeDBNodePerformanceRequest& request, const DescribeDBNodePerformanceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDBNodePerformanceOutcomeCallable describeDBNodePerformanceCallable(const Model::DescribeDBNodePerformanceRequest& request) const;
 			DescribeDatabasesOutcome describeDatabases(const Model::DescribeDatabasesRequest &request)const;
 			void describeDatabasesAsync(const Model::DescribeDatabasesRequest& request, const DescribeDatabasesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeDatabasesOutcomeCallable describeDatabasesCallable(const Model::DescribeDatabasesRequest& request) const;
+			DescribeDetachedBackupsOutcome describeDetachedBackups(const Model::DescribeDetachedBackupsRequest &request)const;
+			void describeDetachedBackupsAsync(const Model::DescribeDetachedBackupsRequest& request, const DescribeDetachedBackupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeDetachedBackupsOutcomeCallable describeDetachedBackupsCallable(const Model::DescribeDetachedBackupsRequest& request) const;
+			DescribeLogBackupPolicyOutcome describeLogBackupPolicy(const Model::DescribeLogBackupPolicyRequest &request)const;
+			void describeLogBackupPolicyAsync(const Model::DescribeLogBackupPolicyRequest& request, const DescribeLogBackupPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeLogBackupPolicyOutcomeCallable describeLogBackupPolicyCallable(const Model::DescribeLogBackupPolicyRequest& request) const;
 			DescribeRegionsOutcome describeRegions(const Model::DescribeRegionsRequest &request)const;
 			void describeRegionsAsync(const Model::DescribeRegionsRequest& request, const DescribeRegionsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeRegionsOutcomeCallable describeRegionsCallable(const Model::DescribeRegionsRequest& request) const;
@@ -485,6 +514,9 @@ namespace AlibabaCloud
 			ModifyDBNodeClassOutcome modifyDBNodeClass(const Model::ModifyDBNodeClassRequest &request)const;
 			void modifyDBNodeClassAsync(const Model::ModifyDBNodeClassRequest& request, const ModifyDBNodeClassAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ModifyDBNodeClassOutcomeCallable modifyDBNodeClassCallable(const Model::ModifyDBNodeClassRequest& request) const;
+			ModifyLogBackupPolicyOutcome modifyLogBackupPolicy(const Model::ModifyLogBackupPolicyRequest &request)const;
+			void modifyLogBackupPolicyAsync(const Model::ModifyLogBackupPolicyRequest& request, const ModifyLogBackupPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			ModifyLogBackupPolicyOutcomeCallable modifyLogBackupPolicyCallable(const Model::ModifyLogBackupPolicyRequest& request) const;
 			ResetAccountOutcome resetAccount(const Model::ResetAccountRequest &request)const;
 			void resetAccountAsync(const Model::ResetAccountRequest& request, const ResetAccountAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			ResetAccountOutcomeCallable resetAccountCallable(const Model::ResetAccountRequest& request) const;

polardb/include/alibabacloud/polardb/model/CreateDBClusterRequest.h

@@ -43,6 +43,8 @@ namespace AlibabaCloud
 				void setClientToken(const std::string& clientToken);
 				std::string getAccessKeyId()const;
 				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getCreationCategory()const;
+				void setCreationCategory(const std::string& creationCategory);
 				std::string getClusterNetworkType()const;
 				void setClusterNetworkType(const std::string& clusterNetworkType);
 				std::string getResourceGroupId()const;
@@ -93,6 +95,7 @@ namespace AlibabaCloud
 				std::string dBClusterDescription_;
 				std::string clientToken_;
 				std::string accessKeyId_;
+				std::string creationCategory_;
 				std::string clusterNetworkType_;
 				std::string resourceGroupId_;
 				std::string dBNodeClass_;

polardb/include/alibabacloud/polardb/model/DeleteDBClusterRequest.h

@@ -39,6 +39,8 @@ namespace AlibabaCloud
 				void setResourceOwnerId(long resourceOwnerId);
 				std::string getAccessKeyId()const;
 				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getBackupRetentionPolicyOnClusterDeletion()const;
+				void setBackupRetentionPolicyOnClusterDeletion(const std::string& backupRetentionPolicyOnClusterDeletion);
 				std::string getResourceOwnerAccount()const;
 				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
 				std::string getDBClusterId()const;
@@ -51,6 +53,7 @@ namespace AlibabaCloud
             private:
 				long resourceOwnerId_;
 				std::string accessKeyId_;
+				std::string backupRetentionPolicyOnClusterDeletion_;
 				std::string resourceOwnerAccount_;
 				std::string dBClusterId_;
 				std::string ownerAccount_;

polardb/include/alibabacloud/polardb/model/DescribeBackupPolicyResult.h

@@ -38,17 +38,23 @@ namespace AlibabaCloud
 				explicit DescribeBackupPolicyResult(const std::string &payload);
 				~DescribeBackupPolicyResult();
 				std::string getPreferredBackupPeriod()const;
+				std::string getDataLevel1BackupRetentionPeriod()const;
 				std::string getPreferredBackupTime()const;
+				std::string getBackupRetentionPolicyOnClusterDeletion()const;
 				int getBackupRetentionPeriod()const;
 				std::string getPreferredNextBackupTime()const;
+				std::string getDataLevel2BackupRetentionPeriod()const;
 
 			protected:
 				void parse(const std::string &payload);
 			private:
 				std::string preferredBackupPeriod_;
+				std::string dataLevel1BackupRetentionPeriod_;
 				std::string preferredBackupTime_;
+				std::string backupRetentionPolicyOnClusterDeletion_;
 				int backupRetentionPeriod_;
 				std::string preferredNextBackupTime_;
+				std::string dataLevel2BackupRetentionPeriod_;
 
 			};
 		}

polardb/include/alibabacloud/polardb/model/DescribeBackupsResult.h

@@ -35,15 +35,17 @@ namespace AlibabaCloud
 				struct Backup
 				{
 					std::string backupMethod;
+					std::string backupMode;
+					std::string backupsLevel;
+					std::string dBClusterId;
+					std::string backupId;
+					std::string isAvail;
+					std::string backupSetSize;
 					std::string storeStatus;
 					std::string backupEndTime;
-					std::string backupMode;
-					std::string dBClusterId;
 					std::string backupStartTime;
 					std::string consistentTime;
-					std::string backupId;
 					std::string backupType;
-					std::string backupSetSize;
 					std::string backupStatus;
 				};
 

polardb/include/alibabacloud/polardb/model/DescribeDBClusterAttributeResult.h

@@ -56,6 +56,7 @@ namespace AlibabaCloud
 				~DescribeDBClusterAttributeResult();
 				int getDeletionLock()const;
 				std::string getResourceGroupId()const;
+				long getDataLevel1BackupChainSize()const;
 				std::string getDBClusterId()const;
 				std::string getDBClusterNetworkType()const;
 				std::string getDBType()const;
@@ -85,6 +86,7 @@ namespace AlibabaCloud
 			private:
 				int deletionLock_;
 				std::string resourceGroupId_;
+				long dataLevel1BackupChainSize_;
 				std::string dBClusterId_;
 				std::string dBClusterNetworkType_;
 				std::string dBType_;

polardb/include/alibabacloud/polardb/model/DescribeDBClusterAvailableResourcesResult.h

@@ -38,6 +38,7 @@ namespace AlibabaCloud
 					{
 						struct AvailableResource
 						{
+							std::string category;
 							std::string dBNodeClass;
 						};
 						std::vector<SupportedEngine::AvailableResource> availableResources;

polardb/include/alibabacloud/polardb/model/DescribeDBClustersWithBackupsRequest.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_POLARDB_MODEL_DESCRIBEDBCLUSTERSWITHBACKUPSREQUEST_H_
+#define ALIBABACLOUD_POLARDB_MODEL_DESCRIBEDBCLUSTERSWITHBACKUPSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/polardb/PolardbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Polardb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_POLARDB_EXPORT DescribeDBClustersWithBackupsRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeDBClustersWithBackupsRequest();
+				~DescribeDBClustersWithBackupsRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getDBClusterDescription()const;
+				void setDBClusterDescription(const std::string& dBClusterDescription);
+				int getIsDeleted()const;
+				void setIsDeleted(int isDeleted);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getRegionId()const;
+				void setRegionId(const std::string& regionId);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getDBType()const;
+				void setDBType(const std::string& dBType);
+				std::string getDBVersion()const;
+				void setDBVersion(const std::string& dBVersion);
+				std::string getDBClusterIds()const;
+				void setDBClusterIds(const std::string& dBClusterIds);
+
+            private:
+				long resourceOwnerId_;
+				std::string dBClusterDescription_;
+				int isDeleted_;
+				int pageNumber_;
+				std::string accessKeyId_;
+				std::string regionId_;
+				int pageSize_;
+				std::string resourceOwnerAccount_;
+				std::string ownerAccount_;
+				long ownerId_;
+				std::string dBType_;
+				std::string dBVersion_;
+				std::string dBClusterIds_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_POLARDB_MODEL_DESCRIBEDBCLUSTERSWITHBACKUPSREQUEST_H_

polardb/include/alibabacloud/polardb/model/DescribeDBClustersWithBackupsResult.h

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_POLARDB_MODEL_DESCRIBEDBCLUSTERSWITHBACKUPSRESULT_H_
+#define ALIBABACLOUD_POLARDB_MODEL_DESCRIBEDBCLUSTERSWITHBACKUPSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/polardb/PolardbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Polardb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_POLARDB_EXPORT DescribeDBClustersWithBackupsResult : public ServiceResult
+			{
+			public:
+				struct DBCluster
+				{
+					int deletionLock;
+					int isDeleted;
+					std::string zoneId;
+					std::string deletedTime;
+					std::string dBClusterStatus;
+					std::string createTime;
+					std::string dBClusterId;
+					std::string dBClusterDescription;
+					std::string expired;
+					std::string payType;
+					std::string dBClusterNetworkType;
+					std::string dBType;
+					std::string lockMode;
+					std::string dBNodeClass;
+					std::string dBVersion;
+					std::string vpcId;
+					std::string regionId;
+					std::string expireTime;
+					std::string engine;
+				};
+
+
+				DescribeDBClustersWithBackupsResult();
+				explicit DescribeDBClustersWithBackupsResult(const std::string &payload);
+				~DescribeDBClustersWithBackupsResult();
+				int getTotalRecordCount()const;
+				int getPageRecordCount()const;
+				int getPageNumber()const;
+				std::vector<DBCluster> getItems()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int totalRecordCount_;
+				int pageRecordCount_;
+				int pageNumber_;
+				std::vector<DBCluster> items_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_POLARDB_MODEL_DESCRIBEDBCLUSTERSWITHBACKUPSRESULT_H_

polardb/include/alibabacloud/polardb/model/DescribeDetachedBackupsRequest.h

@@ -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.
+ */
+
+#ifndef ALIBABACLOUD_POLARDB_MODEL_DESCRIBEDETACHEDBACKUPSREQUEST_H_
+#define ALIBABACLOUD_POLARDB_MODEL_DESCRIBEDETACHEDBACKUPSREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/polardb/PolardbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Polardb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_POLARDB_EXPORT DescribeDetachedBackupsRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeDetachedBackupsRequest();
+				~DescribeDetachedBackupsRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getStartTime()const;
+				void setStartTime(const std::string& startTime);
+				int getPageNumber()const;
+				void setPageNumber(int pageNumber);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				int getPageSize()const;
+				void setPageSize(int pageSize);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getDBClusterId()const;
+				void setDBClusterId(const std::string& dBClusterId);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				std::string getBackupId()const;
+				void setBackupId(const std::string& backupId);
+				std::string getEndTime()const;
+				void setEndTime(const std::string& endTime);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getBackupStatus()const;
+				void setBackupStatus(const std::string& backupStatus);
+				std::string getBackupMode()const;
+				void setBackupMode(const std::string& backupMode);
+
+            private:
+				long resourceOwnerId_;
+				std::string startTime_;
+				int pageNumber_;
+				std::string accessKeyId_;
+				int pageSize_;
+				std::string resourceOwnerAccount_;
+				std::string dBClusterId_;
+				std::string ownerAccount_;
+				std::string backupId_;
+				std::string endTime_;
+				long ownerId_;
+				std::string backupStatus_;
+				std::string backupMode_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_POLARDB_MODEL_DESCRIBEDETACHEDBACKUPSREQUEST_H_

polardb/include/alibabacloud/polardb/model/DescribeDetachedBackupsResult.h

@@ -0,0 +1,73 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_POLARDB_MODEL_DESCRIBEDETACHEDBACKUPSRESULT_H_
+#define ALIBABACLOUD_POLARDB_MODEL_DESCRIBEDETACHEDBACKUPSRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/polardb/PolardbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Polardb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_POLARDB_EXPORT DescribeDetachedBackupsResult : public ServiceResult
+			{
+			public:
+				struct Backup
+				{
+					std::string backupMethod;
+					std::string backupMode;
+					std::string backupsLevel;
+					std::string dBClusterId;
+					std::string backupId;
+					std::string isAvail;
+					std::string backupSetSize;
+					std::string storeStatus;
+					std::string backupEndTime;
+					std::string backupStartTime;
+					std::string consistentTime;
+					std::string backupType;
+					std::string backupStatus;
+				};
+
+
+				DescribeDetachedBackupsResult();
+				explicit DescribeDetachedBackupsResult(const std::string &payload);
+				~DescribeDetachedBackupsResult();
+				std::string getTotalRecordCount()const;
+				std::string getPageRecordCount()const;
+				std::string getPageNumber()const;
+				std::vector<Backup> getItems()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::string totalRecordCount_;
+				std::string pageRecordCount_;
+				std::string pageNumber_;
+				std::vector<Backup> items_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_POLARDB_MODEL_DESCRIBEDETACHEDBACKUPSRESULT_H_

polardb/include/alibabacloud/polardb/model/DescribeLogBackupPolicyRequest.h

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_POLARDB_MODEL_DESCRIBELOGBACKUPPOLICYREQUEST_H_
+#define ALIBABACLOUD_POLARDB_MODEL_DESCRIBELOGBACKUPPOLICYREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/polardb/PolardbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Polardb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_POLARDB_EXPORT DescribeLogBackupPolicyRequest : public RpcServiceRequest
+			{
+
+			public:
+				DescribeLogBackupPolicyRequest();
+				~DescribeLogBackupPolicyRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getDBClusterId()const;
+				void setDBClusterId(const std::string& dBClusterId);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+
+            private:
+				long resourceOwnerId_;
+				std::string accessKeyId_;
+				std::string resourceOwnerAccount_;
+				std::string dBClusterId_;
+				std::string ownerAccount_;
+				long ownerId_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_POLARDB_MODEL_DESCRIBELOGBACKUPPOLICYREQUEST_H_

polardb/include/alibabacloud/polardb/model/DescribeLogBackupPolicyResult.h

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_POLARDB_MODEL_DESCRIBELOGBACKUPPOLICYRESULT_H_
+#define ALIBABACLOUD_POLARDB_MODEL_DESCRIBELOGBACKUPPOLICYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/polardb/PolardbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Polardb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_POLARDB_EXPORT DescribeLogBackupPolicyResult : public ServiceResult
+			{
+			public:
+
+
+				DescribeLogBackupPolicyResult();
+				explicit DescribeLogBackupPolicyResult(const std::string &payload);
+				~DescribeLogBackupPolicyResult();
+				int getLogBackupRetentionPeriod()const;
+				int getEnableBackupLog()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				int logBackupRetentionPeriod_;
+				int enableBackupLog_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_POLARDB_MODEL_DESCRIBELOGBACKUPPOLICYRESULT_H_

polardb/include/alibabacloud/polardb/model/ModifyBackupPolicyRequest.h

@@ -37,10 +37,16 @@ namespace AlibabaCloud
 
 				long getResourceOwnerId()const;
 				void setResourceOwnerId(long resourceOwnerId);
+				std::string getDataLevel2BackupRetentionPeriod()const;
+				void setDataLevel2BackupRetentionPeriod(const std::string& dataLevel2BackupRetentionPeriod);
 				std::string getAccessKeyId()const;
 				void setAccessKeyId(const std::string& accessKeyId);
 				std::string getPreferredBackupPeriod()const;
 				void setPreferredBackupPeriod(const std::string& preferredBackupPeriod);
+				std::string getDataLevel1BackupRetentionPeriod()const;
+				void setDataLevel1BackupRetentionPeriod(const std::string& dataLevel1BackupRetentionPeriod);
+				std::string getBackupRetentionPolicyOnClusterDeletion()const;
+				void setBackupRetentionPolicyOnClusterDeletion(const std::string& backupRetentionPolicyOnClusterDeletion);
 				std::string getResourceOwnerAccount()const;
 				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
 				std::string getDBClusterId()const;
@@ -56,8 +62,11 @@ namespace AlibabaCloud
 
             private:
 				long resourceOwnerId_;
+				std::string dataLevel2BackupRetentionPeriod_;
 				std::string accessKeyId_;
 				std::string preferredBackupPeriod_;
+				std::string dataLevel1BackupRetentionPeriod_;
+				std::string backupRetentionPolicyOnClusterDeletion_;
 				std::string resourceOwnerAccount_;
 				std::string dBClusterId_;
 				std::string ownerAccount_;

polardb/include/alibabacloud/polardb/model/ModifyLogBackupPolicyRequest.h

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_POLARDB_MODEL_MODIFYLOGBACKUPPOLICYREQUEST_H_
+#define ALIBABACLOUD_POLARDB_MODEL_MODIFYLOGBACKUPPOLICYREQUEST_H_
+
+#include <string>
+#include <vector>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <alibabacloud/polardb/PolardbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Polardb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_POLARDB_EXPORT ModifyLogBackupPolicyRequest : public RpcServiceRequest
+			{
+
+			public:
+				ModifyLogBackupPolicyRequest();
+				~ModifyLogBackupPolicyRequest();
+
+				long getResourceOwnerId()const;
+				void setResourceOwnerId(long resourceOwnerId);
+				std::string getAccessKeyId()const;
+				void setAccessKeyId(const std::string& accessKeyId);
+				std::string getResourceOwnerAccount()const;
+				void setResourceOwnerAccount(const std::string& resourceOwnerAccount);
+				std::string getDBClusterId()const;
+				void setDBClusterId(const std::string& dBClusterId);
+				std::string getOwnerAccount()const;
+				void setOwnerAccount(const std::string& ownerAccount);
+				long getOwnerId()const;
+				void setOwnerId(long ownerId);
+				std::string getLogBackupRetentionPeriod()const;
+				void setLogBackupRetentionPeriod(const std::string& logBackupRetentionPeriod);
+
+            private:
+				long resourceOwnerId_;
+				std::string accessKeyId_;
+				std::string resourceOwnerAccount_;
+				std::string dBClusterId_;
+				std::string ownerAccount_;
+				long ownerId_;
+				std::string logBackupRetentionPeriod_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_POLARDB_MODEL_MODIFYLOGBACKUPPOLICYREQUEST_H_

polardb/include/alibabacloud/polardb/model/ModifyLogBackupPolicyResult.h

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_POLARDB_MODEL_MODIFYLOGBACKUPPOLICYRESULT_H_
+#define ALIBABACLOUD_POLARDB_MODEL_MODIFYLOGBACKUPPOLICYRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/polardb/PolardbExport.h>
+
+namespace AlibabaCloud
+{
+	namespace Polardb
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_POLARDB_EXPORT ModifyLogBackupPolicyResult : public ServiceResult
+			{
+			public:
+
+
+				ModifyLogBackupPolicyResult();
+				explicit ModifyLogBackupPolicyResult(const std::string &payload);
+				~ModifyLogBackupPolicyResult();
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_POLARDB_MODEL_MODIFYLOGBACKUPPOLICYRESULT_H_

polardb/src/PolardbClient.cc

@@ -1131,6 +1131,42 @@ PolardbClient::DescribeDBClustersOutcomeCallable PolardbClient::describeDBCluste
 	return task->get_future();
 }
 
+PolardbClient::DescribeDBClustersWithBackupsOutcome PolardbClient::describeDBClustersWithBackups(const DescribeDBClustersWithBackupsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDBClustersWithBackupsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDBClustersWithBackupsOutcome(DescribeDBClustersWithBackupsResult(outcome.result()));
+	else
+		return DescribeDBClustersWithBackupsOutcome(outcome.error());
+}
+
+void PolardbClient::describeDBClustersWithBackupsAsync(const DescribeDBClustersWithBackupsRequest& request, const DescribeDBClustersWithBackupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDBClustersWithBackups(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PolardbClient::DescribeDBClustersWithBackupsOutcomeCallable PolardbClient::describeDBClustersWithBackupsCallable(const DescribeDBClustersWithBackupsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDBClustersWithBackupsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDBClustersWithBackups(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 PolardbClient::DescribeDBNodePerformanceOutcome PolardbClient::describeDBNodePerformance(const DescribeDBNodePerformanceRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1203,6 +1239,78 @@ PolardbClient::DescribeDatabasesOutcomeCallable PolardbClient::describeDatabases
 	return task->get_future();
 }
 
+PolardbClient::DescribeDetachedBackupsOutcome PolardbClient::describeDetachedBackups(const DescribeDetachedBackupsRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeDetachedBackupsOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeDetachedBackupsOutcome(DescribeDetachedBackupsResult(outcome.result()));
+	else
+		return DescribeDetachedBackupsOutcome(outcome.error());
+}
+
+void PolardbClient::describeDetachedBackupsAsync(const DescribeDetachedBackupsRequest& request, const DescribeDetachedBackupsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeDetachedBackups(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PolardbClient::DescribeDetachedBackupsOutcomeCallable PolardbClient::describeDetachedBackupsCallable(const DescribeDetachedBackupsRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeDetachedBackupsOutcome()>>(
+			[this, request]()
+			{
+			return this->describeDetachedBackups(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
+PolardbClient::DescribeLogBackupPolicyOutcome PolardbClient::describeLogBackupPolicy(const DescribeLogBackupPolicyRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeLogBackupPolicyOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeLogBackupPolicyOutcome(DescribeLogBackupPolicyResult(outcome.result()));
+	else
+		return DescribeLogBackupPolicyOutcome(outcome.error());
+}
+
+void PolardbClient::describeLogBackupPolicyAsync(const DescribeLogBackupPolicyRequest& request, const DescribeLogBackupPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeLogBackupPolicy(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PolardbClient::DescribeLogBackupPolicyOutcomeCallable PolardbClient::describeLogBackupPolicyCallable(const DescribeLogBackupPolicyRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeLogBackupPolicyOutcome()>>(
+			[this, request]()
+			{
+			return this->describeLogBackupPolicy(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 PolardbClient::DescribeRegionsOutcome PolardbClient::describeRegions(const DescribeRegionsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -1959,6 +2067,42 @@ PolardbClient::ModifyDBNodeClassOutcomeCallable PolardbClient::modifyDBNodeClass
 	return task->get_future();
 }
 
+PolardbClient::ModifyLogBackupPolicyOutcome PolardbClient::modifyLogBackupPolicy(const ModifyLogBackupPolicyRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return ModifyLogBackupPolicyOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return ModifyLogBackupPolicyOutcome(ModifyLogBackupPolicyResult(outcome.result()));
+	else
+		return ModifyLogBackupPolicyOutcome(outcome.error());
+}
+
+void PolardbClient::modifyLogBackupPolicyAsync(const ModifyLogBackupPolicyRequest& request, const ModifyLogBackupPolicyAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, modifyLogBackupPolicy(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+PolardbClient::ModifyLogBackupPolicyOutcomeCallable PolardbClient::modifyLogBackupPolicyCallable(const ModifyLogBackupPolicyRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<ModifyLogBackupPolicyOutcome()>>(
+			[this, request]()
+			{
+			return this->modifyLogBackupPolicy(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 PolardbClient::ResetAccountOutcome PolardbClient::resetAccount(const ResetAccountRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

polardb/src/model/CreateDBClusterRequest.cc

@@ -71,6 +71,17 @@ void CreateDBClusterRequest::setAccessKeyId(const std::string& accessKeyId)
 	setParameter("AccessKeyId", accessKeyId);
 }
 
+std::string CreateDBClusterRequest::getCreationCategory()const
+{
+	return creationCategory_;
+}
+
+void CreateDBClusterRequest::setCreationCategory(const std::string& creationCategory)
+{
+	creationCategory_ = creationCategory;
+	setParameter("CreationCategory", creationCategory);
+}
+
 std::string CreateDBClusterRequest::getClusterNetworkType()const
 {
 	return clusterNetworkType_;

polardb/src/model/DeleteDBClusterRequest.cc

@@ -49,6 +49,17 @@ void DeleteDBClusterRequest::setAccessKeyId(const std::string& accessKeyId)
 	setParameter("AccessKeyId", accessKeyId);
 }
 
+std::string DeleteDBClusterRequest::getBackupRetentionPolicyOnClusterDeletion()const
+{
+	return backupRetentionPolicyOnClusterDeletion_;
+}
+
+void DeleteDBClusterRequest::setBackupRetentionPolicyOnClusterDeletion(const std::string& backupRetentionPolicyOnClusterDeletion)
+{
+	backupRetentionPolicyOnClusterDeletion_ = backupRetentionPolicyOnClusterDeletion;
+	setParameter("BackupRetentionPolicyOnClusterDeletion", backupRetentionPolicyOnClusterDeletion);
+}
+
 std::string DeleteDBClusterRequest::getResourceOwnerAccount()const
 {
 	return resourceOwnerAccount_;

polardb/src/model/DescribeBackupPolicyResult.cc

@@ -47,6 +47,12 @@ void DescribeBackupPolicyResult::parse(const std::string &payload)
 		preferredBackupTime_ = value["PreferredBackupTime"].asString();
 	if(!value["PreferredBackupPeriod"].isNull())
 		preferredBackupPeriod_ = value["PreferredBackupPeriod"].asString();
+	if(!value["DataLevel1BackupRetentionPeriod"].isNull())
+		dataLevel1BackupRetentionPeriod_ = value["DataLevel1BackupRetentionPeriod"].asString();
+	if(!value["DataLevel2BackupRetentionPeriod"].isNull())
+		dataLevel2BackupRetentionPeriod_ = value["DataLevel2BackupRetentionPeriod"].asString();
+	if(!value["BackupRetentionPolicyOnClusterDeletion"].isNull())
+		backupRetentionPolicyOnClusterDeletion_ = value["BackupRetentionPolicyOnClusterDeletion"].asString();
 
 }
 
@@ -55,11 +61,21 @@ std::string DescribeBackupPolicyResult::getPreferredBackupPeriod()const
 	return preferredBackupPeriod_;
 }
 
+std::string DescribeBackupPolicyResult::getDataLevel1BackupRetentionPeriod()const
+{
+	return dataLevel1BackupRetentionPeriod_;
+}
+
 std::string DescribeBackupPolicyResult::getPreferredBackupTime()const
 {
 	return preferredBackupTime_;
 }
 
+std::string DescribeBackupPolicyResult::getBackupRetentionPolicyOnClusterDeletion()const
+{
+	return backupRetentionPolicyOnClusterDeletion_;
+}
+
 int DescribeBackupPolicyResult::getBackupRetentionPeriod()const
 {
 	return backupRetentionPeriod_;
@@ -70,3 +86,8 @@ std::string DescribeBackupPolicyResult::getPreferredNextBackupTime()const
 	return preferredNextBackupTime_;
 }
 
+std::string DescribeBackupPolicyResult::getDataLevel2BackupRetentionPeriod()const
+{
+	return dataLevel2BackupRetentionPeriod_;
+}
+

polardb/src/model/DescribeBackupsResult.cc

@@ -65,6 +65,10 @@ void DescribeBackupsResult::parse(const std::string &payload)
 			itemsObject.backupSetSize = valueItemsBackup["BackupSetSize"].asString();
 		if(!valueItemsBackup["ConsistentTime"].isNull())
 			itemsObject.consistentTime = valueItemsBackup["ConsistentTime"].asString();
+		if(!valueItemsBackup["BackupsLevel"].isNull())
+			itemsObject.backupsLevel = valueItemsBackup["BackupsLevel"].asString();
+		if(!valueItemsBackup["IsAvail"].isNull())
+			itemsObject.isAvail = valueItemsBackup["IsAvail"].asString();
 		items_.push_back(itemsObject);
 	}
 	if(!value["TotalRecordCount"].isNull())

polardb/src/model/DescribeDBClusterAttributeResult.cc

@@ -119,6 +119,8 @@ void DescribeDBClusterAttributeResult::parse(const std::string &payload)
 		isLatestVersion_ = value["IsLatestVersion"].asString() == "true";
 	if(!value["ResourceGroupId"].isNull())
 		resourceGroupId_ = value["ResourceGroupId"].asString();
+	if(!value["DataLevel1BackupChainSize"].isNull())
+		dataLevel1BackupChainSize_ = std::stol(value["DataLevel1BackupChainSize"].asString());
 
 }
 
@@ -132,6 +134,11 @@ std::string DescribeDBClusterAttributeResult::getResourceGroupId()const
 	return resourceGroupId_;
 }
 
+long DescribeDBClusterAttributeResult::getDataLevel1BackupChainSize()const
+{
+	return dataLevel1BackupChainSize_;
+}
+
 std::string DescribeDBClusterAttributeResult::getDBClusterId()const
 {
 	return dBClusterId_;

polardb/src/model/DescribeDBClusterAvailableResourcesResult.cc

@@ -59,6 +59,8 @@ void DescribeDBClusterAvailableResourcesResult::parse(const std::string &payload
 				AvailableZone::SupportedEngine::AvailableResource availableResourcesObject;
 				if(!allSupportedEnginesNodeAvailableResourcesAvailableResource["DBNodeClass"].isNull())
 					availableResourcesObject.dBNodeClass = allSupportedEnginesNodeAvailableResourcesAvailableResource["DBNodeClass"].asString();
+				if(!allSupportedEnginesNodeAvailableResourcesAvailableResource["Category"].isNull())
+					availableResourcesObject.category = allSupportedEnginesNodeAvailableResourcesAvailableResource["Category"].asString();
 				supportedEnginesObject.availableResources.push_back(availableResourcesObject);
 			}
 			availableZonesObject.supportedEngines.push_back(supportedEnginesObject);

polardb/src/model/DescribeDBClustersWithBackupsRequest.cc

@@ -0,0 +1,172 @@
+/*
+ * 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/polardb/model/DescribeDBClustersWithBackupsRequest.h>
+
+using AlibabaCloud::Polardb::Model::DescribeDBClustersWithBackupsRequest;
+
+DescribeDBClustersWithBackupsRequest::DescribeDBClustersWithBackupsRequest() :
+	RpcServiceRequest("polardb", "2017-08-01", "DescribeDBClustersWithBackups")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDBClustersWithBackupsRequest::~DescribeDBClustersWithBackupsRequest()
+{}
+
+long DescribeDBClustersWithBackupsRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DescribeDBClustersWithBackupsRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string DescribeDBClustersWithBackupsRequest::getDBClusterDescription()const
+{
+	return dBClusterDescription_;
+}
+
+void DescribeDBClustersWithBackupsRequest::setDBClusterDescription(const std::string& dBClusterDescription)
+{
+	dBClusterDescription_ = dBClusterDescription;
+	setParameter("DBClusterDescription", dBClusterDescription);
+}
+
+int DescribeDBClustersWithBackupsRequest::getIsDeleted()const
+{
+	return isDeleted_;
+}
+
+void DescribeDBClustersWithBackupsRequest::setIsDeleted(int isDeleted)
+{
+	isDeleted_ = isDeleted;
+	setParameter("IsDeleted", std::to_string(isDeleted));
+}
+
+int DescribeDBClustersWithBackupsRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void DescribeDBClustersWithBackupsRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+
+std::string DescribeDBClustersWithBackupsRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeDBClustersWithBackupsRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DescribeDBClustersWithBackupsRequest::getRegionId()const
+{
+	return regionId_;
+}
+
+void DescribeDBClustersWithBackupsRequest::setRegionId(const std::string& regionId)
+{
+	regionId_ = regionId;
+	setParameter("RegionId", regionId);
+}
+
+int DescribeDBClustersWithBackupsRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void DescribeDBClustersWithBackupsRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+
+std::string DescribeDBClustersWithBackupsRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DescribeDBClustersWithBackupsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DescribeDBClustersWithBackupsRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void DescribeDBClustersWithBackupsRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long DescribeDBClustersWithBackupsRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeDBClustersWithBackupsRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeDBClustersWithBackupsRequest::getDBType()const
+{
+	return dBType_;
+}
+
+void DescribeDBClustersWithBackupsRequest::setDBType(const std::string& dBType)
+{
+	dBType_ = dBType;
+	setParameter("DBType", dBType);
+}
+
+std::string DescribeDBClustersWithBackupsRequest::getDBVersion()const
+{
+	return dBVersion_;
+}
+
+void DescribeDBClustersWithBackupsRequest::setDBVersion(const std::string& dBVersion)
+{
+	dBVersion_ = dBVersion;
+	setParameter("DBVersion", dBVersion);
+}
+
+std::string DescribeDBClustersWithBackupsRequest::getDBClusterIds()const
+{
+	return dBClusterIds_;
+}
+
+void DescribeDBClustersWithBackupsRequest::setDBClusterIds(const std::string& dBClusterIds)
+{
+	dBClusterIds_ = dBClusterIds;
+	setParameter("DBClusterIds", dBClusterIds);
+}
+

polardb/src/model/DescribeDBClustersWithBackupsResult.cc

@@ -0,0 +1,114 @@
+/*
+ * 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/polardb/model/DescribeDBClustersWithBackupsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Polardb;
+using namespace AlibabaCloud::Polardb::Model;
+
+DescribeDBClustersWithBackupsResult::DescribeDBClustersWithBackupsResult() :
+	ServiceResult()
+{}
+
+DescribeDBClustersWithBackupsResult::DescribeDBClustersWithBackupsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDBClustersWithBackupsResult::~DescribeDBClustersWithBackupsResult()
+{}
+
+void DescribeDBClustersWithBackupsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allItemsNode = value["Items"]["DBCluster"];
+	for (auto valueItemsDBCluster : allItemsNode)
+	{
+		DBCluster itemsObject;
+		if(!valueItemsDBCluster["DBClusterId"].isNull())
+			itemsObject.dBClusterId = valueItemsDBCluster["DBClusterId"].asString();
+		if(!valueItemsDBCluster["DBClusterDescription"].isNull())
+			itemsObject.dBClusterDescription = valueItemsDBCluster["DBClusterDescription"].asString();
+		if(!valueItemsDBCluster["PayType"].isNull())
+			itemsObject.payType = valueItemsDBCluster["PayType"].asString();
+		if(!valueItemsDBCluster["DBClusterNetworkType"].isNull())
+			itemsObject.dBClusterNetworkType = valueItemsDBCluster["DBClusterNetworkType"].asString();
+		if(!valueItemsDBCluster["RegionId"].isNull())
+			itemsObject.regionId = valueItemsDBCluster["RegionId"].asString();
+		if(!valueItemsDBCluster["ZoneId"].isNull())
+			itemsObject.zoneId = valueItemsDBCluster["ZoneId"].asString();
+		if(!valueItemsDBCluster["ExpireTime"].isNull())
+			itemsObject.expireTime = valueItemsDBCluster["ExpireTime"].asString();
+		if(!valueItemsDBCluster["Expired"].isNull())
+			itemsObject.expired = valueItemsDBCluster["Expired"].asString();
+		if(!valueItemsDBCluster["DBClusterStatus"].isNull())
+			itemsObject.dBClusterStatus = valueItemsDBCluster["DBClusterStatus"].asString();
+		if(!valueItemsDBCluster["Engine"].isNull())
+			itemsObject.engine = valueItemsDBCluster["Engine"].asString();
+		if(!valueItemsDBCluster["DBType"].isNull())
+			itemsObject.dBType = valueItemsDBCluster["DBType"].asString();
+		if(!valueItemsDBCluster["DBVersion"].isNull())
+			itemsObject.dBVersion = valueItemsDBCluster["DBVersion"].asString();
+		if(!valueItemsDBCluster["LockMode"].isNull())
+			itemsObject.lockMode = valueItemsDBCluster["LockMode"].asString();
+		if(!valueItemsDBCluster["DeletionLock"].isNull())
+			itemsObject.deletionLock = std::stoi(valueItemsDBCluster["DeletionLock"].asString());
+		if(!valueItemsDBCluster["CreateTime"].isNull())
+			itemsObject.createTime = valueItemsDBCluster["CreateTime"].asString();
+		if(!valueItemsDBCluster["VpcId"].isNull())
+			itemsObject.vpcId = valueItemsDBCluster["VpcId"].asString();
+		if(!valueItemsDBCluster["IsDeleted"].isNull())
+			itemsObject.isDeleted = std::stoi(valueItemsDBCluster["IsDeleted"].asString());
+		if(!valueItemsDBCluster["DeletedTime"].isNull())
+			itemsObject.deletedTime = valueItemsDBCluster["DeletedTime"].asString();
+		if(!valueItemsDBCluster["DBNodeClass"].isNull())
+			itemsObject.dBNodeClass = valueItemsDBCluster["DBNodeClass"].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());
+
+}
+
+int DescribeDBClustersWithBackupsResult::getTotalRecordCount()const
+{
+	return totalRecordCount_;
+}
+
+int DescribeDBClustersWithBackupsResult::getPageRecordCount()const
+{
+	return pageRecordCount_;
+}
+
+int DescribeDBClustersWithBackupsResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::vector<DescribeDBClustersWithBackupsResult::DBCluster> DescribeDBClustersWithBackupsResult::getItems()const
+{
+	return items_;
+}
+

polardb/src/model/DescribeDetachedBackupsRequest.cc

@@ -0,0 +1,172 @@
+/*
+ * 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/polardb/model/DescribeDetachedBackupsRequest.h>
+
+using AlibabaCloud::Polardb::Model::DescribeDetachedBackupsRequest;
+
+DescribeDetachedBackupsRequest::DescribeDetachedBackupsRequest() :
+	RpcServiceRequest("polardb", "2017-08-01", "DescribeDetachedBackups")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeDetachedBackupsRequest::~DescribeDetachedBackupsRequest()
+{}
+
+long DescribeDetachedBackupsRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DescribeDetachedBackupsRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string DescribeDetachedBackupsRequest::getStartTime()const
+{
+	return startTime_;
+}
+
+void DescribeDetachedBackupsRequest::setStartTime(const std::string& startTime)
+{
+	startTime_ = startTime;
+	setParameter("StartTime", startTime);
+}
+
+int DescribeDetachedBackupsRequest::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+void DescribeDetachedBackupsRequest::setPageNumber(int pageNumber)
+{
+	pageNumber_ = pageNumber;
+	setParameter("PageNumber", std::to_string(pageNumber));
+}
+
+std::string DescribeDetachedBackupsRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeDetachedBackupsRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+int DescribeDetachedBackupsRequest::getPageSize()const
+{
+	return pageSize_;
+}
+
+void DescribeDetachedBackupsRequest::setPageSize(int pageSize)
+{
+	pageSize_ = pageSize;
+	setParameter("PageSize", std::to_string(pageSize));
+}
+
+std::string DescribeDetachedBackupsRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DescribeDetachedBackupsRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DescribeDetachedBackupsRequest::getDBClusterId()const
+{
+	return dBClusterId_;
+}
+
+void DescribeDetachedBackupsRequest::setDBClusterId(const std::string& dBClusterId)
+{
+	dBClusterId_ = dBClusterId;
+	setParameter("DBClusterId", dBClusterId);
+}
+
+std::string DescribeDetachedBackupsRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void DescribeDetachedBackupsRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+std::string DescribeDetachedBackupsRequest::getBackupId()const
+{
+	return backupId_;
+}
+
+void DescribeDetachedBackupsRequest::setBackupId(const std::string& backupId)
+{
+	backupId_ = backupId;
+	setParameter("BackupId", backupId);
+}
+
+std::string DescribeDetachedBackupsRequest::getEndTime()const
+{
+	return endTime_;
+}
+
+void DescribeDetachedBackupsRequest::setEndTime(const std::string& endTime)
+{
+	endTime_ = endTime;
+	setParameter("EndTime", endTime);
+}
+
+long DescribeDetachedBackupsRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeDetachedBackupsRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string DescribeDetachedBackupsRequest::getBackupStatus()const
+{
+	return backupStatus_;
+}
+
+void DescribeDetachedBackupsRequest::setBackupStatus(const std::string& backupStatus)
+{
+	backupStatus_ = backupStatus;
+	setParameter("BackupStatus", backupStatus);
+}
+
+std::string DescribeDetachedBackupsRequest::getBackupMode()const
+{
+	return backupMode_;
+}
+
+void DescribeDetachedBackupsRequest::setBackupMode(const std::string& backupMode)
+{
+	backupMode_ = backupMode;
+	setParameter("BackupMode", backupMode);
+}
+

polardb/src/model/DescribeDetachedBackupsResult.cc

@@ -0,0 +1,102 @@
+/*
+ * 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/polardb/model/DescribeDetachedBackupsResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Polardb;
+using namespace AlibabaCloud::Polardb::Model;
+
+DescribeDetachedBackupsResult::DescribeDetachedBackupsResult() :
+	ServiceResult()
+{}
+
+DescribeDetachedBackupsResult::DescribeDetachedBackupsResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeDetachedBackupsResult::~DescribeDetachedBackupsResult()
+{}
+
+void DescribeDetachedBackupsResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allItemsNode = value["Items"]["Backup"];
+	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["BackupStatus"].isNull())
+			itemsObject.backupStatus = valueItemsBackup["BackupStatus"].asString();
+		if(!valueItemsBackup["BackupStartTime"].isNull())
+			itemsObject.backupStartTime = valueItemsBackup["BackupStartTime"].asString();
+		if(!valueItemsBackup["BackupEndTime"].isNull())
+			itemsObject.backupEndTime = valueItemsBackup["BackupEndTime"].asString();
+		if(!valueItemsBackup["BackupType"].isNull())
+			itemsObject.backupType = valueItemsBackup["BackupType"].asString();
+		if(!valueItemsBackup["BackupMode"].isNull())
+			itemsObject.backupMode = valueItemsBackup["BackupMode"].asString();
+		if(!valueItemsBackup["BackupMethod"].isNull())
+			itemsObject.backupMethod = valueItemsBackup["BackupMethod"].asString();
+		if(!valueItemsBackup["StoreStatus"].isNull())
+			itemsObject.storeStatus = valueItemsBackup["StoreStatus"].asString();
+		if(!valueItemsBackup["BackupSetSize"].isNull())
+			itemsObject.backupSetSize = valueItemsBackup["BackupSetSize"].asString();
+		if(!valueItemsBackup["ConsistentTime"].isNull())
+			itemsObject.consistentTime = valueItemsBackup["ConsistentTime"].asString();
+		if(!valueItemsBackup["BackupsLevel"].isNull())
+			itemsObject.backupsLevel = valueItemsBackup["BackupsLevel"].asString();
+		if(!valueItemsBackup["IsAvail"].isNull())
+			itemsObject.isAvail = valueItemsBackup["IsAvail"].asString();
+		items_.push_back(itemsObject);
+	}
+	if(!value["TotalRecordCount"].isNull())
+		totalRecordCount_ = value["TotalRecordCount"].asString();
+	if(!value["PageNumber"].isNull())
+		pageNumber_ = value["PageNumber"].asString();
+	if(!value["PageRecordCount"].isNull())
+		pageRecordCount_ = value["PageRecordCount"].asString();
+
+}
+
+std::string DescribeDetachedBackupsResult::getTotalRecordCount()const
+{
+	return totalRecordCount_;
+}
+
+std::string DescribeDetachedBackupsResult::getPageRecordCount()const
+{
+	return pageRecordCount_;
+}
+
+std::string DescribeDetachedBackupsResult::getPageNumber()const
+{
+	return pageNumber_;
+}
+
+std::vector<DescribeDetachedBackupsResult::Backup> DescribeDetachedBackupsResult::getItems()const
+{
+	return items_;
+}
+

polardb/src/model/DescribeLogBackupPolicyRequest.cc

@@ -0,0 +1,95 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/polardb/model/DescribeLogBackupPolicyRequest.h>
+
+using AlibabaCloud::Polardb::Model::DescribeLogBackupPolicyRequest;
+
+DescribeLogBackupPolicyRequest::DescribeLogBackupPolicyRequest() :
+	RpcServiceRequest("polardb", "2017-08-01", "DescribeLogBackupPolicy")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+DescribeLogBackupPolicyRequest::~DescribeLogBackupPolicyRequest()
+{}
+
+long DescribeLogBackupPolicyRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void DescribeLogBackupPolicyRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string DescribeLogBackupPolicyRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void DescribeLogBackupPolicyRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string DescribeLogBackupPolicyRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void DescribeLogBackupPolicyRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string DescribeLogBackupPolicyRequest::getDBClusterId()const
+{
+	return dBClusterId_;
+}
+
+void DescribeLogBackupPolicyRequest::setDBClusterId(const std::string& dBClusterId)
+{
+	dBClusterId_ = dBClusterId;
+	setParameter("DBClusterId", dBClusterId);
+}
+
+std::string DescribeLogBackupPolicyRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void DescribeLogBackupPolicyRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long DescribeLogBackupPolicyRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void DescribeLogBackupPolicyRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+

polardb/src/model/DescribeLogBackupPolicyResult.cc

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/polardb/model/DescribeLogBackupPolicyResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::Polardb;
+using namespace AlibabaCloud::Polardb::Model;
+
+DescribeLogBackupPolicyResult::DescribeLogBackupPolicyResult() :
+	ServiceResult()
+{}
+
+DescribeLogBackupPolicyResult::DescribeLogBackupPolicyResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeLogBackupPolicyResult::~DescribeLogBackupPolicyResult()
+{}
+
+void DescribeLogBackupPolicyResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	if(!value["EnableBackupLog"].isNull())
+		enableBackupLog_ = std::stoi(value["EnableBackupLog"].asString());
+	if(!value["LogBackupRetentionPeriod"].isNull())
+		logBackupRetentionPeriod_ = std::stoi(value["LogBackupRetentionPeriod"].asString());
+
+}
+
+int DescribeLogBackupPolicyResult::getLogBackupRetentionPeriod()const
+{
+	return logBackupRetentionPeriod_;
+}
+
+int DescribeLogBackupPolicyResult::getEnableBackupLog()const
+{
+	return enableBackupLog_;
+}
+

polardb/src/model/ModifyBackupPolicyRequest.cc

@@ -38,6 +38,17 @@ void ModifyBackupPolicyRequest::setResourceOwnerId(long resourceOwnerId)
 	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
 }
 
+std::string ModifyBackupPolicyRequest::getDataLevel2BackupRetentionPeriod()const
+{
+	return dataLevel2BackupRetentionPeriod_;
+}
+
+void ModifyBackupPolicyRequest::setDataLevel2BackupRetentionPeriod(const std::string& dataLevel2BackupRetentionPeriod)
+{
+	dataLevel2BackupRetentionPeriod_ = dataLevel2BackupRetentionPeriod;
+	setParameter("DataLevel2BackupRetentionPeriod", dataLevel2BackupRetentionPeriod);
+}
+
 std::string ModifyBackupPolicyRequest::getAccessKeyId()const
 {
 	return accessKeyId_;
@@ -60,6 +71,28 @@ void ModifyBackupPolicyRequest::setPreferredBackupPeriod(const std::string& pref
 	setParameter("PreferredBackupPeriod", preferredBackupPeriod);
 }
 
+std::string ModifyBackupPolicyRequest::getDataLevel1BackupRetentionPeriod()const
+{
+	return dataLevel1BackupRetentionPeriod_;
+}
+
+void ModifyBackupPolicyRequest::setDataLevel1BackupRetentionPeriod(const std::string& dataLevel1BackupRetentionPeriod)
+{
+	dataLevel1BackupRetentionPeriod_ = dataLevel1BackupRetentionPeriod;
+	setParameter("DataLevel1BackupRetentionPeriod", dataLevel1BackupRetentionPeriod);
+}
+
+std::string ModifyBackupPolicyRequest::getBackupRetentionPolicyOnClusterDeletion()const
+{
+	return backupRetentionPolicyOnClusterDeletion_;
+}
+
+void ModifyBackupPolicyRequest::setBackupRetentionPolicyOnClusterDeletion(const std::string& backupRetentionPolicyOnClusterDeletion)
+{
+	backupRetentionPolicyOnClusterDeletion_ = backupRetentionPolicyOnClusterDeletion;
+	setParameter("BackupRetentionPolicyOnClusterDeletion", backupRetentionPolicyOnClusterDeletion);
+}
+
 std::string ModifyBackupPolicyRequest::getResourceOwnerAccount()const
 {
 	return resourceOwnerAccount_;

polardb/src/model/ModifyLogBackupPolicyRequest.cc

@@ -0,0 +1,106 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/polardb/model/ModifyLogBackupPolicyRequest.h>
+
+using AlibabaCloud::Polardb::Model::ModifyLogBackupPolicyRequest;
+
+ModifyLogBackupPolicyRequest::ModifyLogBackupPolicyRequest() :
+	RpcServiceRequest("polardb", "2017-08-01", "ModifyLogBackupPolicy")
+{
+	setMethod(HttpRequest::Method::Post);
+}
+
+ModifyLogBackupPolicyRequest::~ModifyLogBackupPolicyRequest()
+{}
+
+long ModifyLogBackupPolicyRequest::getResourceOwnerId()const
+{
+	return resourceOwnerId_;
+}
+
+void ModifyLogBackupPolicyRequest::setResourceOwnerId(long resourceOwnerId)
+{
+	resourceOwnerId_ = resourceOwnerId;
+	setParameter("ResourceOwnerId", std::to_string(resourceOwnerId));
+}
+
+std::string ModifyLogBackupPolicyRequest::getAccessKeyId()const
+{
+	return accessKeyId_;
+}
+
+void ModifyLogBackupPolicyRequest::setAccessKeyId(const std::string& accessKeyId)
+{
+	accessKeyId_ = accessKeyId;
+	setParameter("AccessKeyId", accessKeyId);
+}
+
+std::string ModifyLogBackupPolicyRequest::getResourceOwnerAccount()const
+{
+	return resourceOwnerAccount_;
+}
+
+void ModifyLogBackupPolicyRequest::setResourceOwnerAccount(const std::string& resourceOwnerAccount)
+{
+	resourceOwnerAccount_ = resourceOwnerAccount;
+	setParameter("ResourceOwnerAccount", resourceOwnerAccount);
+}
+
+std::string ModifyLogBackupPolicyRequest::getDBClusterId()const
+{
+	return dBClusterId_;
+}
+
+void ModifyLogBackupPolicyRequest::setDBClusterId(const std::string& dBClusterId)
+{
+	dBClusterId_ = dBClusterId;
+	setParameter("DBClusterId", dBClusterId);
+}
+
+std::string ModifyLogBackupPolicyRequest::getOwnerAccount()const
+{
+	return ownerAccount_;
+}
+
+void ModifyLogBackupPolicyRequest::setOwnerAccount(const std::string& ownerAccount)
+{
+	ownerAccount_ = ownerAccount;
+	setParameter("OwnerAccount", ownerAccount);
+}
+
+long ModifyLogBackupPolicyRequest::getOwnerId()const
+{
+	return ownerId_;
+}
+
+void ModifyLogBackupPolicyRequest::setOwnerId(long ownerId)
+{
+	ownerId_ = ownerId;
+	setParameter("OwnerId", std::to_string(ownerId));
+}
+
+std::string ModifyLogBackupPolicyRequest::getLogBackupRetentionPeriod()const
+{
+	return logBackupRetentionPeriod_;
+}
+
+void ModifyLogBackupPolicyRequest::setLogBackupRetentionPeriod(const std::string& logBackupRetentionPeriod)
+{
+	logBackupRetentionPeriod_ = logBackupRetentionPeriod;
+	setParameter("LogBackupRetentionPeriod", logBackupRetentionPeriod);
+}
+

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