couchbase 3.5.1 → 3.5.2

data/ext/couchbase/core/impl/scope.cxx

@@ -17,6 +17,7 @@
 
 #include "analytics.hxx"
 #include "core/cluster.hxx"
+#include "error.hxx"
 #include "internal_search_error_context.hxx"
 #include "internal_search_meta_data.hxx"
 #include "internal_search_result.hxx"
@@ -38,71 +39,69 @@ namespace couchbase
 {
 class scope_impl
 {
-  public:
-    scope_impl(core::cluster core, std::string_view bucket_name, std::string_view name)
-      : core_{ std::move(core) }
-      , bucket_name_{ bucket_name }
-      , name_{ name }
-      , query_context_{ fmt::format("default:`{}`.`{}`", bucket_name_, name_) }
-    {
-    }
-
-    [[nodiscard]] auto bucket_name() const -> const std::string&
-    {
-        return bucket_name_;
-    }
-
-    [[nodiscard]] auto name() const -> const std::string&
-    {
-        return name_;
-    }
-
-    [[nodiscard]] auto core() const -> const core::cluster&
-    {
-        return core_;
-    }
-
-    void query(std::string statement, query_options::built options, query_handler&& handler) const
-    {
-        return core_.execute(
-          core::impl::build_query_request(std::move(statement), query_context_, std::move(options)),
-          [handler = std::move(handler)](auto resp) { return handler(core::impl::build_context(resp), core::impl::build_result(resp)); });
-    }
-
-    void analytics_query(std::string statement, analytics_options::built options, analytics_handler&& handler) const
-    {
-        return core_.execute(core::impl::build_analytics_request(std::move(statement), std::move(options), bucket_name_, name_),
-                             [handler = std::move(handler)](auto resp) mutable {
-                                 return handler(core::impl::build_context(resp), core::impl::build_result(resp));
-                             });
-    }
-
-    void search_query(std::string index_name,
-                      const class search_query& query,
-                      search_options::built options,
-                      search_handler&& handler) const
-    {
-        return core_.execute(core::impl::build_search_request(std::move(index_name), query, options, bucket_name_, name_),
-                             [handler = std::move(handler)](auto&& resp) mutable {
-                                 return handler(search_error_context{ internal_search_error_context{ resp } },
-                                                search_result{ internal_search_result{ resp } });
-                             });
-    }
-
-    void search(std::string index_name, couchbase::search_request request, search_options::built options, search_handler&& handler) const
-    {
-        return core_.execute(core::impl::build_search_request(std::move(index_name), std::move(request), options, bucket_name_, name_),
-                             [handler = std::move(handler)](auto&& resp) mutable {
-                                 return handler(search_error_context{ internal_search_error_context{ resp } },
-                                                search_result{ internal_search_result{ resp } });
-                             });
-    }
-
-  private:
-    core::cluster core_;
-    std::string bucket_name_;
-    std::string name_;
-    std::string query_context_;
+public:
+  scope_impl(core::cluster core, std::string_view bucket_name, std::string_view name)
+    : core_{ std::move(core) }
+    , bucket_name_{ bucket_name }
+    , name_{ name }
+    , query_context_{ fmt::format("default:`{}`.`{}`", bucket_name_, name_) }
+  {
+  }
+
+  [[nodiscard]] auto bucket_name() const -> const std::string&
+  {
+    return bucket_name_;
+  }
+
+  [[nodiscard]] auto name() const -> const std::string&
+  {
+    return name_;
+  }
+
+  [[nodiscard]] auto core() const -> const core::cluster&
+  {
+    return core_;
+  }
+
+  void query(std::string statement, query_options::built options, query_handler&& handler) const
+  {
+    return core_.execute(
+      core::impl::build_query_request(std::move(statement), query_context_, std::move(options)),
+      [handler = std::move(handler)](auto resp) {
+        return handler(core::impl::make_error(resp.ctx), core::impl::build_result(resp));
+      });
+  }
+
+  void analytics_query(std::string statement,
+                       analytics_options::built options,
+                       analytics_handler&& handler) const
+  {
+    return core_.execute(core::impl::build_analytics_request(
+                           std::move(statement), std::move(options), bucket_name_, name_),
+                         [handler = std::move(handler)](auto resp) mutable {
+                           return handler(core::impl::make_error(resp.ctx),
+                                          core::impl::build_result(resp));
+                         });
+  }
+
+  void search(std::string index_name,
+              couchbase::search_request request,
+              search_options::built options,
+              search_handler&& handler) const
+  {
+    return core_.execute(core::impl::build_search_request(
+                           std::move(index_name), std::move(request), options, bucket_name_, name_),
+                         [handler = std::move(handler)](auto&& resp) mutable {
+                           return handler(core::impl::make_error(resp.ctx),
+                                          search_result{ internal_search_result{ resp } });
+                         });
+  }
+
+private:
+  core::cluster core_;
+  std::string bucket_name_;
+  std::string name_;
+  std::string query_context_;
 };
 
 scope::scope(core::cluster core, std::string_view bucket_name, std::string_view name)
@@ -113,75 +112,85 @@ scope::scope(core::cluster core, std::string_view bucket_name, std::string_view
 auto
 scope::bucket_name() const -> const std::string&
 {
-    return impl_->bucket_name();
+  return impl_->bucket_name();
 }
 
 auto
 scope::name() const -> const std::string&
 {
-    return impl_->name();
+  return impl_->name();
 }
 
 auto
 scope::collection(std::string_view collection_name) const -> couchbase::collection
 {
-    return { impl_->core(), impl_->bucket_name(), impl_->name(), collection_name };
+  return { impl_->core(), impl_->bucket_name(), impl_->name(), collection_name };
 }
 
 void
 scope::query(std::string statement, const query_options& options, query_handler&& handler) const
 {
-    return impl_->query(std::move(statement), options.build(), std::move(handler));
+  return impl_->query(std::move(statement), options.build(), std::move(handler));
 }
 
 auto
-scope::query(std::string statement, const query_options& options) const -> std::future<std::pair<query_error_context, query_result>>
+scope::query(std::string statement,
+             const query_options& options) const -> std::future<std::pair<error, query_result>>
 {
-    auto barrier = std::make_shared<std::promise<std::pair<query_error_context, query_result>>>();
-    auto future = barrier->get_future();
-    query(std::move(statement), options, [barrier](auto ctx, auto result) { barrier->set_value({ std::move(ctx), std::move(result) }); });
-    return future;
+  auto barrier = std::make_shared<std::promise<std::pair<error, query_result>>>();
+  auto future = barrier->get_future();
+  query(std::move(statement), options, [barrier](auto err, auto result) {
+    barrier->set_value({ std::move(err), std::move(result) });
+  });
+  return future;
 }
 
 void
-scope::analytics_query(std::string statement, const analytics_options& options, analytics_handler&& handler) const
+scope::analytics_query(std::string statement,
+                       const analytics_options& options,
+                       analytics_handler&& handler) const
 {
-    return impl_->analytics_query(std::move(statement), options.build(), std::move(handler));
+  return impl_->analytics_query(std::move(statement), options.build(), std::move(handler));
 }
 
 auto
 scope::analytics_query(std::string statement, const analytics_options& options) const
-  -> std::future<std::pair<analytics_error_context, analytics_result>>
+  -> std::future<std::pair<error, analytics_result>>
 {
-    auto barrier = std::make_shared<std::promise<std::pair<analytics_error_context, analytics_result>>>();
-    auto future = barrier->get_future();
-    analytics_query(std::move(statement), options, [barrier](auto ctx, auto result) {
-        barrier->set_value({ std::move(ctx), std::move(result) });
-    });
-    return future;
+  auto barrier = std::make_shared<std::promise<std::pair<error, analytics_result>>>();
+  auto future = barrier->get_future();
+  analytics_query(std::move(statement), options, [barrier](auto err, auto result) {
+    barrier->set_value({ std::move(err), std::move(result) });
+  });
+  return future;
 }
 
 void
-scope::search(std::string index_name, search_request request, const search_options& options, search_handler&& handler) const
+scope::search(std::string index_name,
+              search_request request,
+              const search_options& options,
+              search_handler&& handler) const
 {
-    return impl_->search(std::move(index_name), std::move(request), options.build(), std::move(handler));
+  return impl_->search(
+    std::move(index_name), std::move(request), options.build(), std::move(handler));
 }
 
 auto
-scope::search(std::string index_name, search_request request, const search_options& options) const
-  -> std::future<std::pair<search_error_context, search_result>>
+scope::search(std::string index_name,
+              search_request request,
+              const search_options& options) const -> std::future<std::pair<error, search_result>>
 {
-    auto barrier = std::make_shared<std::promise<std::pair<search_error_context, search_result>>>();
-    auto future = barrier->get_future();
-    search(std::move(index_name), std::move(request), options, [barrier](auto ctx, auto result) {
-        barrier->set_value({ std::move(ctx), std::move(result) });
-    });
-    return future;
+  auto barrier = std::make_shared<std::promise<std::pair<error, search_result>>>();
+  auto future = barrier->get_future();
+  search(std::move(index_name), std::move(request), options, [barrier](auto err, auto result) {
+    barrier->set_value({ std::move(err), std::move(result) });
+  });
+  return future;
 }
 
 auto
 scope::search_indexes() const -> scope_search_index_manager
 {
-    return scope_search_index_manager{ impl_->core(), impl_->bucket_name(), impl_->name() };
+  return scope_search_index_manager{ impl_->core(), impl_->bucket_name(), impl_->name() };
 }
 } // namespace couchbase

data/ext/couchbase/core/impl/search.cxx

@@ -35,181 +35,190 @@ namespace couchbase::core::impl
 {
 namespace
 {
-std::optional<core::search_highlight_style>
+auto
 map_highlight_style(const std::optional<couchbase::highlight_style>& style)
+  -> std::optional<core::search_highlight_style>
 {
-    if (style) {
-        switch (style.value()) {
-            case highlight_style::html:
-                return core::search_highlight_style::html;
-            case highlight_style::ansi:
-                return core::search_highlight_style::ansi;
-        }
+  if (style) {
+    switch (style.value()) {
+      case highlight_style::html:
+        return core::search_highlight_style::html;
+      case highlight_style::ansi:
+        return core::search_highlight_style::ansi;
     }
-    return {};
+  }
+  return {};
 }
 
-static std::optional<core::search_scan_consistency>
+static auto
 map_scan_consistency(const std::optional<couchbase::search_scan_consistency>& scan_consistency)
+  -> std::optional<core::search_scan_consistency>
 {
-    if (scan_consistency == couchbase::search_scan_consistency::not_bounded) {
-        return core::search_scan_consistency::not_bounded;
-    }
-    return {};
+  if (scan_consistency == couchbase::search_scan_consistency::not_bounded) {
+    return core::search_scan_consistency::not_bounded;
+  }
+  return {};
 }
 
-static std::vector<std::string>
-map_sort(const std::vector<std::shared_ptr<search_sort>>& sort, const std::vector<std::string>& sort_string)
+static auto
+map_sort(const std::vector<std::shared_ptr<search_sort>>& sort,
+         const std::vector<std::string>& sort_string) -> std::vector<std::string>
 {
-    std::vector<std::string> sort_specs{};
-    sort_specs.reserve(sort.size() + sort_string.size());
-
-    for (const auto& s : sort) {
-        auto encoded = s->encode();
-        if (encoded.ec) {
-            throw std::system_error(encoded.ec, "unable to encode search sort object");
-        }
-        sort_specs.emplace_back(core::utils::json::generate(encoded.sort));
-    }
+  std::vector<std::string> sort_specs{};
+  sort_specs.reserve(sort.size() + sort_string.size());
 
-    for (const auto& s : sort_string) {
-        sort_specs.emplace_back(core::utils::json::generate(s));
+  for (const auto& s : sort) {
+    auto encoded = s->encode();
+    if (encoded.ec) {
+      throw std::system_error(encoded.ec, "unable to encode search sort object");
     }
+    sort_specs.emplace_back(core::utils::json::generate(encoded.sort));
+  }
+
+  for (const auto& s : sort_string) {
+    sort_specs.emplace_back(core::utils::json::generate(s));
+  }
 
-    return sort_specs;
+  return sort_specs;
 }
 
-static std::map<std::string, std::string>
+static auto
 map_facets(const std::map<std::string, std::shared_ptr<search_facet>, std::less<>>& facets)
+  -> std::map<std::string, std::string>
 {
-    std::map<std::string, std::string> core_facets{};
-
-    for (const auto& [name, f] : facets) {
-        auto encoded = f->encode();
-        if (encoded.ec) {
-            throw std::system_error(encoded.ec, "unable to encode search facet object in request");
-        }
-        core_facets[name] = core::utils::json::generate(encoded.facet);
+  std::map<std::string, std::string> core_facets{};
+
+  for (const auto& [name, f] : facets) {
+    auto encoded = f->encode();
+    if (encoded.ec) {
+      throw std::system_error(encoded.ec, "unable to encode search facet object in request");
     }
+    core_facets[name] = core::utils::json::generate(encoded.facet);
+  }
 
-    return core_facets;
+  return core_facets;
 }
 
-static std::map<std::string, couchbase::core::json_string>
+static auto
 map_raw(std::map<std::string, codec::binary, std::less<>>& raw)
+  -> std::map<std::string, couchbase::core::json_string>
 {
-    std::map<std::string, couchbase::core::json_string> core_raw{};
-    for (const auto& [name, value] : raw) {
-        core_raw[name] = value;
-    }
-    return core_raw;
+  std::map<std::string, couchbase::core::json_string> core_raw{};
+  for (const auto& [name, value] : raw) {
+    core_raw[name] = value;
+  }
+  return core_raw;
 }
 
-static std::optional<core::vector_query_combination>
+static auto
 map_vector_query_combination(const std::optional<couchbase::vector_query_combination>& combination)
+  -> std::optional<core::vector_query_combination>
 {
-    if (combination) {
-        switch (combination.value()) {
-            case couchbase::vector_query_combination::combination_and:
-                return core::vector_query_combination::combination_and;
-            case couchbase::vector_query_combination::combination_or:
-                return core::vector_query_combination::combination_or;
-        }
+  if (combination) {
+    switch (combination.value()) {
+      case couchbase::vector_query_combination::combination_and:
+        return core::vector_query_combination::combination_and;
+      case couchbase::vector_query_combination::combination_or:
+        return core::vector_query_combination::combination_or;
     }
-    return {};
+  }
+  return {};
 }
 
 } // namespace
 
-core::operations::search_request
+auto
 build_search_request(std::string index_name,
                      const search_query& query,
                      search_options::built options,
                      std::optional<std::string> bucket_name,
-                     std::optional<std::string> scope_name)
+                     std::optional<std::string> scope_name) -> core::operations::search_request
 {
-    auto encoded = query.encode();
-    if (encoded.ec) {
-        throw std::system_error(encoded.ec, fmt::format("unable to encode search query for index \"{}\"", index_name));
-    }
-    core::operations::search_request request{
-        std::move(index_name),
-        core::utils::json::generate_binary(encoded.query),
-        std::move(bucket_name),
-        std::move(scope_name),
-        {},
-        {},
-        {},
-        options.limit,
-        options.skip,
-        options.explain,
-        options.disable_scoring,
-        options.include_locations,
-        map_highlight_style(options.highlight_style),
-        options.highlight_fields,
-        options.fields,
-        options.collections,
-        map_scan_consistency(options.scan_consistency),
-        options.mutation_state,
-        map_sort(options.sort, options.sort_string),
-        map_facets(options.facets),
-        map_raw(options.raw),
-        {},
-        options.client_context_id,
-        options.timeout,
-    };
-    return request;
+  auto encoded = query.encode();
+  if (encoded.ec) {
+    throw std::system_error(
+      encoded.ec, fmt::format("unable to encode search query for index \"{}\"", index_name));
+  }
+  core::operations::search_request request{
+    std::move(index_name),
+    core::utils::json::generate_binary(encoded.query),
+    std::move(bucket_name),
+    std::move(scope_name),
+    {},
+    {},
+    {},
+    options.limit,
+    options.skip,
+    options.explain,
+    options.disable_scoring,
+    options.include_locations,
+    map_highlight_style(options.highlight_style),
+    options.highlight_fields,
+    options.fields,
+    options.collections,
+    map_scan_consistency(options.scan_consistency),
+    options.mutation_state,
+    map_sort(options.sort, options.sort_string),
+    map_facets(options.facets),
+    map_raw(options.raw),
+    {},
+    options.client_context_id,
+    options.timeout,
+  };
+  return request;
 }
 
-core::operations::search_request
+auto
 build_search_request(std::string index_name,
                      couchbase::search_request request,
                      search_options::built options,
                      std::optional<std::string> bucket_name,
-                     std::optional<std::string> scope_name)
+                     std::optional<std::string> scope_name) -> core::operations::search_request
 {
-    if (!request.search_query().has_value()) {
-        request.search_query(couchbase::match_none_query{});
-    }
-
-    core::operations::search_request core_request{
-        std::move(index_name),
-        core::utils::json::generate_binary(request.search_query().value().query),
-        std::move(bucket_name),
-        std::move(scope_name),
-        false,
-        {},
-        {},
-        options.limit,
-        options.skip,
-        options.explain,
-        options.disable_scoring,
-        options.include_locations,
-        map_highlight_style(options.highlight_style),
-        options.highlight_fields,
-        options.fields,
-        options.collections,
-        map_scan_consistency(options.scan_consistency),
-        options.mutation_state,
-        map_sort(options.sort, options.sort_string),
-        map_facets(options.facets),
-        map_raw(options.raw),
-        {},
-        options.client_context_id,
-        options.timeout,
-    };
-
-    if (!request.vector_search().has_value()) {
-        return core_request;
-    }
-    core_request.vector_search = core::utils::json::generate_binary(request.vector_search().value().query);
-
-    auto vector_search_options = request.vector_options();
-    if (!vector_search_options.has_value()) {
-        return core_request;
-    }
+  if (!request.search_query().has_value()) {
+    request.search_query(couchbase::match_none_query{});
+  }
+
+  core::operations::search_request core_request{
+    std::move(index_name),
+    core::utils::json::generate_binary(request.search_query().value().query),
+    std::move(bucket_name),
+    std::move(scope_name),
+    false,
+    {},
+    {},
+    options.limit,
+    options.skip,
+    options.explain,
+    options.disable_scoring,
+    options.include_locations,
+    map_highlight_style(options.highlight_style),
+    options.highlight_fields,
+    options.fields,
+    options.collections,
+    map_scan_consistency(options.scan_consistency),
+    options.mutation_state,
+    map_sort(options.sort, options.sort_string),
+    map_facets(options.facets),
+    map_raw(options.raw),
+    {},
+    options.client_context_id,
+    options.timeout,
+  };
+
+  if (!request.vector_search().has_value()) {
+    return core_request;
+  }
+  core_request.vector_search =
+    core::utils::json::generate_binary(request.vector_search().value().query);
 
-    core_request.vector_query_combination = map_vector_query_combination(vector_search_options.value().combination);
+  auto vector_search_options = request.vector_options();
+  if (!vector_search_options.has_value()) {
     return core_request;
+  }
+
+  core_request.vector_query_combination =
+    map_vector_query_combination(vector_search_options.value().combination);
+  return core_request;
 }
 } // namespace couchbase::core::impl

data/ext/couchbase/core/impl/search.hxx

@@ -28,18 +28,18 @@
 
 namespace couchbase::core::impl
 {
-core::operations::search_request
+auto
 build_search_request(std::string index_name,
                      const search_query& query,
                      search_options::built options,
                      std::optional<std::string> bucket_name,
-                     std::optional<std::string> scope_name);
+                     std::optional<std::string> scope_name) -> core::operations::search_request;
 
-core::operations::search_request
+auto
 build_search_request(std::string index_name,
                      search_request request,
                      search_options::built options,
                      std::optional<std::string> bucket_name,
-                     std::optional<std::string> scope_name);
+                     std::optional<std::string> scope_name) -> core::operations::search_request;
 
 } // namespace couchbase::core::impl

data/ext/couchbase/core/impl/search_error_category.cxx

@@ -23,29 +23,30 @@ namespace couchbase::core::impl
 {
 
 struct search_error_category : std::error_category {
-    [[nodiscard]] const char* name() const noexcept override
-    {
-        return "couchbase.search";
-    }
-
-    [[nodiscard]] std::string message(int ev) const noexcept override
-    {
-        switch (static_cast<errc::search>(ev)) {
-            case errc::search::index_not_ready:
-                return "index_not_ready (401)";
-            case errc::search::consistency_mismatch:
-                return "consistency_mismatch (402)";
-        }
-        return "FIXME: unknown error code (recompile with newer library): couchbase.search." + std::to_string(ev);
+  [[nodiscard]] auto name() const noexcept -> const char* override
+  {
+    return "couchbase.search";
+  }
+
+  [[nodiscard]] auto message(int ev) const noexcept -> std::string override
+  {
+    switch (static_cast<errc::search>(ev)) {
+      case errc::search::index_not_ready:
+        return "index_not_ready (401)";
+      case errc::search::consistency_mismatch:
+        return "consistency_mismatch (402)";
     }
+    return "FIXME: unknown error code (recompile with newer library): couchbase.search." +
+           std::to_string(ev);
+  }
 };
 
 const inline static search_error_category category_instance;
 
-const std::error_category&
-search_category() noexcept
+auto
+search_category() noexcept -> const std::error_category&
 {
-    return category_instance;
+  return category_instance;
 }
 
 } // namespace couchbase::core::impl