couchbase 3.1.1 → 3.2.0

data/ext/couchbase/operations/analytics_dataset_create.hxx

@@ -20,6 +20,7 @@
 #include <tao/json.hpp>
 
 #include <error_context/http.hxx>
+#include <utils/name_codec.hxx>
 #include <version.hxx>
 
 namespace couchbase::operations
@@ -54,15 +55,19 @@ struct analytics_dataset_create_request {
 
     bool ignore_if_exists{ false };
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& /* context */)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& /* context */) const
     {
         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{
             { "statement",
-              fmt::format(
-                "CREATE DATASET {} `{}`.`{}` ON `{}` {}", if_not_exists_clause, dataverse_name, dataset_name, bucket_name, where_clause) },
+              fmt::format("CREATE DATASET {} {}.`{}` ON `{}` {}",
+                          if_not_exists_clause,
+                          utils::analytics::uncompound_name(dataverse_name),
+                          dataset_name,
+                          bucket_name,
+                          where_clause) },
         };
         encoded.headers["content-type"] = "application/json";
         encoded.method = "POST";
@@ -74,16 +79,16 @@ struct analytics_dataset_create_request {
 
 analytics_dataset_create_response
 make_response(error_context::http&& ctx,
-              analytics_dataset_create_request& /* request */,
+              const analytics_dataset_create_request& /* request */,
               analytics_dataset_create_request::encoded_response_type&& encoded)
 {
-    analytics_dataset_create_response response{ ctx };
+    analytics_dataset_create_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         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.status = payload.at("status").get_string();
@@ -92,8 +97,7 @@ make_response(error_context::http&& ctx,
             bool dataset_exists = false;
             bool link_not_found = false;
 
-            auto* errors = payload.find("errors");
-            if (errors != nullptr && errors->is_array()) {
+            if (auto* errors = payload.find("errors"); errors != nullptr && errors->is_array()) {
                 for (const auto& error : errors->get_array()) {
                     analytics_dataset_create_response::problem err{
                         error.at("code").as<std::uint32_t>(),
@@ -111,11 +115,11 @@ make_response(error_context::http&& ctx,
                 }
             }
             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 (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 {
-                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/analytics_dataset_drop.hxx

@@ -19,7 +19,7 @@
 
 #include <tao/json.hpp>
 
-#include <version.hxx>
+#include <utils/name_codec.hxx>
 
 namespace couchbase::operations
 {
@@ -50,12 +50,13 @@ struct analytics_dataset_drop_request {
 
     bool ignore_if_does_not_exist{ false };
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& /* context */)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& /* context */) const
     {
         std::string if_exists_clause = ignore_if_does_not_exist ? "IF EXISTS" : "";
 
         tao::json::value body{
-            { "statement", fmt::format("DROP DATASET `{}`.`{}` {}", dataverse_name, dataset_name, if_exists_clause) },
+            { "statement",
+              fmt::format("DROP DATASET {}.`{}` {}", utils::analytics::uncompound_name(dataverse_name), dataset_name, if_exists_clause) },
         };
         encoded.headers["content-type"] = "application/json";
         encoded.method = "POST";
@@ -67,16 +68,16 @@ struct analytics_dataset_drop_request {
 
 analytics_dataset_drop_response
 make_response(error_context::http&& ctx,
-              analytics_dataset_drop_request& /* request */,
+              const analytics_dataset_drop_request& /* request */,
               analytics_dataset_drop_request::encoded_response_type&& encoded)
 {
-    analytics_dataset_drop_response response{ ctx };
+    analytics_dataset_drop_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         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.status = payload.at("status").get_string();
@@ -84,8 +85,7 @@ make_response(error_context::http&& ctx,
         if (response.status != "success") {
             bool dataset_does_not_exist = false;
 
-            auto* errors = payload.find("errors");
-            if (errors != nullptr && errors->is_array()) {
+            if (auto* errors = payload.find("errors"); errors != nullptr && errors->is_array()) {
                 for (const auto& error : errors->get_array()) {
                     analytics_dataset_drop_response::problem err{
                         error.at("code").as<std::uint32_t>(),
@@ -100,9 +100,9 @@ make_response(error_context::http&& ctx,
                 }
             }
             if (dataset_does_not_exist) {
-                response.ctx.ec = std::make_error_code(error::analytics_errc::dataset_not_found);
+                response.ctx.ec = error::analytics_errc::dataset_not_found;
             } 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/analytics_dataset_get_all.hxx

@@ -53,7 +53,7 @@ struct analytics_dataset_get_all_request {
     std::string client_context_id{ uuid::to_string(uuid::random()) };
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& /* context */)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& /* context */) const
     {
         tao::json::value body{
             { "statement", "SELECT d.* FROM Metadata.`Dataset` d WHERE d.DataverseName <> \"Metadata\"" },
@@ -68,17 +68,17 @@ struct analytics_dataset_get_all_request {
 
 analytics_dataset_get_all_response
 make_response(error_context::http&& ctx,
-              analytics_dataset_get_all_request& /* request */,
+              const analytics_dataset_get_all_request& /* request */,
               analytics_dataset_get_all_request::encoded_response_type&& encoded)
 {
-    analytics_dataset_get_all_response response{ ctx };
+    analytics_dataset_get_all_response response{ std::move(ctx) };
 
     if (!response.ctx.ec) {
         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.status = payload.at("status").get_string();
@@ -105,7 +105,7 @@ make_response(error_context::http&& ctx,
                     response.errors.emplace_back(err);
                 }
             }
-            response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
+            response.ctx.ec = error::common_errc::internal_server_failure;
         }
     }
     return response;

data/ext/couchbase/operations/analytics_dataverse_create.hxx

@@ -20,7 +20,7 @@
 #include <tao/json.hpp>
 
 #include <error_context/http.hxx>
-#include <version.hxx>
+#include <utils/name_codec.hxx>
 
 namespace couchbase::operations
 {
@@ -50,12 +50,12 @@ struct analytics_dataverse_create_request {
 
     bool ignore_if_exists{ false };
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& /* context */)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& /* context */) const
     {
         std::string if_not_exists_clause = ignore_if_exists ? "IF NOT EXISTS" : "";
 
         tao::json::value body{
-            { "statement", fmt::format("CREATE DATAVERSE `{}` {}", dataverse_name, if_not_exists_clause) },
+            { "statement", fmt::format("CREATE DATAVERSE {} {}", utils::analytics::uncompound_name(dataverse_name), if_not_exists_clause) },
         };
         encoded.headers["content-type"] = "application/json";
         encoded.method = "POST";
@@ -67,16 +67,16 @@ struct analytics_dataverse_create_request {
 
 analytics_dataverse_create_response
 make_response(error_context::http&& ctx,
-              analytics_dataverse_create_request& /* request */,
+              const analytics_dataverse_create_request& /* request */,
               analytics_dataverse_create_request::encoded_response_type&& encoded)
 {
-    analytics_dataverse_create_response response{ ctx };
+    analytics_dataverse_create_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         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.status = payload.at("status").get_string();
@@ -84,8 +84,7 @@ make_response(error_context::http&& ctx,
         if (response.status != "success") {
             bool dataverse_exists = false;
 
-            auto* errors = payload.find("errors");
-            if (errors != nullptr && errors->is_array()) {
+            if (auto* errors = payload.find("errors"); errors != nullptr && errors->is_array()) {
                 for (const auto& error : errors->get_array()) {
                     analytics_dataverse_create_response::problem err{
                         error.at("code").as<std::uint32_t>(),
@@ -100,9 +99,9 @@ make_response(error_context::http&& ctx,
                 }
             }
             if (dataverse_exists) {
-                response.ctx.ec = std::make_error_code(error::analytics_errc::dataverse_exists);
+                response.ctx.ec = error::analytics_errc::dataverse_exists;
             } 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/analytics_dataverse_drop.hxx

@@ -19,7 +19,7 @@
 
 #include <tao/json.hpp>
 
-#include <version.hxx>
+#include <utils/name_codec.hxx>
 
 namespace couchbase::operations
 {
@@ -49,12 +49,12 @@ struct analytics_dataverse_drop_request {
 
     bool ignore_if_does_not_exist{ false };
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& /* context */)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& /* context */) const
     {
         std::string if_exists_clause = ignore_if_does_not_exist ? "IF EXISTS" : "";
 
         tao::json::value body{
-            { "statement", fmt::format("DROP DATAVERSE `{}` {}", dataverse_name, if_exists_clause) },
+            { "statement", fmt::format("DROP DATAVERSE {} {}", utils::analytics::uncompound_name(dataverse_name), if_exists_clause) },
         };
         encoded.headers["content-type"] = "application/json";
         encoded.method = "POST";
@@ -66,16 +66,16 @@ struct analytics_dataverse_drop_request {
 
 analytics_dataverse_drop_response
 make_response(error_context::http&& ctx,
-              analytics_dataverse_drop_request& /* request */,
+              const analytics_dataverse_drop_request& /* request */,
               analytics_dataverse_drop_request::encoded_response_type&& encoded)
 {
-    analytics_dataverse_drop_response response{ ctx };
+    analytics_dataverse_drop_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         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.status = payload.at("status").get_string();
@@ -83,8 +83,7 @@ make_response(error_context::http&& ctx,
         if (response.status != "success") {
             bool dataverse_does_not_exist = false;
 
-            auto* errors = payload.find("errors");
-            if (errors != nullptr && errors->is_array()) {
+            if (auto* errors = payload.find("errors"); errors != nullptr && errors->is_array()) {
                 for (const auto& error : errors->get_array()) {
                     analytics_dataverse_drop_response::problem err{
                         error.at("code").as<std::uint32_t>(),
@@ -99,9 +98,9 @@ make_response(error_context::http&& ctx,
                 }
             }
             if (dataverse_does_not_exist) {
-                response.ctx.ec = std::make_error_code(error::analytics_errc::dataverse_not_found);
+                response.ctx.ec = error::analytics_errc::dataverse_not_found;
             } 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/analytics_get_pending_mutations.hxx

@@ -47,7 +47,7 @@ struct analytics_get_pending_mutations_request {
     std::string client_context_id{ uuid::to_string(uuid::random()) };
     std::chrono::milliseconds timeout{ timeout_defaults::management_timeout };
 
-    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& /* context */)
+    [[nodiscard]] std::error_code encode_to(encoded_request_type& encoded, http_context& /* context */) const
     {
         encoded.method = "GET";
         encoded.path = "/analytics/node/agg/stats/remaining";
@@ -57,25 +57,23 @@ struct analytics_get_pending_mutations_request {
 
 analytics_get_pending_mutations_response
 make_response(error_context::http&& ctx,
-              analytics_get_pending_mutations_request& /* request */,
+              const analytics_get_pending_mutations_request& /* request */,
               analytics_get_pending_mutations_request::encoded_response_type&& encoded)
 {
-    analytics_get_pending_mutations_response response{ ctx };
+    analytics_get_pending_mutations_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         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;
         }
         if (encoded.status_code == 200) {
             if (payload.is_object()) {
-                for (const auto& entry : payload.get_object()) {
-                    std::string dataverse = entry.first + ".";
-                    for (const auto& stats : entry.second.get_object()) {
-                        std::string dataset = dataverse + stats.first;
-                        response.stats.emplace(dataset, stats.second.get_unsigned());
+                for (const auto& [dataverse, entry] : payload.get_object()) {
+                    for (const auto& [dataset, counter] : entry.get_object()) {
+                        response.stats.try_emplace(fmt::format("{}.{}", dataverse, dataset), counter.get_unsigned());
                     }
                 }
             }
@@ -91,7 +89,7 @@ make_response(error_context::http&& ctx,
                 response.errors.emplace_back(err);
             }
         }
-        response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
+        response.ctx.ec = error::common_errc::internal_server_failure;
     }
     return response;
 }

data/ext/couchbase/operations/analytics_index_create.hxx

@@ -52,13 +52,13 @@ struct analytics_index_create_request {
 
     bool ignore_if_exists{ false };
 
-    [[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
     {
         std::string if_not_exists_clause = ignore_if_exists ? "IF NOT EXISTS" : "";
         std::vector<std::string> field_specs;
         field_specs.reserve(fields.size());
-        for (const auto& entry : fields) {
-            field_specs.emplace_back(entry.first + ": " + entry.second);
+        for (const auto& [field_name, field_type] : fields) {
+            field_specs.emplace_back(fmt::format("{}:{}", field_name, field_type));
         }
 
         tao::json::value body{
@@ -79,15 +79,17 @@ struct analytics_index_create_request {
 };
 
 analytics_index_create_response
-make_response(error_context::http&& ctx, analytics_index_create_request&, analytics_index_create_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx,
+              const analytics_index_create_request& /* request */,
+              analytics_index_create_request::encoded_response_type&& encoded)
 {
-    analytics_index_create_response response{ ctx };
+    analytics_index_create_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         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.status = payload.at("status").get_string();
@@ -97,8 +99,7 @@ make_response(error_context::http&& ctx, analytics_index_create_request&, analyt
             bool dataset_not_found = false;
             bool link_not_found = false;
 
-            auto* errors = payload.find("errors");
-            if (errors != nullptr && errors->is_array()) {
+            if (auto* errors = payload.find("errors"); errors != nullptr && errors->is_array()) {
                 for (const auto& error : errors->get_array()) {
                     analytics_index_create_response::problem err{
                         error.at("code").as<std::uint32_t>(),
@@ -119,13 +120,13 @@ make_response(error_context::http&& ctx, analytics_index_create_request&, analyt
                 }
             }
             if (index_exists) {
-                response.ctx.ec = std::make_error_code(error::common_errc::index_exists);
+                response.ctx.ec = error::common_errc::index_exists;
             } 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 (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 {
-                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/analytics_index_drop.hxx

@@ -19,7 +19,7 @@
 
 #include <tao/json.hpp>
 
-#include <version.hxx>
+#include <utils/name_codec.hxx>
 
 namespace couchbase::operations
 {
@@ -51,12 +51,17 @@ struct analytics_index_drop_request {
 
     bool ignore_if_does_not_exist{ false };
 
-    [[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
     {
         std::string if_exists_clause = ignore_if_does_not_exist ? "IF EXISTS" : "";
 
         tao::json::value body{
-            { "statement", fmt::format("DROP INDEX `{}`.`{}`.`{}` {}", dataverse_name, dataset_name, index_name, if_exists_clause) },
+            { "statement",
+              fmt::format("DROP INDEX {}.`{}`.`{}` {}",
+                          utils::analytics::uncompound_name(dataverse_name),
+                          dataset_name,
+                          index_name,
+                          if_exists_clause) },
         };
         encoded.headers["content-type"] = "application/json";
         encoded.method = "POST";
@@ -67,15 +72,17 @@ struct analytics_index_drop_request {
 };
 
 analytics_index_drop_response
-make_response(error_context::http&& ctx, analytics_index_drop_request&, analytics_index_drop_request::encoded_response_type&& encoded)
+make_response(error_context::http&& ctx,
+              const analytics_index_drop_request& /* request */,
+              analytics_index_drop_request::encoded_response_type&& encoded)
 {
-    analytics_index_drop_response response{ ctx };
+    analytics_index_drop_response response{ std::move(ctx) };
     if (!response.ctx.ec) {
         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.status = payload.at("status").get_string();
@@ -84,8 +91,7 @@ make_response(error_context::http&& ctx, analytics_index_drop_request&, analytic
             bool index_does_not_exist = false;
             bool dataset_not_found = false;
 
-            auto* errors = payload.find("errors");
-            if (errors != nullptr && errors->is_array()) {
+            if (auto* errors = payload.find("errors"); errors != nullptr && errors->is_array()) {
                 for (const auto& error : errors->get_array()) {
                     analytics_index_drop_response::problem err{
                         error.at("code").as<std::uint32_t>(),
@@ -103,11 +109,11 @@ make_response(error_context::http&& ctx, analytics_index_drop_request&, analytic
                 }
             }
             if (index_does_not_exist) {
-                response.ctx.ec = std::make_error_code(error::common_errc::index_not_found);
+                response.ctx.ec = error::common_errc::index_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 {
-                response.ctx.ec = std::make_error_code(error::common_errc::internal_server_failure);
+                response.ctx.ec = error::common_errc::internal_server_failure;
             }
         }
     }