Generated 2019-09-01 for OceanBasePro.

VERSION

@@ -1 +1 @@
-1.36.1957
+1.36.1958

oceanbasepro/CMakeLists.txt

@@ -159,6 +159,8 @@ set(oceanbasepro_public_header_model
 	include/alibabacloud/oceanbasepro/model/DescribeSQLPlansResult.h
 	include/alibabacloud/oceanbasepro/model/DescribeSQLSamplesRequest.h
 	include/alibabacloud/oceanbasepro/model/DescribeSQLSamplesResult.h
+	include/alibabacloud/oceanbasepro/model/DescribeSQLTuningAdvicesRequest.h
+	include/alibabacloud/oceanbasepro/model/DescribeSQLTuningAdvicesResult.h
 	include/alibabacloud/oceanbasepro/model/DescribeSampleSqlRawTextsRequest.h
 	include/alibabacloud/oceanbasepro/model/DescribeSampleSqlRawTextsResult.h
 	include/alibabacloud/oceanbasepro/model/DescribeSecurityIpGroupsRequest.h
@@ -420,6 +422,8 @@ set(oceanbasepro_src
 	src/model/DescribeSQLPlansResult.cc
 	src/model/DescribeSQLSamplesRequest.cc
 	src/model/DescribeSQLSamplesResult.cc
+	src/model/DescribeSQLTuningAdvicesRequest.cc
+	src/model/DescribeSQLTuningAdvicesResult.cc
 	src/model/DescribeSampleSqlRawTextsRequest.cc
 	src/model/DescribeSampleSqlRawTextsResult.cc
 	src/model/DescribeSecurityIpGroupsRequest.cc

oceanbasepro/include/alibabacloud/oceanbasepro/OceanBaseProClient.h

@@ -160,6 +160,8 @@
 #include "model/DescribeSQLPlansResult.h"
 #include "model/DescribeSQLSamplesRequest.h"
 #include "model/DescribeSQLSamplesResult.h"
+#include "model/DescribeSQLTuningAdvicesRequest.h"
+#include "model/DescribeSQLTuningAdvicesResult.h"
 #include "model/DescribeSampleSqlRawTextsRequest.h"
 #include "model/DescribeSampleSqlRawTextsResult.h"
 #include "model/DescribeSecurityIpGroupsRequest.h"
@@ -496,6 +498,9 @@ namespace AlibabaCloud
 			typedef Outcome<Error, Model::DescribeSQLSamplesResult> DescribeSQLSamplesOutcome;
 			typedef std::future<DescribeSQLSamplesOutcome> DescribeSQLSamplesOutcomeCallable;
 			typedef std::function<void(const OceanBaseProClient*, const Model::DescribeSQLSamplesRequest&, const DescribeSQLSamplesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSQLSamplesAsyncHandler;
+			typedef Outcome<Error, Model::DescribeSQLTuningAdvicesResult> DescribeSQLTuningAdvicesOutcome;
+			typedef std::future<DescribeSQLTuningAdvicesOutcome> DescribeSQLTuningAdvicesOutcomeCallable;
+			typedef std::function<void(const OceanBaseProClient*, const Model::DescribeSQLTuningAdvicesRequest&, const DescribeSQLTuningAdvicesOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSQLTuningAdvicesAsyncHandler;
 			typedef Outcome<Error, Model::DescribeSampleSqlRawTextsResult> DescribeSampleSqlRawTextsOutcome;
 			typedef std::future<DescribeSampleSqlRawTextsOutcome> DescribeSampleSqlRawTextsOutcomeCallable;
 			typedef std::function<void(const OceanBaseProClient*, const Model::DescribeSampleSqlRawTextsRequest&, const DescribeSampleSqlRawTextsOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> DescribeSampleSqlRawTextsAsyncHandler;
@@ -888,6 +893,9 @@ namespace AlibabaCloud
 			DescribeSQLSamplesOutcome describeSQLSamples(const Model::DescribeSQLSamplesRequest &request)const;
 			void describeSQLSamplesAsync(const Model::DescribeSQLSamplesRequest& request, const DescribeSQLSamplesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeSQLSamplesOutcomeCallable describeSQLSamplesCallable(const Model::DescribeSQLSamplesRequest& request) const;
+			DescribeSQLTuningAdvicesOutcome describeSQLTuningAdvices(const Model::DescribeSQLTuningAdvicesRequest &request)const;
+			void describeSQLTuningAdvicesAsync(const Model::DescribeSQLTuningAdvicesRequest& request, const DescribeSQLTuningAdvicesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
+			DescribeSQLTuningAdvicesOutcomeCallable describeSQLTuningAdvicesCallable(const Model::DescribeSQLTuningAdvicesRequest& request) const;
 			DescribeSampleSqlRawTextsOutcome describeSampleSqlRawTexts(const Model::DescribeSampleSqlRawTextsRequest &request)const;
 			void describeSampleSqlRawTextsAsync(const Model::DescribeSampleSqlRawTextsRequest& request, const DescribeSampleSqlRawTextsAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
 			DescribeSampleSqlRawTextsOutcomeCallable describeSampleSqlRawTextsCallable(const Model::DescribeSampleSqlRawTextsRequest& request) const;

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeSQLTuningAdvicesRequest.h

@@ -0,0 +1,60 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBESQLTUNINGADVICESREQUEST_H_
+#define ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBESQLTUNINGADVICESREQUEST_H_
+
+#include <alibabacloud/oceanbasepro/OceanBaseProExport.h>
+#include <alibabacloud/core/RpcServiceRequest.h>
+#include <string>
+#include <vector>
+#include <map>
+
+namespace AlibabaCloud {
+namespace OceanBasePro {
+namespace Model {
+class ALIBABACLOUD_OCEANBASEPRO_EXPORT DescribeSQLTuningAdvicesRequest : public RpcServiceRequest {
+public:
+	DescribeSQLTuningAdvicesRequest();
+	~DescribeSQLTuningAdvicesRequest();
+	std::string getStartTime() const;
+	void setStartTime(const std::string &startTime);
+	std::string getTenantId() const;
+	void setTenantId(const std::string &tenantId);
+	std::string getSqlId() const;
+	void setSqlId(const std::string &sqlId);
+	std::string getEndTime() const;
+	void setEndTime(const std::string &endTime);
+	std::string getInstanceId() const;
+	void setInstanceId(const std::string &instanceId);
+	std::string getDbName() const;
+	void setDbName(const std::string &dbName);
+	std::string getAcceptLanguage() const;
+	void setAcceptLanguage(const std::string &acceptLanguage);
+
+private:
+	std::string startTime_;
+	std::string tenantId_;
+	std::string sqlId_;
+	std::string endTime_;
+	std::string instanceId_;
+	std::string dbName_;
+	std::string acceptLanguage_;
+};
+} // namespace Model
+} // namespace OceanBasePro
+} // namespace AlibabaCloud
+#endif // !ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBESQLTUNINGADVICESREQUEST_H_

oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeSQLTuningAdvicesResult.h

@@ -0,0 +1,103 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBESQLTUNINGADVICESRESULT_H_
+#define ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBESQLTUNINGADVICESRESULT_H_
+
+#include <string>
+#include <vector>
+#include <utility>
+#include <alibabacloud/core/ServiceResult.h>
+#include <alibabacloud/oceanbasepro/OceanBaseProExport.h>
+
+namespace AlibabaCloud
+{
+	namespace OceanBasePro
+	{
+		namespace Model
+		{
+			class ALIBABACLOUD_OCEANBASEPRO_EXPORT DescribeSQLTuningAdvicesResult : public ServiceResult
+			{
+			public:
+				struct DataItem
+				{
+					struct Plan
+					{
+						long executions;
+						float avgCpuTime;
+						std::string planHash;
+						float timeoutPercentage;
+						float avgConcurrencyWaitTime;
+						long firstLoadTimeUs;
+						float avgDiskWrites;
+						float avgUserIoWaitTime;
+						long planSize;
+						std::string serverSn;
+						std::string outlineData;
+						std::string planType;
+						long obDbId;
+						float hitPercentage;
+						float avgBufferGets;
+						float execPs;
+						float delayedLargeQueryPercentage;
+						bool tableScan;
+						float largeQueryPercentage;
+						long schemaVersion;
+						long planId;
+						std::string firstLoadTime;
+						float avgRowProcessed;
+						long mergedVersion;
+						bool hitDiagnosis;
+						std::string uid;
+						float avgApplicationWaitTime;
+						long collectTimeUs;
+						float avgElapsedTime;
+						long obServerId;
+						long outlineId;
+						float avgDiskReads;
+					};
+					struct ColumnsItem
+					{
+						std::string columnName;
+						float ndv;
+						std::string minValue;
+						std::string maxValue;
+					};
+					std::string type;
+					std::string columnNames;
+					std::string table;
+					std::string localityType;
+					std::vector<DataItem::ColumnsItem> columns;
+					std::string dbName;
+					Plan plan;
+				};
+
+
+				DescribeSQLTuningAdvicesResult();
+				explicit DescribeSQLTuningAdvicesResult(const std::string &payload);
+				~DescribeSQLTuningAdvicesResult();
+				std::vector<DataItem> getData()const;
+
+			protected:
+				void parse(const std::string &payload);
+			private:
+				std::vector<DataItem> data_;
+
+			};
+		}
+	}
+}
+#endif // !ALIBABACLOUD_OCEANBASEPRO_MODEL_DESCRIBESQLTUNINGADVICESRESULT_H_

oceanbasepro/src/OceanBaseProClient.cc

@@ -2535,6 +2535,42 @@ OceanBaseProClient::DescribeSQLSamplesOutcomeCallable OceanBaseProClient::descri
 	return task->get_future();
 }
 
+OceanBaseProClient::DescribeSQLTuningAdvicesOutcome OceanBaseProClient::describeSQLTuningAdvices(const DescribeSQLTuningAdvicesRequest &request) const
+{
+	auto endpointOutcome = endpointProvider_->getEndpoint();
+	if (!endpointOutcome.isSuccess())
+		return DescribeSQLTuningAdvicesOutcome(endpointOutcome.error());
+
+	auto outcome = makeRequest(endpointOutcome.result(), request);
+
+	if (outcome.isSuccess())
+		return DescribeSQLTuningAdvicesOutcome(DescribeSQLTuningAdvicesResult(outcome.result()));
+	else
+		return DescribeSQLTuningAdvicesOutcome(outcome.error());
+}
+
+void OceanBaseProClient::describeSQLTuningAdvicesAsync(const DescribeSQLTuningAdvicesRequest& request, const DescribeSQLTuningAdvicesAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
+{
+	auto fn = [this, request, handler, context]()
+	{
+		handler(this, request, describeSQLTuningAdvices(request), context);
+	};
+
+	asyncExecute(new Runnable(fn));
+}
+
+OceanBaseProClient::DescribeSQLTuningAdvicesOutcomeCallable OceanBaseProClient::describeSQLTuningAdvicesCallable(const DescribeSQLTuningAdvicesRequest &request) const
+{
+	auto task = std::make_shared<std::packaged_task<DescribeSQLTuningAdvicesOutcome()>>(
+			[this, request]()
+			{
+			return this->describeSQLTuningAdvices(request);
+			});
+
+	asyncExecute(new Runnable([task]() { (*task)(); }));
+	return task->get_future();
+}
+
 OceanBaseProClient::DescribeSampleSqlRawTextsOutcome OceanBaseProClient::describeSampleSqlRawTexts(const DescribeSampleSqlRawTextsRequest &request) const
 {
 	auto endpointOutcome = endpointProvider_->getEndpoint();

oceanbasepro/src/model/DescribeSQLTuningAdvicesRequest.cc

@@ -0,0 +1,90 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/oceanbasepro/model/DescribeSQLTuningAdvicesRequest.h>
+
+using AlibabaCloud::OceanBasePro::Model::DescribeSQLTuningAdvicesRequest;
+
+DescribeSQLTuningAdvicesRequest::DescribeSQLTuningAdvicesRequest()
+    : RpcServiceRequest("oceanbasepro", "2019-09-01", "DescribeSQLTuningAdvices") {
+  setMethod(HttpRequest::Method::Post);
+}
+
+DescribeSQLTuningAdvicesRequest::~DescribeSQLTuningAdvicesRequest() {}
+
+std::string DescribeSQLTuningAdvicesRequest::getStartTime() const {
+  return startTime_;
+}
+
+void DescribeSQLTuningAdvicesRequest::setStartTime(const std::string &startTime) {
+  startTime_ = startTime;
+  setBodyParameter(std::string("StartTime"), startTime);
+}
+
+std::string DescribeSQLTuningAdvicesRequest::getTenantId() const {
+  return tenantId_;
+}
+
+void DescribeSQLTuningAdvicesRequest::setTenantId(const std::string &tenantId) {
+  tenantId_ = tenantId;
+  setBodyParameter(std::string("TenantId"), tenantId);
+}
+
+std::string DescribeSQLTuningAdvicesRequest::getSqlId() const {
+  return sqlId_;
+}
+
+void DescribeSQLTuningAdvicesRequest::setSqlId(const std::string &sqlId) {
+  sqlId_ = sqlId;
+  setBodyParameter(std::string("SqlId"), sqlId);
+}
+
+std::string DescribeSQLTuningAdvicesRequest::getEndTime() const {
+  return endTime_;
+}
+
+void DescribeSQLTuningAdvicesRequest::setEndTime(const std::string &endTime) {
+  endTime_ = endTime;
+  setBodyParameter(std::string("EndTime"), endTime);
+}
+
+std::string DescribeSQLTuningAdvicesRequest::getInstanceId() const {
+  return instanceId_;
+}
+
+void DescribeSQLTuningAdvicesRequest::setInstanceId(const std::string &instanceId) {
+  instanceId_ = instanceId;
+  setBodyParameter(std::string("InstanceId"), instanceId);
+}
+
+std::string DescribeSQLTuningAdvicesRequest::getDbName() const {
+  return dbName_;
+}
+
+void DescribeSQLTuningAdvicesRequest::setDbName(const std::string &dbName) {
+  dbName_ = dbName;
+  setBodyParameter(std::string("DbName"), dbName);
+}
+
+std::string DescribeSQLTuningAdvicesRequest::getAcceptLanguage() const {
+  return acceptLanguage_;
+}
+
+void DescribeSQLTuningAdvicesRequest::setAcceptLanguage(const std::string &acceptLanguage) {
+  acceptLanguage_ = acceptLanguage;
+  setBodyParameter(std::string("AcceptLanguage"), acceptLanguage);
+}
+

oceanbasepro/src/model/DescribeSQLTuningAdvicesResult.cc

@@ -0,0 +1,144 @@
+/*
+ * Copyright 2009-2017 Alibaba Cloud All rights reserved.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <alibabacloud/oceanbasepro/model/DescribeSQLTuningAdvicesResult.h>
+#include <json/json.h>
+
+using namespace AlibabaCloud::OceanBasePro;
+using namespace AlibabaCloud::OceanBasePro::Model;
+
+DescribeSQLTuningAdvicesResult::DescribeSQLTuningAdvicesResult() :
+	ServiceResult()
+{}
+
+DescribeSQLTuningAdvicesResult::DescribeSQLTuningAdvicesResult(const std::string &payload) :
+	ServiceResult()
+{
+	parse(payload);
+}
+
+DescribeSQLTuningAdvicesResult::~DescribeSQLTuningAdvicesResult()
+{}
+
+void DescribeSQLTuningAdvicesResult::parse(const std::string &payload)
+{
+	Json::Reader reader;
+	Json::Value value;
+	reader.parse(payload, value);
+	setRequestId(value["RequestId"].asString());
+	auto allDataNode = value["Data"]["DataItem"];
+	for (auto valueDataDataItem : allDataNode)
+	{
+		DataItem dataObject;
+		if(!valueDataDataItem["Type"].isNull())
+			dataObject.type = valueDataDataItem["Type"].asString();
+		if(!valueDataDataItem["ColumnNames"].isNull())
+			dataObject.columnNames = valueDataDataItem["ColumnNames"].asString();
+		if(!valueDataDataItem["LocalityType"].isNull())
+			dataObject.localityType = valueDataDataItem["LocalityType"].asString();
+		if(!valueDataDataItem["DbName"].isNull())
+			dataObject.dbName = valueDataDataItem["DbName"].asString();
+		if(!valueDataDataItem["Table"].isNull())
+			dataObject.table = valueDataDataItem["Table"].asString();
+		auto allColumnsNode = valueDataDataItem["Columns"]["ColumnsItem"];
+		for (auto valueDataDataItemColumnsColumnsItem : allColumnsNode)
+		{
+			DataItem::ColumnsItem columnsObject;
+			if(!valueDataDataItemColumnsColumnsItem["ColumnName"].isNull())
+				columnsObject.columnName = valueDataDataItemColumnsColumnsItem["ColumnName"].asString();
+			if(!valueDataDataItemColumnsColumnsItem["Ndv"].isNull())
+				columnsObject.ndv = std::stof(valueDataDataItemColumnsColumnsItem["Ndv"].asString());
+			if(!valueDataDataItemColumnsColumnsItem["MinValue"].isNull())
+				columnsObject.minValue = valueDataDataItemColumnsColumnsItem["MinValue"].asString();
+			if(!valueDataDataItemColumnsColumnsItem["MaxValue"].isNull())
+				columnsObject.maxValue = valueDataDataItemColumnsColumnsItem["MaxValue"].asString();
+			dataObject.columns.push_back(columnsObject);
+		}
+		auto planNode = value["Plan"];
+		if(!planNode["Executions"].isNull())
+			dataObject.plan.executions = std::stol(planNode["Executions"].asString());
+		if(!planNode["AvgCpuTime"].isNull())
+			dataObject.plan.avgCpuTime = std::stof(planNode["AvgCpuTime"].asString());
+		if(!planNode["PlanHash"].isNull())
+			dataObject.plan.planHash = planNode["PlanHash"].asString();
+		if(!planNode["TimeoutPercentage"].isNull())
+			dataObject.plan.timeoutPercentage = std::stof(planNode["TimeoutPercentage"].asString());
+		if(!planNode["AvgConcurrencyWaitTime"].isNull())
+			dataObject.plan.avgConcurrencyWaitTime = std::stof(planNode["AvgConcurrencyWaitTime"].asString());
+		if(!planNode["FirstLoadTimeUs"].isNull())
+			dataObject.plan.firstLoadTimeUs = std::stol(planNode["FirstLoadTimeUs"].asString());
+		if(!planNode["AvgDiskWrites"].isNull())
+			dataObject.plan.avgDiskWrites = std::stof(planNode["AvgDiskWrites"].asString());
+		if(!planNode["AvgUserIoWaitTime"].isNull())
+			dataObject.plan.avgUserIoWaitTime = std::stof(planNode["AvgUserIoWaitTime"].asString());
+		if(!planNode["PlanSize"].isNull())
+			dataObject.plan.planSize = std::stol(planNode["PlanSize"].asString());
+		if(!planNode["ServerSn"].isNull())
+			dataObject.plan.serverSn = planNode["ServerSn"].asString();
+		if(!planNode["OutlineData"].isNull())
+			dataObject.plan.outlineData = planNode["OutlineData"].asString();
+		if(!planNode["PlanType"].isNull())
+			dataObject.plan.planType = planNode["PlanType"].asString();
+		if(!planNode["ObDbId"].isNull())
+			dataObject.plan.obDbId = std::stol(planNode["ObDbId"].asString());
+		if(!planNode["HitPercentage"].isNull())
+			dataObject.plan.hitPercentage = std::stof(planNode["HitPercentage"].asString());
+		if(!planNode["AvgBufferGets"].isNull())
+			dataObject.plan.avgBufferGets = std::stof(planNode["AvgBufferGets"].asString());
+		if(!planNode["ExecPs"].isNull())
+			dataObject.plan.execPs = std::stof(planNode["ExecPs"].asString());
+		if(!planNode["DelayedLargeQueryPercentage"].isNull())
+			dataObject.plan.delayedLargeQueryPercentage = std::stof(planNode["DelayedLargeQueryPercentage"].asString());
+		if(!planNode["TableScan"].isNull())
+			dataObject.plan.tableScan = planNode["TableScan"].asString() == "true";
+		if(!planNode["LargeQueryPercentage"].isNull())
+			dataObject.plan.largeQueryPercentage = std::stof(planNode["LargeQueryPercentage"].asString());
+		if(!planNode["SchemaVersion"].isNull())
+			dataObject.plan.schemaVersion = std::stol(planNode["SchemaVersion"].asString());
+		if(!planNode["PlanId"].isNull())
+			dataObject.plan.planId = std::stol(planNode["PlanId"].asString());
+		if(!planNode["FirstLoadTime"].isNull())
+			dataObject.plan.firstLoadTime = planNode["FirstLoadTime"].asString();
+		if(!planNode["AvgRowProcessed"].isNull())
+			dataObject.plan.avgRowProcessed = std::stof(planNode["AvgRowProcessed"].asString());
+		if(!planNode["MergedVersion"].isNull())
+			dataObject.plan.mergedVersion = std::stol(planNode["MergedVersion"].asString());
+		if(!planNode["HitDiagnosis"].isNull())
+			dataObject.plan.hitDiagnosis = planNode["HitDiagnosis"].asString() == "true";
+		if(!planNode["Uid"].isNull())
+			dataObject.plan.uid = planNode["Uid"].asString();
+		if(!planNode["AvgApplicationWaitTime"].isNull())
+			dataObject.plan.avgApplicationWaitTime = std::stof(planNode["AvgApplicationWaitTime"].asString());
+		if(!planNode["CollectTimeUs"].isNull())
+			dataObject.plan.collectTimeUs = std::stol(planNode["CollectTimeUs"].asString());
+		if(!planNode["AvgElapsedTime"].isNull())
+			dataObject.plan.avgElapsedTime = std::stof(planNode["AvgElapsedTime"].asString());
+		if(!planNode["ObServerId"].isNull())
+			dataObject.plan.obServerId = std::stol(planNode["ObServerId"].asString());
+		if(!planNode["OutlineId"].isNull())
+			dataObject.plan.outlineId = std::stol(planNode["OutlineId"].asString());
+		if(!planNode["AvgDiskReads"].isNull())
+			dataObject.plan.avgDiskReads = std::stof(planNode["AvgDiskReads"].asString());
+		data_.push_back(dataObject);
+	}
+
+}
+
+std::vector<DescribeSQLTuningAdvicesResult::DataItem> DescribeSQLTuningAdvicesResult::getData()const
+{
+	return data_;
+}
+