Skip to content

Commit

Permalink
fix naming for responses of the HTTP queries (#117)
Browse files Browse the repository at this point in the history
  • Loading branch information
@avsej
avsej committed Jan 26, 2022
1 parent ed0c886 commit e0966ea
Show file tree
Hide file tree
Showing 10 changed files with 158 additions and 192 deletions.
128 changes: 58 additions & 70 deletions couchbase/operations/document_analytics.cxx
View file
Expand Up @@ -23,71 +23,6 @@

#include <gsl/assert>

namespace tao::json
{
template<>
struct traits<couchbase::operations::analytics_response_payload> {
template<template<typename...> class Traits>
static couchbase::operations::analytics_response_payload as(const tao::json::basic_value<Traits>& v)
{
couchbase::operations::analytics_response_payload result;
result.meta_data.request_id = v.at("requestID").get_string();
result.meta_data.client_context_id = v.at("clientContextID").get_string();
result.meta_data.status = v.at("status").get_string();

if (const auto* s = v.find("signature"); s != nullptr) {
result.meta_data.signature = couchbase::utils::json::generate(*s);
}

if (const auto* p = v.find("profile"); p != nullptr) {
result.meta_data.profile = couchbase::utils::json::generate(*p);
}

if (const auto* m = v.find("metrics"); m != nullptr) {
result.meta_data.metrics.result_count = m->at("resultCount").get_unsigned();
result.meta_data.metrics.result_size = m->at("resultSize").get_unsigned();
result.meta_data.metrics.elapsed_time = m->at("elapsedTime").get_string();
result.meta_data.metrics.execution_time = m->at("executionTime").get_string();
result.meta_data.metrics.sort_count = m->template optional<std::uint64_t>("sortCount");
result.meta_data.metrics.mutation_count = m->template optional<std::uint64_t>("mutationCount");
result.meta_data.metrics.error_count = m->template optional<std::uint64_t>("errorCount");
result.meta_data.metrics.warning_count = m->template optional<std::uint64_t>("warningCount");
}

if (const auto* e = v.find("errors"); e != nullptr) {
std::vector<couchbase::operations::analytics_response_payload::analytics_problem> problems{};
for (auto& err : e->get_array()) {
couchbase::operations::analytics_response_payload::analytics_problem problem;
problem.code = err.at("code").get_unsigned();
problem.message = err.at("msg").get_string();
problems.emplace_back(problem);
}
result.meta_data.errors.emplace(problems);
}

if (const auto* w = v.find("warnings"); w != nullptr) {
std::vector<couchbase::operations::analytics_response_payload::analytics_problem> problems{};
for (auto& warn : w->get_array()) {
couchbase::operations::analytics_response_payload::analytics_problem problem;
problem.code = warn.at("code").get_unsigned();
problem.message = warn.at("msg").get_string();
problems.emplace_back(problem);
}
result.meta_data.warnings.emplace(problems);
}

if (const auto* r = v.find("results"); r != nullptr) {
result.rows.reserve(result.meta_data.metrics.result_count);
for (auto& row : r->get_array()) {
result.rows.emplace_back(couchbase::utils::json::generate(row));
}
}

return result;
}
};
} // namespace tao::json

namespace couchbase::operations
{
std::error_code
Expand Down Expand Up @@ -164,14 +99,67 @@ analytics_request::make_response(error_context::analytics&& ctx, const encoded_r
response.ctx.statement = statement;
response.ctx.parameters = body_str;
if (!response.ctx.ec) {
tao::json::value payload;
try {
response.payload = utils::json::parse(encoded.body.data()).as<analytics_response_payload>();
payload = utils::json::parse(encoded.body.data());
} catch (const tao::pegtl::parse_error&) {
response.ctx.ec = error::common_errc::parsing_failure;
return response;
}
Expects(response.payload.meta_data.client_context_id == client_context_id);
if (response.payload.meta_data.status != "success") {
response.meta.request_id = payload.at("requestID").get_string();
response.meta.client_context_id = payload.at("clientContextID").get_string();
response.meta.status = payload.at("status").get_string();

if (const auto* s = payload.find("signature"); s != nullptr) {
response.meta.signature = couchbase::utils::json::generate(*s);
}

if (const auto* p = payload.find("profile"); p != nullptr) {
response.meta.profile = couchbase::utils::json::generate(*p);
}

if (const auto* m = payload.find("metrics"); m != nullptr) {
response.meta.metrics.result_count = m->at("resultCount").get_unsigned();
response.meta.metrics.result_size = m->at("resultSize").get_unsigned();
response.meta.metrics.elapsed_time = m->at("elapsedTime").get_string();
response.meta.metrics.execution_time = m->at("executionTime").get_string();
response.meta.metrics.sort_count = m->template optional<std::uint64_t>("sortCount");
response.meta.metrics.mutation_count = m->template optional<std::uint64_t>("mutationCount");
response.meta.metrics.error_count = m->template optional<std::uint64_t>("errorCount");
response.meta.metrics.warning_count = m->template optional<std::uint64_t>("warningCount");
}

if (const auto* e = payload.find("errors"); e != nullptr) {
std::vector<couchbase::operations::analytics_response::analytics_problem> problems{};
for (const auto& err : e->get_array()) {
couchbase::operations::analytics_response::analytics_problem problem;
problem.code = err.at("code").get_unsigned();
problem.message = err.at("msg").get_string();
problems.emplace_back(problem);
}
response.meta.errors.emplace(problems);
}

if (const auto* w = payload.find("warnings"); w != nullptr) {
std::vector<couchbase::operations::analytics_response::analytics_problem> problems{};
for (const auto& warn : w->get_array()) {
couchbase::operations::analytics_response::analytics_problem problem;
problem.code = warn.at("code").get_unsigned();
problem.message = warn.at("msg").get_string();
problems.emplace_back(problem);
}
response.meta.warnings.emplace(problems);
}

if (const auto* r = payload.find("results"); r != nullptr) {
response.rows.reserve(response.meta.metrics.result_count);
for (const auto& row : r->get_array()) {
response.rows.emplace_back(couchbase::utils::json::generate(row));
}
}

Expects(response.meta.client_context_id == client_context_id);
if (response.meta.status != "success") {
bool server_timeout = false;
bool job_queue_is_full = false;
bool dataset_not_found = false;
Expand All @@ -181,8 +169,8 @@ analytics_request::make_response(error_context::analytics&& ctx, const encoded_r
bool link_not_found = false;
bool compilation_failure = false;

if (response.payload.meta_data.errors) {
for (const auto& error : *response.payload.meta_data.errors) {
if (response.meta.errors) {
for (const auto& error : *response.meta.errors) {
switch (error.code) {
case 21002: /* Request timed out and will be cancelled */
server_timeout = true;
Expand Down
10 changes: 3 additions & 7 deletions couchbase/operations/document_analytics.hxx
View file
Expand Up @@ -26,7 +26,7 @@

namespace couchbase::operations
{
struct analytics_response_payload {
struct analytics_response {
struct analytics_metrics {
std::string elapsed_time;
std::string execution_time;
Expand Down Expand Up @@ -54,13 +54,9 @@ struct analytics_response_payload {
std::optional<std::vector<analytics_problem>> errors;
};

analytics_meta_data meta_data{};
std::vector<std::string> rows{};
};

struct analytics_response {
error_context::analytics ctx;
analytics_response_payload payload{};
analytics_meta_data meta{};
std::vector<std::string> rows{};
};

struct analytics_request {
Expand Down
144 changes: 66 additions & 78 deletions couchbase/operations/document_query.cxx
View file
Expand Up @@ -24,75 +24,6 @@

#include <gsl/assert>

namespace tao::json
{
template<>
struct traits<couchbase::operations::query_response_payload> {
template<template<typename...> class Traits>
static couchbase::operations::query_response_payload as(const tao::json::basic_value<Traits>& v)
{
couchbase::operations::query_response_payload result;
result.meta_data.request_id = v.at("requestID").get_string();

if (const auto* i = v.find("clientContextID"); i != nullptr) {
result.meta_data.client_context_id = i->get_string();
}
result.meta_data.status = v.at("status").get_string();
if (const auto* s = v.find("signature"); s != nullptr) {
result.meta_data.signature = couchbase::utils::json::generate(*s);
}
if (const auto* c = v.find("prepared"); c != nullptr) {
result.prepared = c->get_string();
}
if (const auto* p = v.find("profile"); p != nullptr) {
result.meta_data.profile = couchbase::utils::json::generate(*p);
}

if (const auto* m = v.find("metrics"); m != nullptr) {
result.meta_data.metrics.result_count = m->at("resultCount").get_unsigned();
result.meta_data.metrics.result_size = m->at("resultSize").get_unsigned();
result.meta_data.metrics.elapsed_time = m->at("elapsedTime").get_string();
result.meta_data.metrics.execution_time = m->at("executionTime").get_string();
result.meta_data.metrics.sort_count = m->template optional<std::uint64_t>("sortCount");
result.meta_data.metrics.mutation_count = m->template optional<std::uint64_t>("mutationCount");
result.meta_data.metrics.error_count = m->template optional<std::uint64_t>("errorCount");
result.meta_data.metrics.warning_count = m->template optional<std::uint64_t>("warningCount");
}

if (const auto* e = v.find("errors"); e != nullptr) {
std::vector<couchbase::operations::query_response_payload::query_problem> problems{};
for (auto& err : e->get_array()) {
couchbase::operations::query_response_payload::query_problem problem;
problem.code = err.at("code").get_unsigned();
problem.message = err.at("msg").get_string();
problems.emplace_back(problem);
}
result.meta_data.errors.emplace(problems);
}

if (const auto* w = v.find("warnings"); w != nullptr) {
std::vector<couchbase::operations::query_response_payload::query_problem> problems{};
for (auto& warn : w->get_array()) {
couchbase::operations::query_response_payload::query_problem problem;
problem.code = warn.at("code").get_unsigned();
problem.message = warn.at("msg").get_string();
problems.emplace_back(problem);
}
result.meta_data.warnings.emplace(problems);
}

if (const auto* r = v.find("results"); r != nullptr) {
result.rows.reserve(result.meta_data.metrics.result_count);
for (auto& row : r->get_array()) {
result.rows.emplace_back(couchbase::utils::json::generate(row));
}
}

return result;
}
};
} // namespace tao::json

namespace couchbase::operations
{
std::error_code
Expand Down Expand Up @@ -252,22 +183,79 @@ query_request::make_response(error_context::query&& ctx, const encoded_response_
response.ctx.parameters = body_str;
response.served_by_node = response.ctx.last_dispatched_to.value_or("");
if (!response.ctx.ec) {
tao::json::value payload;
try {
response.payload = utils::json::parse(encoded.body.data()).as<query_response_payload>();
payload = utils::json::parse(encoded.body.data());
} catch (const tao::pegtl::parse_error&) {
response.ctx.ec = error::common_errc::parsing_failure;
return response;
}
Expects(response.payload.meta_data.client_context_id.empty() || response.payload.meta_data.client_context_id == client_context_id);
if (response.payload.meta_data.status == "success") {
if (response.payload.prepared) {
ctx_->cache.put(statement, response.payload.prepared.value());
response.meta.request_id = payload.at("requestID").get_string();

if (const auto* i = payload.find("clientContextID"); i != nullptr) {
response.meta.client_context_id = i->get_string();
}
response.meta.status = payload.at("status").get_string();
if (const auto* s = payload.find("signature"); s != nullptr) {
response.meta.signature = couchbase::utils::json::generate(*s);
}
if (const auto* c = payload.find("prepared"); c != nullptr) {
response.prepared = c->get_string();
}
if (const auto* p = payload.find("profile"); p != nullptr) {
response.meta.profile = couchbase::utils::json::generate(*p);
}

if (const auto* m = payload.find("metrics"); m != nullptr) {
response.meta.metrics.result_count = m->at("resultCount").get_unsigned();
response.meta.metrics.result_size = m->at("resultSize").get_unsigned();
response.meta.metrics.elapsed_time = m->at("elapsedTime").get_string();
response.meta.metrics.execution_time = m->at("executionTime").get_string();
response.meta.metrics.sort_count = m->template optional<std::uint64_t>("sortCount");
response.meta.metrics.mutation_count = m->template optional<std::uint64_t>("mutationCount");
response.meta.metrics.error_count = m->template optional<std::uint64_t>("errorCount");
response.meta.metrics.warning_count = m->template optional<std::uint64_t>("warningCount");
}

if (const auto* e = payload.find("errors"); e != nullptr) {
std::vector<couchbase::operations::query_response::query_problem> problems{};
for (const auto& err : e->get_array()) {
couchbase::operations::query_response::query_problem problem;
problem.code = err.at("code").get_unsigned();
problem.message = err.at("msg").get_string();
problems.emplace_back(problem);
}
response.meta.errors.emplace(problems);
}

if (const auto* w = payload.find("warnings"); w != nullptr) {
std::vector<couchbase::operations::query_response::query_problem> problems{};
for (const auto& warn : w->get_array()) {
couchbase::operations::query_response::query_problem problem;
problem.code = warn.at("code").get_unsigned();
problem.message = warn.at("msg").get_string();
problems.emplace_back(problem);
}
response.meta.warnings.emplace(problems);
}

if (const auto* r = payload.find("results"); r != nullptr) {
response.rows.reserve(response.meta.metrics.result_count);
for (const auto& row : r->get_array()) {
response.rows.emplace_back(couchbase::utils::json::generate(row));
}
}

Expects(response.meta.client_context_id.empty() || response.meta.client_context_id == client_context_id);
if (response.meta.status == "success") {
if (response.prepared) {
ctx_->cache.put(statement, response.prepared.value());
} else if (extract_encoded_plan_) {
extract_encoded_plan_ = false;
if (response.payload.rows.size() == 1) {
if (response.rows.size() == 1) {
tao::json::value row{};
try {
row = utils::json::parse(response.payload.rows[0]);
row = utils::json::parse(response.rows[0]);
} catch (const tao::pegtl::parse_error&) {
response.ctx.ec = error::common_errc::parsing_failure;
return response;
Expand Down Expand Up @@ -297,8 +285,8 @@ query_request::make_response(error_context::query&& ctx, const encoded_response_
bool authentication_failure = false;
std::optional<std::error_code> common_ec{};

if (response.payload.meta_data.errors) {
for (const auto& error : *response.payload.meta_data.errors) {
if (response.meta.errors) {
for (const auto& error : *response.meta.errors) {
switch (error.code) {
case 1065: /* IKey: "service.io.request.unrecognized_parameter" */
invalid_argument = true;
Expand Down
13 changes: 3 additions & 10 deletions couchbase/operations/document_query.hxx
View file
Expand Up @@ -28,7 +28,7 @@

namespace couchbase::operations
{
struct query_response_payload {
struct query_response {
struct query_metrics {
std::string elapsed_time;
std::string execution_time;
Expand Down Expand Up @@ -56,17 +56,10 @@ struct query_response_payload {
std::optional<std::vector<query_problem>> errors;
};

query_meta_data meta_data{};
error_context::query ctx;
query_meta_data meta{};
std::optional<std::string> prepared{};
std::vector<std::string> rows{};
};
} // namespace couchbase::operations

namespace couchbase::operations
{
struct query_response {
error_context::query ctx;
query_response_payload payload{};
std::string served_by_node{};
};

Expand Down

0 comments on commit e0966ea

Please sign in to comment.