couchbase 4.4.1-dev.2 → 4.4.2

package/deps/couchbase-cxx-client/core/mcbp/operation_queue.cxx

@@ -26,6 +26,7 @@
 #include <fmt/core.h>
 
 #include <algorithm>
+#include <iterator>
 #include <memory>
 
 namespace couchbase::core::mcbp
@@ -33,7 +34,7 @@ namespace couchbase::core::mcbp
 auto
 operation_queue::debug_string() const -> std::string
 {
-  std::scoped_lock lock(mutex_);
+  const std::scoped_lock lock(mutex_);
   std::vector<char> out;
   fmt::format_to(
     std::back_insert_iterator(out), "num_items: {}, is_open: {}", items_.size(), is_open_);
@@ -47,9 +48,9 @@ operation_queue::consumer() -> std::shared_ptr<operation_consumer>
 }
 
 void
-operation_queue::close_consumer(std::shared_ptr<operation_consumer> consumer)
+operation_queue::close_consumer(const std::shared_ptr<operation_consumer>& consumer)
 {
-  std::scoped_lock lock(mutex_);
+  const std::scoped_lock lock(mutex_);
   consumer->close();
   signal_.notify_all();
 }
@@ -57,7 +58,7 @@ operation_queue::close_consumer(std::shared_ptr<operation_consumer> consumer)
 void
 operation_queue::close()
 {
-  std::scoped_lock lock(mutex_);
+  const std::scoped_lock lock(mutex_);
   is_open_ = false;
   signal_.notify_all();
 }
@@ -66,7 +67,7 @@ auto
 operation_queue::push(std::shared_ptr<queue_request> request,
                       std::size_t max_items) -> std::error_code
 {
-  std::scoped_lock lock(mutex_);
+  const std::scoped_lock lock(mutex_);
 
   if (!is_open_) {
     return errc::network::operation_queue_closed;
@@ -93,9 +94,9 @@ operation_queue::push(std::shared_ptr<queue_request> request,
 }
 
 auto
-operation_queue::remove(std::shared_ptr<queue_request> request) -> bool
+operation_queue::remove(const std::shared_ptr<queue_request>& request) -> bool
 {
-  std::scoped_lock lock(mutex_);
+  const std::scoped_lock lock(mutex_);
 
   if (!is_open_) {
     return false;
@@ -115,7 +116,8 @@ operation_queue::remove(std::shared_ptr<queue_request> request) -> bool
 }
 
 auto
-operation_queue::pop(std::shared_ptr<operation_consumer> consumer) -> std::shared_ptr<queue_request>
+operation_queue::pop(const std::shared_ptr<operation_consumer>& consumer)
+  -> std::shared_ptr<queue_request>
 {
   std::unique_lock lock(mutex_);
 
@@ -134,7 +136,7 @@ operation_queue::pop(std::shared_ptr<operation_consumer> consumer) -> std::share
 }
 
 void
-operation_queue::drain(operation_queue::drain_callback callback)
+operation_queue::drain(const operation_queue::drain_callback& callback)
 {
   for (const auto& request : items_to_drain()) {
     callback(request);
@@ -144,7 +146,7 @@ operation_queue::drain(operation_queue::drain_callback callback)
 auto
 operation_queue::items_to_drain() -> std::list<std::shared_ptr<queue_request>>
 {
-  std::scoped_lock lock(mutex_);
+  const std::scoped_lock lock(mutex_);
 
   if (is_open_) {
     CB_LOG_ERROR("attempted to drain open MCBP operation queue, ignoring");

package/deps/couchbase-cxx-client/core/mcbp/operation_queue.hxx

@@ -36,16 +36,16 @@ public:
 
   [[nodiscard]] auto push(std::shared_ptr<queue_request> request,
                           std::size_t max_items) -> std::error_code;
-  auto remove(std::shared_ptr<queue_request> request) -> bool;
-  void drain(drain_callback callback);
+  auto remove(const std::shared_ptr<queue_request>& request) -> bool;
+  void drain(const drain_callback& callback);
 
   [[nodiscard]] auto consumer() -> std::shared_ptr<operation_consumer>;
   void close();
   [[nodiscard]] auto debug_string() const -> std::string;
 
 private:
-  void close_consumer(std::shared_ptr<operation_consumer> consumer);
-  auto pop(std::shared_ptr<operation_consumer> consumer) -> std::shared_ptr<queue_request>;
+  void close_consumer(const std::shared_ptr<operation_consumer>& consumer);
+  auto pop(const std::shared_ptr<operation_consumer>& consumer) -> std::shared_ptr<queue_request>;
   auto items_to_drain() -> std::list<std::shared_ptr<queue_request>>;
 
   std::list<std::shared_ptr<queue_request>> items_{};

package/deps/couchbase-cxx-client/core/mcbp/packet.cxx

@@ -25,6 +25,8 @@
 #include <fmt/core.h>
 #include <spdlog/fmt/bin_to_hex.h>
 
+#include <iterator>
+
 namespace couchbase::core::mcbp
 {
 auto

package/deps/couchbase-cxx-client/core/mcbp/queue_request.cxx

@@ -38,7 +38,7 @@ queue_request::queue_request(protocol::magic magic,
 auto
 queue_request::retry_attempts() const -> std::size_t
 {
-  std::scoped_lock lock(retry_mutex_);
+  const std::scoped_lock lock(retry_mutex_);
   return retry_count_;
 }
 
@@ -57,14 +57,14 @@ queue_request::idempotent() const -> bool
 auto
 queue_request::retry_reasons() const -> std::set<retry_reason>
 {
-  std::scoped_lock lock(retry_mutex_);
+  const std::scoped_lock lock(retry_mutex_);
   return retry_reasons_;
 }
 
 void
 queue_request::record_retry_attempt(retry_reason reason)
 {
-  std::scoped_lock lock(retry_mutex_);
+  const std::scoped_lock lock(retry_mutex_);
   ++retry_count_;
   retry_reasons_.insert(reason);
 }
@@ -72,14 +72,14 @@ queue_request::record_retry_attempt(retry_reason reason)
 auto
 queue_request::retries() const -> std::pair<std::size_t, std::set<retry_reason>>
 {
-  std::scoped_lock lock(retry_mutex_);
+  const std::scoped_lock lock(retry_mutex_);
   return { retry_count_, retry_reasons_ };
 }
 
 auto
 queue_request::connection_info() const -> queue_request_connection_info
 {
-  std::scoped_lock lock(connection_info_mutex_);
+  const std::scoped_lock lock(connection_info_mutex_);
   return connection_info_;
 }
 
@@ -89,18 +89,21 @@ queue_request::is_cancelled() const -> bool
   return is_completed_.load();
 }
 
-static inline void
+namespace
+{
+inline void
 cancel_timer(std::shared_ptr<asio::steady_timer> timer)
 {
   if (auto t = std::move(timer); t) {
     t->cancel();
   }
 }
+} // namespace
 
 auto
 queue_request::internal_cancel() -> bool
 {
-  std::scoped_lock lock(processing_mutex_);
+  const std::scoped_lock lock(processing_mutex_);
 
   if (bool expected_state{ false }; !is_completed_.compare_exchange_strong(expected_state, true)) {
     // someone already completed this request

package/deps/couchbase-cxx-client/core/meta/version.cxx

@@ -72,16 +72,22 @@ sdk_build_info() -> std::map<std::string, std::string>
   info["cxx"] = COUCHBASE_CXX_CLIENT_CXX_COMPILER;
   info["cmake_version"] = CMAKE_VERSION;
   info["cmake_build_type"] = CMAKE_BUILD_TYPE;
-  info["compile_definitions"] = COUCHBASE_CXX_CLIENT_COMPILE_DEFINITIONS;
-  info["compile_features"] = COUCHBASE_CXX_CLIENT_COMPILE_FEATURES;
-  info["compile_flags"] = COUCHBASE_CXX_CLIENT_COMPILE_FLAGS;
-  info["compile_options"] = COUCHBASE_CXX_CLIENT_COMPILE_OPTIONS;
-  info["link_depends"] = COUCHBASE_CXX_CLIENT_LINK_DEPENDS;
-  info["link_flags"] = COUCHBASE_CXX_CLIENT_LINK_FLAGS;
-  info["link_libraries"] = COUCHBASE_CXX_CLIENT_LINK_LIBRARIES;
-  info["link_options"] = COUCHBASE_CXX_CLIENT_LINK_OPTIONS;
+  info["static_target"] =
+#if defined(COUCHBASE_CXX_CLIENT_STATIC_TARGET)
+    "true"
+#else
+    "false"
+#endif
+    ;
   info["static_stdlib"] =
-#if defined(COUCHBASE_CXX_CLIENT_STATIC_STDLIB)
+#if defined(COUCHBASE_CXX_CLIENT_STATIC_TARGET) && defined(COUCHBASE_CXX_CLIENT_STATIC_STDLIB)
+    "true"
+#else
+    "false"
+#endif
+    ;
+  info["columnar"] =
+#if defined(COUCHBASE_CXX_CLIENT_COLUMNAR)
     "true"
 #else
     "false"
@@ -243,15 +249,17 @@ parse_git_describe_output(const std::string& git_describe_output) -> std::string
   return "";
 }
 
-const std::string&
-build_revision_short()
+auto
+build_revision_short() -> const std::string&
 {
   static const std::string revision{ COUCHBASE_CXX_CLIENT_GIT_REVISION_SHORT };
   return revision;
 }
 
-static std::string
-revision_with_prefix(std::string_view prefix)
+namespace
+{
+auto
+revision_with_prefix(std::string_view prefix) -> std::string
 {
   const auto& revision = build_revision_short();
   if (revision.empty() || revision == "unknown") {
@@ -259,6 +267,7 @@ revision_with_prefix(std::string_view prefix)
   }
   return fmt::format("{}{}", prefix, revision);
 }
+} // namespace
 
 auto
 build_date() -> const std::string&

package/deps/couchbase-cxx-client/core/metrics/logging_meter.cxx

@@ -23,9 +23,9 @@
 #include "core/utils/json.hxx"
 #include "noop_meter.hxx"
 
-#include <hdr/hdr_histogram.h>
-
 #include <gsl/assert>
+#include <hdr/hdr_histogram.h>
+#include <tao/json/value.hpp>
 
 #include <memory>
 #include <utility>
@@ -205,7 +205,7 @@ logging_meter::get_value_recorder(const std::string& name,
                                   const std::map<std::string, std::string>& tags)
   -> std::shared_ptr<couchbase::metrics::value_recorder>
 {
-  static std::shared_ptr<noop_value_recorder> noop_recorder{
+  static const std::shared_ptr<noop_value_recorder> noop_recorder{
     std::make_shared<noop_value_recorder>()
   };
 
@@ -214,18 +214,18 @@ logging_meter::get_value_recorder(const std::string& name,
   }
 
   static const std::string service_tag = "db.couchbase.service";
-  auto service = tags.find(service_tag);
+  const auto service = tags.find(service_tag);
   if (service == tags.end()) {
     return noop_recorder;
   }
 
   static const std::string operation_tag = "db.operation";
-  auto operation = tags.find(operation_tag);
+  const auto operation = tags.find(operation_tag);
   if (operation == tags.end()) {
     return noop_recorder;
   }
 
-  std::scoped_lock lock(recorders_mutex_);
+  const std::scoped_lock lock(recorders_mutex_);
   auto& service_recorders = recorders_[service->second];
 
   auto recorder = service_recorders.find(operation->second);

package/deps/couchbase-cxx-client/core/mozilla_ca_bundle.hxx

@@ -17,8 +17,9 @@
 
 #pragma once
 
-#include <array>
 #include <gsl/span>
+
+#include <array>
 #include <string_view>
 
 namespace couchbase::core::default_ca

package/deps/couchbase-cxx-client/core/operations/document_analytics.cxx

@@ -24,6 +24,7 @@
 #include <couchbase/error_codes.hxx>
 
 #include <gsl/assert>
+#include <tao/json/value.hpp>
 
 namespace couchbase::core::operations
 {
@@ -45,6 +46,7 @@ analytics_request::encode_to(analytics_request::encoded_request_type& encoded,
     }
   } else {
     std::vector<tao::json::value> parameters;
+    parameters.reserve(positional_parameters.size());
     for (const auto& value : positional_parameters) {
       parameters.emplace_back(utils::json::parse(value));
     }
@@ -122,7 +124,7 @@ analytics_request::make_response(error_context::analytics&& ctx,
                      response.ctx.client_context_id);
     }
     if (auto& status_prop = payload.at("status"); status_prop.is_string()) {
-      const auto status = status_prop.get_string();
+      const auto& status = status_prop.get_string();
       if (status == "running") {
         response.meta.status = analytics_response::analytics_status::running;
       } else if (status == "success") {

package/deps/couchbase-cxx-client/core/operations/document_get_projected.cxx

@@ -23,10 +23,14 @@
 #include <couchbase/error_codes.hxx>
 #include <couchbase/lookup_in_specs.hxx>
 
+#include <tao/json/value.hpp>
+
 namespace couchbase::core::operations
 {
 
-static auto
+namespace
+{
+auto
 subdoc_lookup(tao::json::value& root, const std::string& path) -> std::optional<tao::json::value>
 {
   std::string::size_type offset = 0;
@@ -36,7 +40,7 @@ subdoc_lookup(tao::json::value& root, const std::string& path) -> std::optional<
     std::string::size_type idx = path.find_first_of(".[]", offset);
 
     if (idx == std::string::npos) {
-      std::string key = path.substr(offset);
+      const std::string key = path.substr(offset);
       if (auto* val = cur->find(key); val != nullptr) {
         return *val;
       }
@@ -44,7 +48,7 @@ subdoc_lookup(tao::json::value& root, const std::string& path) -> std::optional<
     }
 
     if (path[idx] == '.' || path[idx] == '[') {
-      std::string key = path.substr(offset, idx - offset);
+      const std::string key = path.substr(offset, idx - offset);
       auto* val = cur->find(key);
       if (val == nullptr) {
         break;
@@ -54,10 +58,9 @@ subdoc_lookup(tao::json::value& root, const std::string& path) -> std::optional<
       if (!cur->is_array()) {
         break;
       }
-      std::string key = path.substr(offset, idx - offset);
-      if (int array_index = std::stoi(key); array_index == -1) {
-        cur = &cur->get_array().back();
-      } else if (static_cast<std::size_t>(array_index) < cur->get_array().size()) {
+      const std::string key = path.substr(offset, idx - offset);
+      if (const int array_index = std::stoi(key);
+          array_index == -1 || static_cast<std::size_t>(array_index) < cur->get_array().size()) {
         cur = &cur->get_array().back();
       } else {
         break;
@@ -73,7 +76,7 @@ subdoc_lookup(tao::json::value& root, const std::string& path) -> std::optional<
   return {};
 }
 
-static void
+void
 subdoc_apply_projection(tao::json::value& root,
                         const std::string& path,
                         tao::json::value& value,
@@ -91,7 +94,7 @@ subdoc_apply_projection(tao::json::value& root,
     }
 
     if (path[idx] == '.') {
-      std::string key = path.substr(offset, idx - offset);
+      const std::string key = path.substr(offset, idx - offset);
       tao::json::value* child = cur->find(key);
       if (child == nullptr) {
         cur->operator[](key) = tao::json::empty_object;
@@ -99,7 +102,7 @@ subdoc_apply_projection(tao::json::value& root,
       }
       cur = child;
     } else if (path[idx] == '[') {
-      std::string key = path.substr(offset, idx - offset);
+      const std::string key = path.substr(offset, idx - offset);
       tao::json::value* child = cur->find(key);
       if (child == nullptr) {
         cur->operator[](key) = tao::json::empty_array;
@@ -118,10 +121,10 @@ subdoc_apply_projection(tao::json::value& root,
         Expects(false);
       }
       if (preserve_array_indexes) {
-        int array_index = std::stoi(path.substr(offset, idx - offset));
+        const int array_index = std::stoi(path.substr(offset, idx - offset));
         if (array_index >= 0) {
           if (static_cast<std::size_t>(array_index) >= cur->get_array().size()) {
-            cur->get_array().resize(static_cast<std::size_t>(array_index + 1), tao::json::null);
+            cur->get_array().resize(static_cast<std::size_t>(array_index) + 1, tao::json::null);
           }
           cur->at(static_cast<std::size_t>(array_index)) = child;
           cur = &cur->at(static_cast<std::size_t>(array_index));
@@ -139,6 +142,7 @@ subdoc_apply_projection(tao::json::value& root,
     offset = idx + 1;
   }
 }
+} // namespace
 
 auto
 get_projected_request::encode_to(get_projected_request::encoded_request_type& encoded,

package/deps/couchbase-cxx-client/core/operations/document_lookup_in.cxx

@@ -16,11 +16,15 @@
  */
 
 #include "document_lookup_in.hxx"
+
 #include "core/impl/subdoc/path_flags.hxx"
 #include "core/protocol/hello_feature.hxx"
+#include "core/utils/json.hxx"
 
 #include <couchbase/error_codes.hxx>
 
+#include <tao/json/value.hpp>
+
 namespace couchbase::core::operations
 {
 auto

package/deps/couchbase-cxx-client/core/operations/document_lookup_in.hxx

@@ -27,6 +27,7 @@
 #include "core/public_fwd.hxx"
 #include "core/timeout_defaults.hxx"
 
+#include <couchbase/codec/encoded_value.hxx>
 #include <couchbase/lookup_in_result.hxx>
 
 namespace couchbase::core::operations

package/deps/couchbase-cxx-client/core/operations/document_lookup_in_all_replicas.hxx

@@ -25,8 +25,8 @@
 #include "core/operations/operation_traits.hxx"
 #include "core/utils/movable_function.hxx"
 
-#include "couchbase/codec/encoded_value.hxx"
-#include "couchbase/error_codes.hxx"
+#include <couchbase/codec/encoded_value.hxx>
+#include <couchbase/error_codes.hxx>
 
 #include <functional>
 #include <memory>

package/deps/couchbase-cxx-client/core/operations/document_lookup_in_any_replica.hxx

@@ -24,9 +24,10 @@
 #include "core/operations/document_lookup_in.hxx"
 #include "core/operations/operation_traits.hxx"
 #include "core/utils/movable_function.hxx"
-#include "couchbase/codec/encoded_value.hxx"
-#include "couchbase/error_codes.hxx"
-#include "couchbase/read_preference.hxx"
+
+#include <couchbase/codec/encoded_value.hxx>
+#include <couchbase/error_codes.hxx>
+#include <couchbase/read_preference.hxx>
 
 #include <functional>
 #include <memory>
@@ -114,17 +115,6 @@ struct lookup_in_any_replica_request {
                 make_key_value_error_context(ec, id), ec, {}, {}, false) });
             }
 
-            if (ec) {
-              std::optional<std::string> first_error_path{};
-              std::optional<std::size_t> first_error_index{};
-              return h(
-                response_type{ make_subdocument_error_context(make_key_value_error_context(ec, id),
-                                                              ec,
-                                                              first_error_path,
-                                                              first_error_index,
-                                                              false) });
-            }
-
             using handler_type = utils::movable_function<void(response_type)>;
 
             struct replica_context {

package/deps/couchbase-cxx-client/core/operations/document_query.cxx

@@ -26,6 +26,8 @@
 #include <couchbase/error_codes.hxx>
 
 #include <gsl/assert>
+#include <tao/json/value.hpp>
+
 #include <regex>
 
 namespace couchbase::core::operations
@@ -73,6 +75,7 @@ query_request::encode_to(query_request::encoded_request_type& encoded,
     }
   } else {
     std::vector<tao::json::value> parameters;
+    parameters.reserve(positional_parameters.size());
     for (const auto& value : positional_parameters) {
       parameters.emplace_back(utils::json::parse(value));
     }
@@ -306,7 +309,9 @@ query_request::make_response(error_context::query&& ctx,
 
     if (response.meta.status == "success") {
       if (response.prepared) {
-        ctx_->cache.put(statement, response.prepared.value());
+        if (ctx_.has_value()) {
+          ctx_->cache.put(statement, response.prepared.value());
+        }
       } else if (extract_encoded_plan_) {
         extract_encoded_plan_ = false;
         if (response.rows.size() == 1) {
@@ -320,7 +325,9 @@ query_request::make_response(error_context::query&& ctx,
           auto* plan = row.find("encoded_plan");
           auto* name = row.find("name");
           if (plan != nullptr && name != nullptr) {
-            ctx_->cache.put(statement, name->get_string(), plan->get_string());
+            if (ctx_) {
+              ctx_->cache.put(statement, name->get_string(), plan->get_string());
+            }
             throw couchbase::core::priv::retry_http_request{};
           }
           response.ctx.ec = errc::query::prepared_statement_failure;
@@ -352,7 +359,9 @@ query_request::make_response(error_context::query&& ctx,
           case 4040: /* IKey: "plan.build_prepared.no_such_name" */
           case 4050: /* IKey: "plan.build_prepared.unrecognized_prepared" */
           case 4070: /* IKey: "plan.build_prepared.decoding" */
-            ctx_->cache.erase(statement);
+            if (ctx_.has_value()) {
+              ctx_->cache.erase(statement);
+            }
             throw couchbase::core::priv::retry_http_request{};
           case 4060: /* IKey: "plan.build_prepared.no_such_name" */
           case 4080: /* IKey: "plan.build_prepared.name_encoded_plan_mismatch" */

package/deps/couchbase-cxx-client/core/operations/document_view.cxx

@@ -23,6 +23,8 @@
 
 #include <couchbase/error_codes.hxx>
 
+#include <tao/json/value.hpp>
+
 namespace couchbase::core::operations
 {
 auto

package/deps/couchbase-cxx-client/core/operations/http_noop.hxx

@@ -35,7 +35,7 @@ struct http_noop_request {
   using encoded_response_type = io::http_response;
   using error_context_type = error_context::http;
 
-  service_type type;
+  service_type type{};
 
   std::optional<std::string> client_context_id{};
   std::optional<std::chrono::milliseconds> timeout{};

package/deps/couchbase-cxx-client/core/operations/management/analytics_dataset_create.cxx

@@ -22,17 +22,18 @@
 #include "error_utils.hxx"
 
 #include <fmt/core.h>
+#include <tao/json/value.hpp>
 
 namespace couchbase::core::operations::management
 {
-std::error_code
+auto
 analytics_dataset_create_request::encode_to(encoded_request_type& encoded,
-                                            http_context& /* context */) const
+                                            http_context& /* context */) const -> std::error_code
 {
   std::string where_clause = condition ? fmt::format("WHERE {}", *condition) : "";
   std::string if_not_exists_clause = ignore_if_exists ? "IF NOT EXISTS" : "";
 
-  tao::json::value body{
+  const tao::json::value body{
     { "statement",
       fmt::format("CREATE DATASET {} {}.`{}` ON `{}` {}",
                   if_not_exists_clause,
@@ -48,9 +49,10 @@ analytics_dataset_create_request::encode_to(encoded_request_type& encoded,
   return {};
 }
 
-analytics_dataset_create_response
+auto
 analytics_dataset_create_request::make_response(error_context::http&& ctx,
                                                 const encoded_response_type& encoded) const
+  -> analytics_dataset_create_response
 {
   analytics_dataset_create_response response{ std::move(ctx) };
   if (!response.ctx.ec) {
@@ -68,7 +70,7 @@ analytics_dataset_create_request::make_response(error_context::http&& ctx,
 
       if (const auto* errors = payload.find("errors"); errors != nullptr && errors->is_array()) {
         for (const auto& error : errors->get_array()) {
-          analytics_problem err{
+          const analytics_problem err{
             error.at("code").as<std::uint32_t>(),
             error.at("msg").get_string(),
           };
@@ -79,6 +81,8 @@ analytics_dataset_create_request::make_response(error_context::http&& ctx,
             case 24006: /* Link [string] does not exist */
               link_not_found = true;
               break;
+            default:
+              break;
           }
           response.errors.emplace_back(err);
         }

package/deps/couchbase-cxx-client/core/operations/management/analytics_dataset_drop.cxx

@@ -22,16 +22,17 @@
 #include "error_utils.hxx"
 
 #include <fmt/core.h>
+#include <tao/json/value.hpp>
 
 namespace couchbase::core::operations::management
 {
-std::error_code
+auto
 analytics_dataset_drop_request::encode_to(encoded_request_type& encoded,
-                                          http_context& /* context */) const
+                                          http_context& /* context */) const -> std::error_code
 {
   std::string if_exists_clause = ignore_if_does_not_exist ? "IF EXISTS" : "";
 
-  tao::json::value body{
+  const tao::json::value body{
     { "statement",
       fmt::format("DROP DATASET {}.`{}` {}",
                   utils::analytics::uncompound_name(dataverse_name),
@@ -45,9 +46,10 @@ analytics_dataset_drop_request::encode_to(encoded_request_type& encoded,
   return {};
 }
 
-analytics_dataset_drop_response
+auto
 analytics_dataset_drop_request::make_response(error_context::http&& ctx,
                                               const encoded_response_type& encoded) const
+  -> analytics_dataset_drop_response
 {
   analytics_dataset_drop_response response{ std::move(ctx) };
   if (!response.ctx.ec) {
@@ -65,7 +67,7 @@ analytics_dataset_drop_request::make_response(error_context::http&& ctx,
 
       if (auto* errors = payload.find("errors"); errors != nullptr && errors->is_array()) {
         for (const auto& error : errors->get_array()) {
-          analytics_problem err{
+          const analytics_problem err{
             error.at("code").as<std::uint32_t>(),
             error.at("msg").get_string(),
           };
@@ -73,6 +75,8 @@ analytics_dataset_drop_request::make_response(error_context::http&& ctx,
             case 24025: /* Cannot find dataset with name [string] in dataverse [string] */
               dataset_does_not_exist = true;
               break;
+            default:
+              break;
           }
           response.errors.emplace_back(err);
         }