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

Generated 2019-09-01 for OceanBasePro.

Browse Source
This commit is contained in:
sdk-team
2024-07-24 10:05:23 +00:00
parent f80621c4a4
commit 16843433e4
8 changed files with 446 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
oceanbasepro/CMakeLists.txt
View File

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

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

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

60
oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeSQLTuningAdvicesRequest.h Normal file
View File

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

103
oceanbasepro/include/alibabacloud/oceanbasepro/model/DescribeSQLTuningAdvicesResult.h Normal file
View File

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

36
oceanbasepro/src/OceanBaseProClient.cc
View File

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

90
oceanbasepro/src/model/DescribeSQLTuningAdvicesRequest.cc Normal file
View File

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

144
oceanbasepro/src/model/DescribeSQLTuningAdvicesResult.cc Normal file
View File

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