couchbase 3.5.1 → 3.5.2

data/ext/couchbase/core/impl/subdoc/lookup_in_specs.cxx

@@ -24,19 +24,19 @@ namespace couchbase
 auto
 lookup_in_specs::specs() const -> const std::vector<core::impl::subdoc::command>&
 {
-    static std::vector<core::impl::subdoc::command> empty{};
-    if (specs_ == nullptr) {
-        return empty;
-    }
-    return specs_->specs();
+  static std::vector<core::impl::subdoc::command> empty{};
+  if (specs_ == nullptr) {
+    return empty;
+  }
+  return specs_->specs();
 }
 
 auto
 lookup_in_specs::bundle() -> core::impl::subdoc::command_bundle&
 {
-    if (specs_ == nullptr) {
-        specs_ = std::make_shared<core::impl::subdoc::command_bundle>();
-    }
-    return *specs_;
+  if (specs_ == nullptr) {
+    specs_ = std::make_shared<core::impl::subdoc::command_bundle>();
+  }
+  return *specs_;
 }
 } // namespace couchbase

data/ext/couchbase/core/impl/subdoc/mutate_in_macro.cxx

@@ -26,52 +26,61 @@ namespace couchbase::subdoc
 auto
 to_mutate_in_macro(std::string_view input) -> std::optional<couchbase::subdoc::mutate_in_macro>
 {
-    if (input == "\"${Mutation.CAS}\"") {
-        return couchbase::subdoc::mutate_in_macro::cas;
-    }
-    if (input == "\"${Mutation.seqno}\"") {
-        return couchbase::subdoc::mutate_in_macro::sequence_number;
-    }
-    if (input == "\"${Mutation.value_crc32c}\"") {
-        return couchbase::subdoc::mutate_in_macro::value_crc32c;
-    }
-    return {};
+  if (input == "\"${Mutation.CAS}\"") {
+    return couchbase::subdoc::mutate_in_macro::cas;
+  }
+  if (input == "\"${Mutation.seqno}\"") {
+    return couchbase::subdoc::mutate_in_macro::sequence_number;
+  }
+  if (input == "\"${Mutation.value_crc32c}\"") {
+    return couchbase::subdoc::mutate_in_macro::value_crc32c;
+  }
+  return {};
 }
 
 auto
 to_binary(couchbase::subdoc::mutate_in_macro value) -> std::vector<std::byte>
 {
-    // echo -n '"${Mutation.CAS}"' | ruby -e 'puts ARGF.read.chars.map{|c| format("std::byte{0x%02x}", c.ord)}.join(", ")'
-    static std::vector cas_bytes{
-        std::byte{ 0x22 }, std::byte{ 0x24 }, std::byte{ 0x7b }, std::byte{ 0x4d }, std::byte{ 0x75 }, std::byte{ 0x74 },
-        std::byte{ 0x61 }, std::byte{ 0x74 }, std::byte{ 0x69 }, std::byte{ 0x6f }, std::byte{ 0x6e }, std::byte{ 0x2e },
-        std::byte{ 0x43 }, std::byte{ 0x41 }, std::byte{ 0x53 }, std::byte{ 0x7d }, std::byte{ 0x22 },
-    };
+  // echo -n '"${Mutation.CAS}"' | ruby -e 'puts ARGF.read.chars.map{|c| format("std::byte{0x%02x}",
+  // c.ord)}.join(", ")'
+  static std::vector cas_bytes{
+    std::byte{ 0x22 }, std::byte{ 0x24 }, std::byte{ 0x7b }, std::byte{ 0x4d }, std::byte{ 0x75 },
+    std::byte{ 0x74 }, std::byte{ 0x61 }, std::byte{ 0x74 }, std::byte{ 0x69 }, std::byte{ 0x6f },
+    std::byte{ 0x6e }, std::byte{ 0x2e }, std::byte{ 0x43 }, std::byte{ 0x41 }, std::byte{ 0x53 },
+    std::byte{ 0x7d }, std::byte{ 0x22 },
+  };
 
-    // echo -n '"${Mutation.seqno}"' | ruby -e 'puts ARGF.read.chars.map{|c| format("std::byte{0x%02x}", c.ord)}.join(", ")'
-    static std::vector seqno_bytes{
-        std::byte{ 0x22 }, std::byte{ 0x24 }, std::byte{ 0x7b }, std::byte{ 0x4d }, std::byte{ 0x75 }, std::byte{ 0x74 }, std::byte{ 0x61 },
-        std::byte{ 0x74 }, std::byte{ 0x69 }, std::byte{ 0x6f }, std::byte{ 0x6e }, std::byte{ 0x2e }, std::byte{ 0x73 }, std::byte{ 0x65 },
-        std::byte{ 0x71 }, std::byte{ 0x6e }, std::byte{ 0x6f }, std::byte{ 0x7d }, std::byte{ 0x22 },
-    };
+  // echo -n '"${Mutation.seqno}"' | ruby -e 'puts ARGF.read.chars.map{|c|
+  // format("std::byte{0x%02x}", c.ord)}.join(",
+  // ")'
+  static std::vector seqno_bytes{
+    std::byte{ 0x22 }, std::byte{ 0x24 }, std::byte{ 0x7b }, std::byte{ 0x4d }, std::byte{ 0x75 },
+    std::byte{ 0x74 }, std::byte{ 0x61 }, std::byte{ 0x74 }, std::byte{ 0x69 }, std::byte{ 0x6f },
+    std::byte{ 0x6e }, std::byte{ 0x2e }, std::byte{ 0x73 }, std::byte{ 0x65 }, std::byte{ 0x71 },
+    std::byte{ 0x6e }, std::byte{ 0x6f }, std::byte{ 0x7d }, std::byte{ 0x22 },
+  };
 
-    // echo -n '"${Mutation.value_crc32c}"' | ruby -e 'puts ARGF.read.chars.map{|c| format("std::byte{0x%02x}", c.ord)}.join(", ")'
-    static std::vector crc32_bytes{
-        std::byte{ 0x22 }, std::byte{ 0x24 }, std::byte{ 0x7b }, std::byte{ 0x4d }, std::byte{ 0x75 }, std::byte{ 0x74 }, std::byte{ 0x61 },
-        std::byte{ 0x74 }, std::byte{ 0x69 }, std::byte{ 0x6f }, std::byte{ 0x6e }, std::byte{ 0x2e }, std::byte{ 0x76 }, std::byte{ 0x61 },
-        std::byte{ 0x6c }, std::byte{ 0x75 }, std::byte{ 0x65 }, std::byte{ 0x5f }, std::byte{ 0x63 }, std::byte{ 0x72 }, std::byte{ 0x63 },
-        std::byte{ 0x33 }, std::byte{ 0x32 }, std::byte{ 0x63 }, std::byte{ 0x7d }, std::byte{ 0x22 },
-    };
+  // echo -n '"${Mutation.value_crc32c}"' | ruby -e 'puts ARGF.read.chars.map{|c|
+  // format("std::byte{0x%02x}", c.ord)}.join(", ")'
+  static std::vector crc32_bytes{
+    std::byte{ 0x22 }, std::byte{ 0x24 }, std::byte{ 0x7b }, std::byte{ 0x4d }, std::byte{ 0x75 },
+    std::byte{ 0x74 }, std::byte{ 0x61 }, std::byte{ 0x74 }, std::byte{ 0x69 }, std::byte{ 0x6f },
+    std::byte{ 0x6e }, std::byte{ 0x2e }, std::byte{ 0x76 }, std::byte{ 0x61 }, std::byte{ 0x6c },
+    std::byte{ 0x75 }, std::byte{ 0x65 }, std::byte{ 0x5f }, std::byte{ 0x63 }, std::byte{ 0x72 },
+    std::byte{ 0x63 }, std::byte{ 0x33 }, std::byte{ 0x32 }, std::byte{ 0x63 }, std::byte{ 0x7d },
+    std::byte{ 0x22 },
+  };
 
-    switch (value) {
-        case couchbase::subdoc::mutate_in_macro::cas:
-            return cas_bytes;
-        case couchbase::subdoc::mutate_in_macro::sequence_number:
-            return seqno_bytes;
-        case couchbase::subdoc::mutate_in_macro::value_crc32c:
-            return crc32_bytes;
-    }
-    throw std::system_error(errc::common::invalid_argument,
-                            "Unexpected mutate_in macro: " + std::to_string(static_cast<std::uint32_t>(value)));
+  switch (value) {
+    case couchbase::subdoc::mutate_in_macro::cas:
+      return cas_bytes;
+    case couchbase::subdoc::mutate_in_macro::sequence_number:
+      return seqno_bytes;
+    case couchbase::subdoc::mutate_in_macro::value_crc32c:
+      return crc32_bytes;
+  }
+  throw std::system_error(errc::common::invalid_argument,
+                          "Unexpected mutate_in macro: " +
+                            std::to_string(static_cast<std::uint32_t>(value)));
 }
 } // namespace couchbase::subdoc

data/ext/couchbase/core/impl/subdoc/mutate_in_specs.cxx

@@ -24,19 +24,19 @@ namespace couchbase
 auto
 mutate_in_specs::specs() const -> const std::vector<core::impl::subdoc::command>&
 {
-    static std::vector<core::impl::subdoc::command> empty{};
-    if (specs_ == nullptr) {
-        return empty;
-    }
-    return specs_->specs();
+  static std::vector<core::impl::subdoc::command> empty{};
+  if (specs_ == nullptr) {
+    return empty;
+  }
+  return specs_->specs();
 }
 
 auto
 mutate_in_specs::bundle() -> core::impl::subdoc::command_bundle&
 {
-    if (specs_ == nullptr) {
-        specs_ = std::make_shared<core::impl::subdoc::command_bundle>();
-    }
-    return *specs_;
+  if (specs_ == nullptr) {
+    specs_ = std::make_shared<core::impl::subdoc::command_bundle>();
+  }
+  return *specs_;
 }
 } // namespace couchbase

data/ext/couchbase/core/impl/subdoc/opcode.hxx

@@ -27,21 +27,21 @@ namespace couchbase::core::impl::subdoc
  * @internal
  */
 enum class opcode : std::uint8_t {
-    get_doc = 0x00,
-    set_doc = 0x01,
-    remove_doc = 0x04,
-    get = 0xc5,
-    exists = 0xc6,
-    dict_add = 0xc7,
-    dict_upsert = 0xc8,
-    remove = 0xc9,
-    replace = 0xca,
-    array_push_last = 0xcb,
-    array_push_first = 0xcc,
-    array_insert = 0xcd,
-    array_add_unique = 0xce,
-    counter = 0xcf,
-    get_count = 0xd2,
-    replace_body_with_xattr = 0xd3,
+  get_doc = 0x00,
+  set_doc = 0x01,
+  remove_doc = 0x04,
+  get = 0xc5,
+  exists = 0xc6,
+  dict_add = 0xc7,
+  dict_upsert = 0xc8,
+  remove = 0xc9,
+  replace = 0xca,
+  array_push_last = 0xcb,
+  array_push_first = 0xcc,
+  array_insert = 0xcd,
+  array_add_unique = 0xce,
+  counter = 0xcf,
+  get_count = 0xd2,
+  replace_body_with_xattr = 0xd3,
 };
 } // namespace couchbase::core::impl::subdoc

data/ext/couchbase/core/impl/subdoc/path_flags.hxx

@@ -42,36 +42,59 @@ constexpr std::byte path_flag_xattr{ 0b0000'0100U };
  */
 constexpr std::byte path_flag_expand_macros{ 0b0001'0000U };
 
+/**
+ * The value is binary, and not JSON or text.
+ */
+constexpr std::byte path_flag_binary_value{ 0b0010'0000U };
+
 constexpr std::byte
-build_mutate_in_path_flags(bool xattr, bool create_path, bool expand_macro)
+build_mutate_in_path_flags(bool xattr, bool create_path, bool expand_macro, bool binary)
 {
-    std::byte flags{ 0 };
-    if (xattr) {
-        flags |= path_flag_xattr;
+  std::byte flags{ 0 };
+  if (xattr) {
+    flags |= path_flag_xattr;
+    if (binary) {
+      flags |= path_flag_binary_value;
     }
-    if (create_path) {
-        flags |= path_flag_create_parents;
-    }
-    if (expand_macro) {
-        flags |= path_flag_expand_macros;
-    }
-    return flags;
+  }
+  if (create_path) {
+    flags |= path_flag_create_parents;
+  }
+  if (expand_macro) {
+    flags |= path_flag_expand_macros;
+  }
+  return flags;
 }
 
 constexpr std::byte
-build_lookup_in_path_flags(bool xattr)
+build_lookup_in_path_flags(bool xattr, bool binary)
 {
-    std::byte flags{ 0U };
-    if (xattr) {
-        flags |= path_flag_xattr;
+  std::byte flags{ 0U };
+  if (xattr) {
+    flags |= path_flag_xattr;
+    if (binary) {
+      flags |= path_flag_binary_value;
     }
-    return flags;
+  }
+  return flags;
 }
 
 constexpr bool
 has_xattr_path_flag(std::byte flags)
 {
-    return (flags & path_flag_xattr) == path_flag_xattr;
+  return (flags & path_flag_xattr) == path_flag_xattr;
+}
+
+constexpr bool
+has_binary_value_path_flag(std::byte flags)
+{
+  return (flags & path_flag_binary_value) == path_flag_binary_value;
+}
+
+constexpr void
+reset_binary_value_path_flag(std::byte& flags)
+{
+  flags &= ~path_flag_binary_value;
 }
 
 } // namespace couchbase::core::impl::subdoc

data/ext/couchbase/core/impl/subdoc/remove.cxx

@@ -26,11 +26,11 @@ namespace couchbase
 void
 subdoc::remove::encode(core::impl::subdoc::command_bundle& bundle) const
 {
-    bundle.emplace_back({
-      path_.empty() ? core::impl::subdoc::opcode::remove_doc : core::impl::subdoc::opcode::remove,
-      path_,
-      {},
-      core::impl::subdoc::build_mutate_in_path_flags(xattr_, false, false),
-    });
+  bundle.emplace_back({
+    path_.empty() ? core::impl::subdoc::opcode::remove_doc : core::impl::subdoc::opcode::remove,
+    path_,
+    {},
+    core::impl::subdoc::build_mutate_in_path_flags(xattr_, false, false, false),
+  });
 }
 } // namespace couchbase

data/ext/couchbase/core/impl/subdoc/replace.cxx

@@ -26,11 +26,11 @@ namespace couchbase
 void
 subdoc::replace::encode(core::impl::subdoc::command_bundle& bundle) const
 {
-    bundle.emplace_back({
-      path_.empty() ? core::impl::subdoc::opcode::set_doc : core::impl::subdoc::opcode::replace,
-      path_,
-      value_,
-      core::impl::subdoc::build_mutate_in_path_flags(xattr_, false, expand_macro_),
-    });
+  bundle.emplace_back({
+    path_.empty() ? core::impl::subdoc::opcode::set_doc : core::impl::subdoc::opcode::replace,
+    path_,
+    value_,
+    core::impl::subdoc::build_mutate_in_path_flags(xattr_, false, expand_macro_, binary_),
+  });
 }
 } // namespace couchbase

data/ext/couchbase/core/impl/subdoc/upsert.cxx

@@ -26,11 +26,11 @@ namespace couchbase
 void
 subdoc::upsert::encode(core::impl::subdoc::command_bundle& bundle) const
 {
-    bundle.emplace_back({
-      core::impl::subdoc::opcode::dict_upsert,
-      path_,
-      value_,
-      core::impl::subdoc::build_mutate_in_path_flags(xattr_, create_path_, expand_macro_),
-    });
+  bundle.emplace_back({
+    core::impl::subdoc::opcode::dict_upsert,
+    path_,
+    value_,
+    core::impl::subdoc::build_mutate_in_path_flags(xattr_, create_path_, expand_macro_, binary_),
+  });
 }
 } // namespace couchbase

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

@@ -24,13 +24,13 @@ namespace couchbase
 auto
 term_facet::encode() const -> encoded_search_facet
 {
-    encoded_search_facet built;
-    built.facet = {
-        { "field", field_ },
-    };
-    if (size_) {
-        built.facet["size"] = size_.value();
-    }
-    return built;
+  encoded_search_facet built;
+  built.facet = {
+    { "field", field_ },
+  };
+  if (size_) {
+    built.facet["size"] = size_.value();
+  }
+  return built;
 }
 } // namespace couchbase

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

@@ -29,36 +29,36 @@ term_facet_result::term_facet_result(internal_term_facet_result internal)
 auto
 term_facet_result::name() const -> const std::string&
 {
-    return internal_->name();
+  return internal_->name();
 }
 
 auto
 term_facet_result::field() const -> const std::string&
 {
-    return internal_->field();
+  return internal_->field();
 }
 
 auto
 term_facet_result::total() const -> std::uint64_t
 {
-    return internal_->total();
+  return internal_->total();
 }
 
 auto
 term_facet_result::missing() const -> std::uint64_t
 {
-    return internal_->missing();
+  return internal_->missing();
 }
 
 auto
 term_facet_result::other() const -> std::uint64_t
 {
-    return internal_->other();
+  return internal_->other();
 }
 
 auto
 term_facet_result::terms() const -> const std::vector<search_term_range>&
 {
-    return internal_->terms();
+  return internal_->terms();
 }
 } // namespace couchbase

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

@@ -24,33 +24,33 @@ namespace couchbase
 auto
 term_query::encode() const -> encoded_search_query
 {
-    encoded_search_query built;
-    built.query = tao::json::empty_object;
-    if (boost_) {
-        built.query["boost"] = boost_.value();
-    }
+  encoded_search_query built;
+  built.query = tao::json::empty_object;
+  if (boost_) {
+    built.query["boost"] = boost_.value();
+  }
 
-    built.query["term"] = term_;
-    if (field_) {
-        built.query["field"] = field_.value();
-    }
-    if (fuzziness_) {
-        built.query["fuzziness"] = fuzziness_.value();
-    }
-    if (prefix_length_) {
-        built.query["prefix_length"] = prefix_length_.value();
-    }
-    if (operator_) {
-        switch (operator_.value()) {
-            case match_operator::logical_or:
-                built.query["operator"] = "or";
-                break;
-            case match_operator::logical_and:
-                built.query["operator"] = "and";
-                break;
-        }
+  built.query["term"] = term_;
+  if (field_) {
+    built.query["field"] = field_.value();
+  }
+  if (fuzziness_) {
+    built.query["fuzziness"] = fuzziness_.value();
+  }
+  if (prefix_length_) {
+    built.query["prefix_length"] = prefix_length_.value();
+  }
+  if (operator_) {
+    switch (operator_.value()) {
+      case match_operator::logical_or:
+        built.query["operator"] = "or";
+        break;
+      case match_operator::logical_and:
+        built.query["operator"] = "and";
+        break;
     }
+  }
 
-    return built;
+  return built;
 }
 } // namespace couchbase

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

@@ -26,32 +26,32 @@ namespace couchbase
 auto
 term_range_query::encode() const -> encoded_search_query
 {
-    if ((!min_ || min_->empty()) && (!max_ || max_->empty())) {
-        return { errc::common::invalid_argument };
-    }
+  if ((!min_ || min_->empty()) && (!max_ || max_->empty())) {
+    return { errc::common::invalid_argument };
+  }
 
-    encoded_search_query built;
-    built.query = tao::json::empty_object;
-    if (boost_) {
-        built.query["boost"] = boost_.value();
-    }
-    if (field_) {
-        built.query["field"] = field_.value();
-    }
+  encoded_search_query built;
+  built.query = tao::json::empty_object;
+  if (boost_) {
+    built.query["boost"] = boost_.value();
+  }
+  if (field_) {
+    built.query["field"] = field_.value();
+  }
 
-    if (min_) {
-        built.query["min"] = min_.value();
-        if (inclusive_min_.has_value()) {
-            built.query["inclusive_min"] = inclusive_min_.value();
-        }
+  if (min_) {
+    built.query["min"] = min_.value();
+    if (inclusive_min_.has_value()) {
+      built.query["inclusive_min"] = inclusive_min_.value();
     }
-    if (max_) {
-        built.query["max"] = max_.value();
-        if (inclusive_max_.has_value()) {
-            built.query["inclusive_max"] = inclusive_max_.value();
-        }
+  }
+  if (max_) {
+    built.query["max"] = max_.value();
+    if (inclusive_max_.has_value()) {
+      built.query["inclusive_max"] = inclusive_max_.value();
     }
+  }
 
-    return built;
+  return built;
 }
 } // namespace couchbase

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

@@ -22,33 +22,34 @@ namespace couchbase::core::impl
 {
 
 struct transaction_error_category : std::error_category {
-    [[nodiscard]] const char* name() const noexcept override
-    {
-        return "couchbase.transaction";
-    }
+  [[nodiscard]] auto name() const noexcept -> const char* override
+  {
+    return "couchbase.transaction";
+  }
 
-    [[nodiscard]] std::string message(int ev) const noexcept override
-    {
-        switch (static_cast<errc::transaction>(ev)) {
-            case errc::transaction::failed:
-                return "transaction failed (1200)";
-            case errc::transaction::expired:
-                return "transaction expired (1201)";
-            case errc::transaction::failed_post_commit:
-                return "transaction failed post-commit (1202)";
-            case errc::transaction::ambiguous:
-                return "transaction commit ambiguous (1203)";
-        }
-        return "FIXME: unknown error code (recompile with newer library): couchbase.transaction." + std::to_string(ev);
+  [[nodiscard]] auto message(int ev) const noexcept -> std::string override
+  {
+    switch (static_cast<errc::transaction>(ev)) {
+      case errc::transaction::failed:
+        return "transaction failed (1200)";
+      case errc::transaction::expired:
+        return "transaction expired (1201)";
+      case errc::transaction::failed_post_commit:
+        return "transaction failed post-commit (1202)";
+      case errc::transaction::ambiguous:
+        return "transaction commit ambiguous (1203)";
     }
+    return "FIXME: unknown error code (recompile with newer library): couchbase.transaction." +
+           std::to_string(ev);
+  }
 };
 
 const inline static transaction_error_category transaction_category_instance;
 
-const std::error_category&
-transaction_category() noexcept
+auto
+transaction_category() noexcept -> const std::error_category&
 {
-    return transaction_category_instance;
+  return transaction_category_instance;
 }
 
 } // namespace couchbase::core::impl