couchbase 3.1.1 → 3.2.0

data/ext/couchbase/operations/bucket_update.hxx

@@ -44,7 +44,7 @@ struct bucket_update_request {
 
     bucket_settings bucket{};
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& /* context */) const
     {
         encoded.method = "POST";
         encoded.path = fmt::format("/pools/default/buckets/{}", bucket.name);
@@ -105,23 +105,23 @@ struct bucket_update_request {
 };
 
 bucket_update_response
-make_response(error_context::http&& ctx, bucket_update_request& /* request */, bucket_update_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx, const bucket_update_request& /* request */, bucket_update_request::encoded_response_type&& encoded)
 {
-    bucket_update_response response{ ctx };
+    bucket_update_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         switch (encoded.status_code) {
             case 404:
-                response.ctx.ec = std::make_error_code(error::common_errc::bucket_not_found);
+                response.ctx.ec = error::common_errc::bucket_not_found;
                 break;
             case 400: {
                 tao::json::value payload{};
                 try {
                     payload = tao::json::from_string(encoded.body);
-                } catch (tao::json::pegtl::parse_error& e) {
-                    response.ctx.ec = std::make_error_code(error::common_errc::parsing_failure);
+                } catch (const tao::json::pegtl::parse_error& e) {
+                    response.ctx.ec = error::common_errc::parsing_failure;
                     return response;
                 }
-                response.ctx.ec = std::make_error_code(error::common_errc::invalid_argument);
+                response.ctx.ec = error::common_errc::invalid_argument;
                 auto* errors = payload.find("errors");
                 if (errors != nullptr) {
                     std::vector<std::string> error_list{};
@@ -137,7 +137,7 @@ make_response(error_context::http&& ctx, bucket_update_request& /* request */, b
             case 202:
                 break;
             default:
-                response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
+                response.ctx.ec = error::common_errc::internal_server_failure;
                 break;
         }
     }

data/ext/couchbase/operations/cluster_developer_preview_enable.hxx

@@ -39,7 +39,7 @@ struct cluster_developer_preview_enable_request {
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
     std::string client_context_id{ uuid::to_string(uuid::random()) };
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& /* context */) const
     {
         encoded.method = "POST";
         encoded.headers["content-type"] = "application/x-www-form-urlencoded";
@@ -50,13 +50,13 @@ struct cluster_developer_preview_enable_request {
 };
 
 cluster_developer_preview_enable_response
-make_response(error_context::http&& ctx, cluster_developer_preview_enable_request&, scope_get_all_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx,
+              const cluster_developer_preview_enable_request& /* request */,
+              scope_get_all_request::encoded_response_type&& encoded)
 {
-    cluster_developer_preview_enable_response response{ ctx };
-    if (!response.ctx.ec) {
-        if (encoded.status_code != 200) {
-            response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
-        }
+    cluster_developer_preview_enable_response response{ std::move(ctx) };
+    if (!response.ctx.ec && encoded.status_code != 200) {
+        response.ctx.ec = error::common_errc::internal_server_failure;
     }
     return response;
 }

data/ext/couchbase/operations/collection_create.hxx

@@ -46,7 +46,7 @@ struct collection_create_request {
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
     std::string client_context_id{ uuid::to_string(uuid::random()) };
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& /* context */) const
     {
         encoded.method = "POST";
         encoded.path = fmt::format("/pools/default/buckets/{}/scopes/{}/collections", bucket_name, scope_name);
@@ -61,42 +61,42 @@ struct collection_create_request {
 
 collection_create_response
 make_response(error_context::http&& ctx,
-              collection_create_request& /* request */,
+              const collection_create_request& /* request */,
               collection_create_request::encoded_response_type&& encoded)
 {
-    collection_create_response response{ ctx };
+    collection_create_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         switch (encoded.status_code) {
             case 400: {
                 std::regex collection_exists("Collection with name .+ already exists");
                 if (std::regex_search(encoded.body, collection_exists)) {
-                    response.ctx.ec = std::make_error_code(error::management_errc::collection_exists);
+                    response.ctx.ec = error::management_errc::collection_exists;
                 } else if (encoded.body.find("Not allowed on this version of cluster") != std::string::npos) {
-                    response.ctx.ec = std::make_error_code(error::common_errc::feature_not_available);
+                    response.ctx.ec = error::common_errc::feature_not_available;
                 } else {
-                    response.ctx.ec = std::make_error_code(error::common_errc::invalid_argument);
+                    response.ctx.ec = error::common_errc::invalid_argument;
                 }
             } break;
             case 404: {
                 std::regex scope_not_found("Scope with name .+ is not found");
                 if (std::regex_search(encoded.body, scope_not_found)) {
-                    response.ctx.ec = std::make_error_code(error::common_errc::scope_not_found);
+                    response.ctx.ec = error::common_errc::scope_not_found;
                 } else {
-                    response.ctx.ec = std::make_error_code(error::common_errc::bucket_not_found);
+                    response.ctx.ec = error::common_errc::bucket_not_found;
                 }
             } break;
             case 200: {
                 tao::json::value payload{};
                 try {
                     payload = tao::json::from_string(encoded.body);
-                } catch (tao::json::pegtl::parse_error& e) {
-                    response.ctx.ec = std::make_error_code(error::common_errc::parsing_failure);
+                } catch (const tao::json::pegtl::parse_error& e) {
+                    response.ctx.ec = error::common_errc::parsing_failure;
                     return response;
                 }
                 response.uid = std::stoull(payload.at("uid").get_string(), 0, 16);
             } break;
             default:
-                response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
+                response.ctx.ec = error::common_errc::internal_server_failure;
                 break;
         }
     }

data/ext/couchbase/operations/collection_drop.hxx

@@ -47,7 +47,7 @@ struct collection_drop_request {
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
     std::string client_context_id{ uuid::to_string(uuid::random()) };
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& /* context */) const
     {
         encoded.method = "DELETE";
         encoded.path = fmt::format("/pools/default/buckets/{}/scopes/{}/collections/{}", bucket_name, scope_name, collection_name);
@@ -56,37 +56,39 @@ struct collection_drop_request {
 };
 
 collection_drop_response
-make_response(error_context::http&& ctx, collection_drop_request& /* request */, collection_drop_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx,
+              const collection_drop_request& /* request */,
+              collection_drop_request::encoded_response_type&& encoded)
 {
-    collection_drop_response response{ ctx };
+    collection_drop_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         switch (encoded.status_code) {
             case 400:
-                response.ctx.ec = std::make_error_code(error::common_errc::unsupported_operation);
+                response.ctx.ec = error::common_errc::unsupported_operation;
                 break;
             case 404: {
                 std::regex scope_not_found("Scope with name .+ is not found");
                 std::regex collection_not_found("Collection with name .+ is not found");
                 if (std::regex_search(encoded.body, collection_not_found)) {
-                    response.ctx.ec = std::make_error_code(error::common_errc::collection_not_found);
+                    response.ctx.ec = error::common_errc::collection_not_found;
                 } else if (std::regex_search(encoded.body, scope_not_found)) {
-                    response.ctx.ec = std::make_error_code(error::common_errc::scope_not_found);
+                    response.ctx.ec = error::common_errc::scope_not_found;
                 } else {
-                    response.ctx.ec = std::make_error_code(error::common_errc::bucket_not_found);
+                    response.ctx.ec = error::common_errc::bucket_not_found;
                 }
             } break;
             case 200: {
                 tao::json::value payload{};
                 try {
                     payload = tao::json::from_string(encoded.body);
-                } catch (tao::json::pegtl::parse_error& e) {
-                    response.ctx.ec = std::make_error_code(error::common_errc::parsing_failure);
+                } catch (const tao::json::pegtl::parse_error& e) {
+                    response.ctx.ec = error::common_errc::parsing_failure;
                     return response;
                 }
                 response.uid = std::stoull(payload.at("uid").get_string(), 0, 16);
             } break;
             default:
-                response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
+                response.ctx.ec = error::common_errc::internal_server_failure;
                 break;
         }
     }

data/ext/couchbase/operations/collections_manifest_get.hxx

@@ -45,7 +45,7 @@ struct collections_manifest_get_request {
     std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
     io::retry_context<io::retry_strategy::best_effort> retries{ true };
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&& /* context */) const
     {
         encoded.opaque(opaque);
         return {};
@@ -54,10 +54,10 @@ struct collections_manifest_get_request {
 
 collections_manifest_get_response
 make_response(error_context::key_value&& ctx,
-              collections_manifest_get_request&,
+              const collections_manifest_get_request& /* request */,
               collections_manifest_get_request::encoded_response_type&& encoded)
 {
-    collections_manifest_get_response response{ ctx };
+    collections_manifest_get_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         response.manifest = encoded.body().manifest();
     }

data/ext/couchbase/operations/design_document.hxx

@@ -27,8 +27,8 @@ struct design_document {
 
     struct view {
         std::string name;
-        std::optional<std::string> map;
-        std::optional<std::string> reduce;
+        std::optional<std::string> map{};
+        std::optional<std::string> reduce{};
     };
 
     std::string rev;

data/ext/couchbase/operations/document_analytics.hxx

@@ -79,18 +79,16 @@ struct traits<couchbase::operations::analytics_response_payload> {
         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();
-        const auto s = v.find("signature");
-        if (s != nullptr) {
+
+        if (const auto* s = v.find("signature"); s != nullptr) {
             result.meta_data.signature = tao::json::to_string(*s);
         }
 
-        const auto p = v.find("profile");
-        if (p != nullptr) {
+        if (const auto* p = v.find("profile"); p != nullptr) {
             result.meta_data.profile = tao::json::to_string(*p);
         }
 
-        const auto m = v.find("metrics");
-        if (m != nullptr) {
+        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();
@@ -101,8 +99,7 @@ struct traits<couchbase::operations::analytics_response_payload> {
             result.meta_data.metrics.warning_count = m->template optional<std::uint64_t>("warningCount");
         }
 
-        const auto e = v.find("errors");
-        if (e != nullptr) {
+        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;
@@ -113,8 +110,7 @@ struct traits<couchbase::operations::analytics_response_payload> {
             result.meta_data.errors.emplace(problems);
         }
 
-        const auto w = v.find("warnings");
-        if (w != nullptr) {
+        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;
@@ -124,8 +120,8 @@ struct traits<couchbase::operations::analytics_response_payload> {
             }
             result.meta_data.warnings.emplace(problems);
         }
-        const auto r = v.find("results");
-        if (r != nullptr) {
+
+        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(tao::json::to_string(row));
@@ -178,13 +174,13 @@ struct analytics_request {
                                { "client_context_id", client_context_id },
                                { "timeout", fmt::format("{}ms", timeout.count()) } };
         if (positional_parameters.empty()) {
-            for (auto& param : named_parameters) {
-                Expects(param.first.empty() == false);
-                std::string key = param.first;
+            for (const auto& [name, value] : named_parameters) {
+                Expects(name.empty() == false);
+                std::string key = name;
                 if (key[0] != '$') {
                     key.insert(key.begin(), '$');
                 }
-                body[key] = param.second;
+                body[key] = value;
             }
         } else {
             body["args"] = positional_parameters;
@@ -204,14 +200,11 @@ struct analytics_request {
         }
         if (scope_qualifier) {
             body["query_context"] = scope_qualifier;
-        } else if (scope_name) {
-            if (bucket_name) {
-                // for analytics bucket_name.scope_name is quoted as a single unit (unlike n1ql query)
-                body["query_context"] = fmt::format("default:`{}.{}`", *bucket_name, *scope_name);
-            }
+        } else if (scope_name && bucket_name) {
+            body["query_context"] = fmt::format("default:`{}`.`{}`", *bucket_name, *scope_name);
         }
-        for (auto& param : raw) {
-            body[param.first] = param.second;
+        for (const auto& [name, value] : raw) {
+            body[name] = value;
         }
         encoded.type = type;
         encoded.headers["content-type"] = "application/json";
@@ -232,16 +225,16 @@ struct analytics_request {
 };
 
 analytics_response
-make_response(error_context::analytics&& ctx, analytics_request& request, analytics_request::encoded_response_type&& encoded)
+make_response(error_context::analytics&& ctx, const analytics_request& request, analytics_request::encoded_response_type&& encoded)
 {
-    analytics_response response{ ctx };
+    analytics_response response{ std::move(ctx) };
     response.ctx.statement = request.statement;
     response.ctx.parameters = request.body_str;
     if (!response.ctx.ec) {
         try {
             response.payload = tao::json::from_string(encoded.body).as<analytics_response_payload>();
-        } catch (tao::json::pegtl::parse_error& e) {
-            response.ctx.ec = std::make_error_code(error::common_errc::parsing_failure);
+        } catch (const tao::json::pegtl::parse_error&) {
+            response.ctx.ec = error::common_errc::parsing_failure;
             return response;
         }
         Expects(response.payload.meta_data.client_context_id == request.client_context_id);
@@ -290,23 +283,23 @@ make_response(error_context::analytics&& ctx, analytics_request& request, analyt
                 }
             }
             if (compilation_failure) {
-                response.ctx.ec = std::make_error_code(error::analytics_errc::compilation_failure);
+                response.ctx.ec = error::analytics_errc::compilation_failure;
             } else if (link_not_found) {
-                response.ctx.ec = std::make_error_code(error::analytics_errc::link_not_found);
+                response.ctx.ec = error::analytics_errc::link_not_found;
             } else if (dataset_not_found) {
-                response.ctx.ec = std::make_error_code(error::analytics_errc::dataset_not_found);
+                response.ctx.ec = error::analytics_errc::dataset_not_found;
             } else if (dataverse_not_found) {
-                response.ctx.ec = std::make_error_code(error::analytics_errc::dataverse_not_found);
+                response.ctx.ec = error::analytics_errc::dataverse_not_found;
             } else if (server_timeout) {
-                response.ctx.ec = std::make_error_code(error::common_errc::unambiguous_timeout);
+                response.ctx.ec = error::common_errc::unambiguous_timeout;
             } else if (dataset_exists) {
-                response.ctx.ec = std::make_error_code(error::analytics_errc::dataset_exists);
+                response.ctx.ec = error::analytics_errc::dataset_exists;
             } else if (dataverse_exists) {
-                response.ctx.ec = std::make_error_code(error::analytics_errc::dataverse_exists);
+                response.ctx.ec = error::analytics_errc::dataverse_exists;
             } else if (job_queue_is_full) {
-                response.ctx.ec = std::make_error_code(error::analytics_errc::job_queue_full);
+                response.ctx.ec = error::analytics_errc::job_queue_full;
             } else {
-                response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
+                response.ctx.ec = error::common_errc::internal_server_failure;
             }
         }
     }

data/ext/couchbase/operations/document_append.hxx

@@ -43,7 +43,7 @@ struct append_request {
     std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
     io::retry_context<io::retry_strategy::best_effort> retries{ false };
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&& /* context */) const
     {
         encoded.opaque(opaque);
         encoded.partition(partition);
@@ -57,9 +57,9 @@ struct append_request {
 };
 
 append_response
-make_response(error_context::key_value&& ctx, append_request& request, append_request::encoded_response_type&& encoded)
+make_response(error_context::key_value&& ctx, const append_request& request, append_request::encoded_response_type&& encoded)
 {
-    append_response response{ ctx };
+    append_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         response.cas = encoded.cas();
         response.token = encoded.body().token();

data/ext/couchbase/operations/document_decrement.hxx

@@ -47,7 +47,7 @@ struct decrement_request {
     io::retry_context<io::retry_strategy::best_effort> retries{ false };
     bool preserve_expiry{ false };
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&& /* context */) const
     {
         encoded.opaque(opaque);
         encoded.partition(partition);
@@ -71,9 +71,9 @@ struct decrement_request {
 };
 
 decrement_response
-make_response(error_context::key_value&& ctx, decrement_request& request, decrement_request::encoded_response_type&& encoded)
+make_response(error_context::key_value&& ctx, const decrement_request& request, decrement_request::encoded_response_type&& encoded)
 {
-    decrement_response response{ ctx };
+    decrement_response response{ std::move(ctx) };
     if (!ctx.ec) {
         response.cas = encoded.cas();
         response.content = encoded.body().content();

data/ext/couchbase/operations/document_exists.hxx

@@ -43,7 +43,7 @@ struct exists_request {
     std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
     io::retry_context<io::retry_strategy::best_effort> retries{ false };
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&& /* context */) const
     {
         encoded.opaque(opaque);
         encoded.body().id(partition, id);
@@ -52,7 +52,7 @@ struct exists_request {
 };
 
 exists_response
-make_response(error_context::key_value&& ctx, exists_request& request, exists_request::encoded_response_type&& encoded)
+make_response(error_context::key_value&& ctx, const exists_request& request, exists_request::encoded_response_type&& encoded)
 {
     exists_response response{ ctx, request.partition };
     if (!ctx.ec) {

data/ext/couchbase/operations/document_get.hxx

@@ -42,7 +42,7 @@ struct get_request {
     std::chrono::milliseconds timeout{ timeout_defaults::key_value_timeout };
     io::retry_context<io::retry_strategy::best_effort> retries{ true };
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&&)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, mcbp_context&& /* context */) const
     {
         encoded.opaque(opaque);
         encoded.partition(partition);
@@ -52,9 +52,9 @@ struct get_request {
 };
 
 get_response
-make_response(error_context::key_value&& ctx, get_request&, get_request::encoded_response_type&& encoded)
+make_response(error_context::key_value&& ctx, const get_request& /* request */, get_request::encoded_response_type&& encoded)
 {
-    get_response response{ ctx };
+    get_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         response.value = std::move(encoded.body().value());
         response.cas = encoded.cas();