couchbase 3.4.4 → 3.4.5

data/ext/couchbase/test/test_integration_subdoc.cxx

@@ -49,7 +49,8 @@ assert_single_lookup_error(test::utils::integration_test_guard& integration,
                            const couchbase::core::document_id& id,
                            const SubdocumentOperation& spec,
                            couchbase::key_value_status_code expected_status,
-                           std::error_code expected_ec)
+                           std::error_code expected_ec,
+                           std::optional<std::string> expected_value = std::nullopt)
 {
     couchbase::core::operations::lookup_in_request req{ id };
     req.specs = couchbase::lookup_in_specs{ spec }.specs();
@@ -60,9 +61,13 @@ assert_single_lookup_error(test::utils::integration_test_guard& integration,
     REQUIRE(resp.fields.size() == 1);
     REQUIRE_FALSE(resp.fields[0].exists);
     REQUIRE(resp.fields[0].path == req.specs[0].path_);
-    REQUIRE(resp.fields[0].value.empty());
     REQUIRE(resp.fields[0].status == expected_status);
     REQUIRE(resp.fields[0].ec == expected_ec);
+    if (expected_value.has_value()) {
+        REQUIRE(couchbase::core::utils::to_binary(expected_value.value()) == resp.fields[0].value);
+    } else {
+        REQUIRE(resp.fields[0].value.empty());
+    }
 }
 
 template<typename SubdocumentOperation>
@@ -85,6 +90,8 @@ assert_single_lookup_any_replica_success(test::utils::integration_test_guard& in
     REQUIRE_SUCCESS(resp.fields[0].ec);
     if (expected_value.has_value()) {
         REQUIRE(couchbase::core::utils::to_binary(expected_value.value()) == resp.fields[0].value);
+    } else {
+        REQUIRE(resp.fields[0].value.empty());
     }
 }
 
@@ -94,20 +101,25 @@ assert_single_lookup_any_replica_error(test::utils::integration_test_guard& inte
                                        const couchbase::core::document_id& id,
                                        const SubdocumentOperation& spec,
                                        couchbase::key_value_status_code expected_status,
-                                       std::error_code expected_ec)
+                                       std::error_code expected_ec,
+                                       std::optional<std::string> expected_value = std::nullopt)
 {
     couchbase::core::operations::lookup_in_any_replica_request req{ id };
     req.specs = couchbase::lookup_in_specs{ spec }.specs();
     auto resp = test::utils::execute(integration.cluster, req);
-    INFO(fmt::format("assert_single_lookup_all_replica_error(\"{}\", \"{}\")", id, req.specs[0].path_));
+    INFO(fmt::format("assert_single_lookup_any_replica_error(\"{}\", \"{}\")", id, req.specs[0].path_));
     REQUIRE_SUCCESS(resp.ctx.ec());
     REQUIRE_FALSE(resp.cas.empty());
     REQUIRE(resp.fields.size() == 1);
     REQUIRE_FALSE(resp.fields[0].exists);
     REQUIRE(resp.fields[0].path == req.specs[0].path_);
-    REQUIRE(resp.fields[0].value.empty());
     REQUIRE(resp.fields[0].status == expected_status);
     REQUIRE(resp.fields[0].ec == expected_ec);
+    if (expected_value.has_value()) {
+        REQUIRE(couchbase::core::utils::to_binary(expected_value.value()) == resp.fields[0].value);
+    } else {
+        REQUIRE(resp.fields[0].value.empty());
+    }
 }
 
 template<typename SubdocumentOperation>
@@ -145,7 +157,8 @@ assert_single_lookup_all_replica_error(test::utils::integration_test_guard& inte
                                        const couchbase::core::document_id& id,
                                        const SubdocumentOperation& spec,
                                        couchbase::key_value_status_code expected_status,
-                                       std::error_code expected_ec)
+                                       std::error_code expected_ec,
+                                       std::optional<std::string> expected_value = std::nullopt)
 {
     couchbase::core::operations::lookup_in_all_replicas_request req{ id };
     req.specs = couchbase::lookup_in_specs{ spec }.specs();
@@ -161,9 +174,13 @@ assert_single_lookup_all_replica_error(test::utils::integration_test_guard& inte
         REQUIRE(resp.fields.size() == 1);
         REQUIRE_FALSE(resp.fields[0].exists);
         REQUIRE(resp.fields[0].path == req.specs[0].path_);
-        REQUIRE(resp.fields[0].value.empty());
         REQUIRE(resp.fields[0].status == expected_status);
         REQUIRE(resp.fields[0].ec == expected_ec);
+        if (expected_value.has_value()) {
+            REQUIRE(couchbase::core::utils::to_binary(expected_value.value()) == resp.fields[0].value);
+        } else {
+            REQUIRE(resp.fields[0].value.empty());
+        }
     }
 }
 
@@ -214,7 +231,7 @@ TEST_CASE("integration: subdoc get & exists", "[integration]")
 
     SECTION("dict exists")
     {
-        assert_single_lookup_success(integration, id, couchbase::lookup_in_specs::exists("dictkey"));
+        assert_single_lookup_success(integration, id, couchbase::lookup_in_specs::exists("dictkey"), "true");
     }
 
     SECTION("array get")
@@ -224,7 +241,7 @@ TEST_CASE("integration: subdoc get & exists", "[integration]")
 
     SECTION("array exists")
     {
-        assert_single_lookup_success(integration, id, couchbase::lookup_in_specs::exists("array"));
+        assert_single_lookup_success(integration, id, couchbase::lookup_in_specs::exists("array"), "true");
     }
 
     SECTION("array index get")
@@ -234,7 +251,7 @@ TEST_CASE("integration: subdoc get & exists", "[integration]")
 
     SECTION("array index exists")
     {
-        assert_single_lookup_success(integration, id, couchbase::lookup_in_specs::exists("array[0]"));
+        assert_single_lookup_success(integration, id, couchbase::lookup_in_specs::exists("array[0]"), "true");
     }
 
     SECTION("non existent path get")
@@ -252,7 +269,8 @@ TEST_CASE("integration: subdoc get & exists", "[integration]")
                                    id,
                                    couchbase::lookup_in_specs::exists("non-exist"),
                                    couchbase::key_value_status_code::subdoc_path_not_found,
-                                   couchbase::errc::key_value::path_not_found);
+                                   std::error_code{},
+                                   "false");
     }
 
     SECTION("non existent doc")
@@ -738,7 +756,7 @@ TEST_CASE("integration: subdoc multi lookup", "[integration]")
         REQUIRE(resp.fields[0].value == couchbase::core::utils::to_binary(R"("dictval")"));
         REQUIRE(resp.fields[0].status == couchbase::key_value_status_code::success);
 
-        REQUIRE(resp.fields[1].value.empty());
+        REQUIRE(resp.fields[1].value == couchbase::core::utils::to_binary("true"));
         REQUIRE(resp.fields[1].status == couchbase::key_value_status_code::success);
         REQUIRE(resp.fields[1].exists);
 
@@ -1082,7 +1100,7 @@ TEST_CASE("integration: subdoc all replica reads", "[integration]")
     test::utils::integration_test_guard integration;
 
     if (!integration.has_bucket_capability("subdoc.ReplicaRead")) {
-        SKIP("cluster does not support replica_read");
+        SKIP("bucket does not support replica_read");
     }
 
     auto number_of_replicas = integration.number_of_replicas();
@@ -1114,7 +1132,7 @@ TEST_CASE("integration: subdoc all replica reads", "[integration]")
 
     SECTION("dict exists")
     {
-        assert_single_lookup_all_replica_success(integration, id, couchbase::lookup_in_specs::exists("dictkey"));
+        assert_single_lookup_all_replica_success(integration, id, couchbase::lookup_in_specs::exists("dictkey"), "true");
     }
 
     SECTION("array get")
@@ -1125,7 +1143,7 @@ TEST_CASE("integration: subdoc all replica reads", "[integration]")
 
     SECTION("array exists")
     {
-        assert_single_lookup_all_replica_success(integration, id, couchbase::lookup_in_specs::exists("array"));
+        assert_single_lookup_all_replica_success(integration, id, couchbase::lookup_in_specs::exists("array"), "true");
     }
 
     SECTION("array index get")
@@ -1135,7 +1153,7 @@ TEST_CASE("integration: subdoc all replica reads", "[integration]")
 
     SECTION("array index exists")
     {
-        assert_single_lookup_all_replica_success(integration, id, couchbase::lookup_in_specs::exists("array[0]"));
+        assert_single_lookup_all_replica_success(integration, id, couchbase::lookup_in_specs::exists("array[0]"), "true");
     }
 
     SECTION("non existent path get")
@@ -1153,7 +1171,8 @@ TEST_CASE("integration: subdoc all replica reads", "[integration]")
                                                id,
                                                couchbase::lookup_in_specs::exists("non-exist"),
                                                couchbase::key_value_status_code::subdoc_path_not_found,
-                                               couchbase::errc::key_value::path_not_found);
+                                               std::error_code{},
+                                               "false");
     }
 
     SECTION("non existent doc")
@@ -1282,6 +1301,7 @@ TEST_CASE("integration: subdoc all replica reads", "[integration]")
                 REQUIRE(!res.cas().empty());
                 REQUIRE("dictval" == res.content_as<std::string>(0));
                 REQUIRE(res.exists("array"));
+                REQUIRE(res.content_as<bool>(1));
                 REQUIRE(5 == res.content_as<int>(2));
             }
         }
@@ -1295,6 +1315,20 @@ TEST_CASE("integration: subdoc all replica reads", "[integration]")
             REQUIRE(ctx.ec() == couchbase::errc::key_value::document_not_found);
             REQUIRE(result.empty());
         }
+
+        SECTION("non existent path exists")
+        {
+            auto specs = couchbase::lookup_in_specs{
+                couchbase::lookup_in_specs::exists("non-exists"),
+            };
+            auto [ctx, result] = collection.lookup_in_all_replicas(key, specs).get();
+            REQUIRE_SUCCESS(ctx.ec());
+            for (auto& res : result) {
+                REQUIRE(!res.cas().empty());
+                REQUIRE(!res.exists(0));
+                REQUIRE(!res.content_as<bool>(0));
+            }
+        }
     }
 }
 
@@ -1303,7 +1337,7 @@ TEST_CASE("integration: subdoc any replica reads", "[integration]")
     test::utils::integration_test_guard integration;
 
     if (!integration.has_bucket_capability("subdoc.ReplicaRead")) {
-        SKIP("cluster does not support replica_read");
+        SKIP("bucket does not support replica_read");
     }
 
     auto number_of_replicas = integration.number_of_replicas();
@@ -1337,7 +1371,7 @@ TEST_CASE("integration: subdoc any replica reads", "[integration]")
 
     SECTION("dict exists")
     {
-        assert_single_lookup_any_replica_success(integration, id, couchbase::lookup_in_specs::exists("dictkey"));
+        assert_single_lookup_any_replica_success(integration, id, couchbase::lookup_in_specs::exists("dictkey"), "true");
     }
 
     SECTION("array get")
@@ -1348,7 +1382,7 @@ TEST_CASE("integration: subdoc any replica reads", "[integration]")
 
     SECTION("array exists")
     {
-        assert_single_lookup_any_replica_success(integration, id, couchbase::lookup_in_specs::exists("array"));
+        assert_single_lookup_any_replica_success(integration, id, couchbase::lookup_in_specs::exists("array"), "true");
     }
 
     SECTION("array index get")
@@ -1358,7 +1392,7 @@ TEST_CASE("integration: subdoc any replica reads", "[integration]")
 
     SECTION("array index exists")
     {
-        assert_single_lookup_any_replica_success(integration, id, couchbase::lookup_in_specs::exists("array[0]"));
+        assert_single_lookup_any_replica_success(integration, id, couchbase::lookup_in_specs::exists("array[0]"), "true");
     }
 
     SECTION("non existent path get")
@@ -1376,7 +1410,8 @@ TEST_CASE("integration: subdoc any replica reads", "[integration]")
                                                id,
                                                couchbase::lookup_in_specs::exists("non-exist"),
                                                couchbase::key_value_status_code::subdoc_path_not_found,
-                                               couchbase::errc::key_value::path_not_found);
+                                               std::error_code{},
+                                               "false");
     }
 
     SECTION("non existent doc")
@@ -1516,6 +1551,7 @@ TEST_CASE("integration: subdoc any replica reads", "[integration]")
             REQUIRE(!result.cas().empty());
             REQUIRE("dictval" == result.content_as<std::string>(0));
             REQUIRE(result.exists("array"));
+            REQUIRE(result.content_as<bool>(1));
             REQUIRE(5 == result.content_as<int>(2));
         }
 
@@ -1540,6 +1576,17 @@ TEST_CASE("integration: subdoc any replica reads", "[integration]")
             REQUIRE(ctx.ec() == couchbase::errc::common::invalid_argument);
             REQUIRE(result.cas().empty());
         }
+
+        SECTION("non existent path exists")
+        {
+            auto specs = couchbase::lookup_in_specs{
+                couchbase::lookup_in_specs::exists("non-exists"),
+            };
+            auto [ctx, result] = collection.lookup_in_any_replica(key, specs).get();
+            REQUIRE_SUCCESS(ctx.ec());
+            REQUIRE(!result.exists(0));
+            REQUIRE(!result.content_as<bool>(0));
+        }
     }
 }
 
@@ -1627,4 +1674,16 @@ TEST_CASE("integration: public API lookup in per-spec errors", "[integration]")
         }
         REQUIRE_SUCCESS(ec);
     }
+
+    SECTION("non existent path exists")
+    {
+        auto specs = couchbase::lookup_in_specs{
+            couchbase::lookup_in_specs::exists("dictkey2"),
+        };
+        auto [ctx, result] = collection.lookup_in(key, specs).get();
+
+        REQUIRE_SUCCESS(ctx.ec());
+        REQUIRE(!result.exists(0));
+        REQUIRE(!result.content_as<bool>(0));
+    }
 }

data/ext/couchbase.cxx

@@ -1013,16 +1013,14 @@ cb_map_error_code(const couchbase::key_value_error_context& ctx, const std::stri
         rb_hash_aset(enhanced_error_info, rb_id2sym(rb_intern("context")), cb_str_new(ctx.extended_error_info()->context()));
         rb_hash_aset(error_context, rb_id2sym(rb_intern("extended_error_info")), enhanced_error_info);
     }
-    if (ctx.retry_attempts() > 0) {
-        rb_hash_aset(error_context, rb_id2sym(rb_intern("retry_attempts")), INT2FIX(ctx.retry_attempts()));
-        if (!ctx.retry_reasons().empty()) {
-            VALUE retry_reasons = rb_ary_new_capa(static_cast<long>(ctx.retry_reasons().size()));
-            for (const auto& reason : ctx.retry_reasons()) {
-                auto reason_str = fmt::format("{}", reason);
-                rb_ary_push(retry_reasons, rb_id2sym(rb_intern(reason_str.c_str())));
-            }
-            rb_hash_aset(error_context, rb_id2sym(rb_intern("retry_reasons")), retry_reasons);
+    rb_hash_aset(error_context, rb_id2sym(rb_intern("retry_attempts")), INT2FIX(ctx.retry_attempts()));
+    if (!ctx.retry_reasons().empty()) {
+        VALUE retry_reasons = rb_ary_new_capa(static_cast<long>(ctx.retry_reasons().size()));
+        for (const auto& reason : ctx.retry_reasons()) {
+            auto reason_str = fmt::format("{}", reason);
+            rb_ary_push(retry_reasons, rb_id2sym(rb_intern(reason_str.c_str())));
         }
+        rb_hash_aset(error_context, rb_id2sym(rb_intern("retry_reasons")), retry_reasons);
     }
     if (ctx.last_dispatched_to()) {
         rb_hash_aset(error_context, rb_id2sym(rb_intern("last_dispatched_to")), cb_str_new(ctx.last_dispatched_to().value()));
@@ -3517,7 +3515,7 @@ cb_Backend_document_lookup_in(VALUE self, VALUE bucket, VALUE scope, VALUE colle
             if (!resp_entry.value.empty()) {
                 rb_hash_aset(entry, value_property, cb_str_new(resp_entry.value));
             }
-            if (resp_entry.ec && resp_entry.ec != couchbase::errc::key_value::path_not_found) {
+            if (resp_entry.ec) {
                 rb_hash_aset(entry,
                              error_property,
                              cb_map_error_code(resp_entry.ec,
@@ -3628,7 +3626,7 @@ cb_Backend_document_lookup_in_any_replica(VALUE self, VALUE bucket, VALUE scope,
             if (!resp_entry.value.empty()) {
                 rb_hash_aset(entry, value_property, cb_str_new(resp_entry.value));
             }
-            if (resp_entry.ec && resp_entry.ec != couchbase::errc::key_value::path_not_found) {
+            if (resp_entry.ec) {
                 rb_hash_aset(entry,
                              error_property,
                              cb_map_error_code(resp_entry.ec,
@@ -3744,7 +3742,7 @@ cb_Backend_document_lookup_in_all_replicas(VALUE self, VALUE bucket, VALUE scope
                 if (!field_entry.value.empty()) {
                     rb_hash_aset(entry, value_property, cb_str_new(field_entry.value));
                 }
-                if (field_entry.ec && field_entry.ec != couchbase::errc::key_value::path_not_found) {
+                if (field_entry.ec) {
                     rb_hash_aset(
                       entry,
                       error_property,
@@ -4370,18 +4368,20 @@ cb_Backend_document_query(VALUE self, VALUE statement, VALUE options)
 static void
 cb_generate_bucket_settings(VALUE bucket, couchbase::core::management::cluster::bucket_settings& entry, bool is_create)
 {
-    if (VALUE bucket_type = rb_hash_aref(bucket, rb_id2sym(rb_intern("bucket_type"))); TYPE(bucket_type) == T_SYMBOL) {
-        if (bucket_type == rb_id2sym(rb_intern("couchbase")) || bucket_type == rb_id2sym(rb_intern("membase"))) {
-            entry.bucket_type = couchbase::core::management::cluster::bucket_type::couchbase;
-        } else if (bucket_type == rb_id2sym(rb_intern("memcached"))) {
-            entry.bucket_type = couchbase::core::management::cluster::bucket_type::memcached;
-        } else if (bucket_type == rb_id2sym(rb_intern("ephemeral"))) {
-            entry.bucket_type = couchbase::core::management::cluster::bucket_type::ephemeral;
+    if (VALUE bucket_type = rb_hash_aref(bucket, rb_id2sym(rb_intern("bucket_type"))); !NIL_P(bucket_type)) {
+        if (TYPE(bucket_type) == T_SYMBOL) {
+            if (bucket_type == rb_id2sym(rb_intern("couchbase")) || bucket_type == rb_id2sym(rb_intern("membase"))) {
+                entry.bucket_type = couchbase::core::management::cluster::bucket_type::couchbase;
+            } else if (bucket_type == rb_id2sym(rb_intern("memcached"))) {
+                entry.bucket_type = couchbase::core::management::cluster::bucket_type::memcached;
+            } else if (bucket_type == rb_id2sym(rb_intern("ephemeral"))) {
+                entry.bucket_type = couchbase::core::management::cluster::bucket_type::ephemeral;
+            } else {
+                throw ruby_exception(rb_eArgError, rb_sprintf("unknown bucket type, given %+" PRIsVALUE, bucket_type));
+            }
         } else {
-            throw ruby_exception(rb_eArgError, rb_sprintf("unknown bucket type, given %+" PRIsVALUE, bucket_type));
+            throw ruby_exception(rb_eArgError, rb_sprintf("bucket type must be a Symbol, given %+" PRIsVALUE, bucket_type));
         }
-    } else {
-        throw ruby_exception(rb_eArgError, rb_sprintf("bucket type must be a Symbol, given %+" PRIsVALUE, bucket_type));
     }
 
     if (VALUE name = rb_hash_aref(bucket, rb_id2sym(rb_intern("name"))); TYPE(name) == T_STRING) {
@@ -4390,10 +4390,12 @@ cb_generate_bucket_settings(VALUE bucket, couchbase::core::management::cluster::
         throw ruby_exception(rb_eArgError, rb_sprintf("bucket name must be a String, given %+" PRIsVALUE, name));
     }
 
-    if (VALUE quota = rb_hash_aref(bucket, rb_id2sym(rb_intern("ram_quota_mb"))); TYPE(quota) == T_FIXNUM) {
-        entry.ram_quota_mb = FIX2ULONG(quota);
-    } else {
-        throw ruby_exception(rb_eArgError, rb_sprintf("bucket RAM quota must be an Integer, given %+" PRIsVALUE, quota));
+    if (VALUE quota = rb_hash_aref(bucket, rb_id2sym(rb_intern("ram_quota_mb"))); !NIL_P(quota)) {
+        if (TYPE(quota) == T_FIXNUM) {
+            entry.ram_quota_mb = FIX2ULONG(quota);
+        } else {
+            throw ruby_exception(rb_eArgError, rb_sprintf("bucket RAM quota must be an Integer, given %+" PRIsVALUE, quota));
+        }
     }
 
     if (VALUE expiry = rb_hash_aref(bucket, rb_id2sym(rb_intern("max_expiry"))); !NIL_P(expiry)) {
@@ -4490,6 +4492,31 @@ cb_generate_bucket_settings(VALUE bucket, couchbase::core::management::cluster::
         }
     }
 
+    if (VALUE history_retention_collection_default = rb_hash_aref(bucket, rb_id2sym(rb_intern("history_retention_collection_default")));
+        !NIL_P(history_retention_collection_default)) {
+        entry.history_retention_collection_default = RTEST(history_retention_collection_default);
+    }
+
+    if (VALUE history_retention_bytes = rb_hash_aref(bucket, rb_id2sym(rb_intern("history_retention_bytes")));
+        !NIL_P(history_retention_bytes)) {
+        if (TYPE(history_retention_bytes) == T_FIXNUM) {
+            entry.history_retention_bytes = FIX2UINT(history_retention_bytes);
+        } else {
+            throw ruby_exception(rb_eArgError,
+                                 rb_sprintf("history retention bytes must be an Integer, given %+" PRIsVALUE, history_retention_bytes));
+        }
+    }
+
+    if (VALUE history_retention_duration = rb_hash_aref(bucket, rb_id2sym(rb_intern("history_retention_duration")));
+        !NIL_P(history_retention_duration)) {
+        if (TYPE(history_retention_duration) == T_FIXNUM) {
+            entry.history_retention_duration = FIX2UINT(history_retention_duration);
+        } else {
+            throw ruby_exception(
+              rb_eArgError, rb_sprintf("history retention duration must be an Integer, given %+" PRIsVALUE, history_retention_duration));
+        }
+    }
+
     if (is_create) {
         if (VALUE conflict_resolution_type = rb_hash_aref(bucket, rb_id2sym(rb_intern("conflict_resolution_type")));
             !NIL_P(conflict_resolution_type)) {
@@ -4654,7 +4681,9 @@ cb_extract_bucket_settings(const couchbase::core::management::cluster::bucket_se
     rb_hash_aset(bucket, rb_id2sym(rb_intern("name")), cb_str_new(entry.name));
     rb_hash_aset(bucket, rb_id2sym(rb_intern("uuid")), cb_str_new(entry.uuid));
     rb_hash_aset(bucket, rb_id2sym(rb_intern("ram_quota_mb")), ULL2NUM(entry.ram_quota_mb));
-    rb_hash_aset(bucket, rb_id2sym(rb_intern("max_expiry")), ULONG2NUM(entry.max_expiry));
+    if (const auto& val = entry.max_expiry; val.has_value()) {
+        rb_hash_aset(bucket, rb_id2sym(rb_intern("max_expiry")), ULONG2NUM(val.value()));
+    }
     switch (entry.compression_mode) {
         case couchbase::core::management::cluster::bucket_compression::off:
             rb_hash_aset(bucket, rb_id2sym(rb_intern("compression_mode")), rb_id2sym(rb_intern("off")));
@@ -4669,9 +4698,15 @@ cb_extract_bucket_settings(const couchbase::core::management::cluster::bucket_se
             rb_hash_aset(bucket, rb_id2sym(rb_intern("compression_mode")), Qnil);
             break;
     }
-    rb_hash_aset(bucket, rb_id2sym(rb_intern("num_replicas")), ULONG2NUM(entry.num_replicas));
-    rb_hash_aset(bucket, rb_id2sym(rb_intern("replica_indexes")), entry.replica_indexes ? Qtrue : Qfalse);
-    rb_hash_aset(bucket, rb_id2sym(rb_intern("flush_enabled")), entry.flush_enabled ? Qtrue : Qfalse);
+    if (const auto& val = entry.num_replicas; val.has_value()) {
+        rb_hash_aset(bucket, rb_id2sym(rb_intern("num_replicas")), ULONG2NUM(val.value()));
+    }
+    if (const auto& val = entry.replica_indexes; val.has_value()) {
+        rb_hash_aset(bucket, rb_id2sym(rb_intern("replica_indexes")), val.value() ? Qtrue : Qfalse);
+    }
+    if (const auto& val = entry.flush_enabled; val.has_value()) {
+        rb_hash_aset(bucket, rb_id2sym(rb_intern("flush_enabled")), val.value() ? Qtrue : Qfalse);
+    }
     switch (entry.eviction_policy) {
         case couchbase::core::management::cluster::bucket_eviction_policy::full:
             rb_hash_aset(bucket, rb_id2sym(rb_intern("eviction_policy")), rb_id2sym(rb_intern("full")));
@@ -4720,6 +4755,18 @@ cb_extract_bucket_settings(const couchbase::core::management::cluster::bucket_se
                 break;
         }
     }
+    if (entry.history_retention_collection_default.has_value()) {
+        rb_hash_aset(bucket,
+                     rb_id2sym(rb_intern("history_retention_collection_default")),
+                     entry.history_retention_collection_default.value() ? Qtrue : Qfalse);
+    }
+    if (const auto& val = entry.history_retention_bytes; val.has_value()) {
+        rb_hash_aset(bucket, rb_id2sym(rb_intern("history_retention_bytes")), ULONG2NUM(val.value()));
+    }
+    if (const auto& val = entry.history_retention_duration; val.has_value()) {
+        rb_hash_aset(bucket, rb_id2sym(rb_intern("history_retention_duration")), ULONG2NUM(val.value()));
+    }
+
     VALUE capabilities = rb_ary_new_capa(static_cast<long>(entry.capabilities.size()));
     for (const auto& capa : entry.capabilities) {
         rb_ary_push(capabilities, cb_str_new(capa));
@@ -5401,6 +5448,10 @@ cb_Backend_scope_get_all(VALUE self, VALUE bucket_name, VALUE options)
                 VALUE collection = rb_hash_new();
                 rb_hash_aset(collection, rb_id2sym(rb_intern("uid")), ULL2NUM(c.uid));
                 rb_hash_aset(collection, rb_id2sym(rb_intern("name")), cb_str_new(c.name));
+                rb_hash_aset(collection, rb_id2sym(rb_intern("max_expiry")), ULONG2NUM(c.max_expiry));
+                if (c.history.has_value()) {
+                    rb_hash_aset(collection, rb_id2sym(rb_intern("history")), c.history.value() ? Qtrue : Qfalse);
+                }
                 rb_ary_push(collections, collection);
             }
             rb_hash_aset(scope, rb_id2sym(rb_intern("collections")), collections);
@@ -5531,13 +5582,16 @@ cb_Backend_scope_drop(VALUE self, VALUE bucket_name, VALUE scope_name, VALUE opt
 }
 
 static VALUE
-cb_Backend_collection_create(VALUE self, VALUE bucket_name, VALUE scope_name, VALUE collection_name, VALUE max_expiry, VALUE options)
+cb_Backend_collection_create(VALUE self, VALUE bucket_name, VALUE scope_name, VALUE collection_name, VALUE settings, VALUE options)
 {
     const auto& cluster = cb_backend_to_cluster(self);
 
     Check_Type(bucket_name, T_STRING);
     Check_Type(scope_name, T_STRING);
     Check_Type(collection_name, T_STRING);
+    if (!NIL_P(settings)) {
+        Check_Type(settings, T_HASH);
+    }
     if (!NIL_P(options)) {
         Check_Type(options, T_HASH);
     }
@@ -5548,10 +5602,20 @@ cb_Backend_collection_create(VALUE self, VALUE bucket_name, VALUE scope_name, VA
                                                                                 cb_string_new(collection_name) };
         cb_extract_timeout(req, options);
 
-        if (!NIL_P(max_expiry)) {
-            Check_Type(max_expiry, T_FIXNUM);
-            req.max_expiry = FIX2UINT(max_expiry);
+        if (!NIL_P(settings)) {
+            if (VALUE max_expiry = rb_hash_aref(settings, rb_id2sym(rb_intern("max_expiry"))); !NIL_P(max_expiry)) {
+                if (TYPE(max_expiry) == T_FIXNUM) {
+                    req.max_expiry = FIX2UINT(max_expiry);
+                } else {
+                    throw ruby_exception(rb_eArgError,
+                                         rb_sprintf("collection max expiry must be an Integer, given %+" PRIsVALUE, max_expiry));
+                }
+            }
+            if (VALUE history = rb_hash_aref(settings, rb_id2sym(rb_intern("history"))); !NIL_P(history)) {
+                req.history = RTEST(history);
+            }
         }
+
         auto barrier = std::make_shared<std::promise<couchbase::core::operations::management::collection_create_response>>();
         auto f = barrier->get_future();
         cluster->execute(req, [barrier](couchbase::core::operations::management::collection_create_response&& resp) {
@@ -5573,6 +5637,62 @@ cb_Backend_collection_create(VALUE self, VALUE bucket_name, VALUE scope_name, VA
     return Qnil;
 }
 
+static VALUE
+cb_Backend_collection_update(VALUE self, VALUE bucket_name, VALUE scope_name, VALUE collection_name, VALUE settings, VALUE options)
+{
+    const auto& cluster = cb_backend_to_cluster(self);
+
+    Check_Type(bucket_name, T_STRING);
+    Check_Type(scope_name, T_STRING);
+    Check_Type(collection_name, T_STRING);
+    if (!NIL_P(settings)) {
+        Check_Type(settings, T_HASH);
+    }
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
+
+    try {
+        couchbase::core::operations::management::collection_update_request req{ cb_string_new(bucket_name),
+                                                                                cb_string_new(scope_name),
+                                                                                cb_string_new(collection_name) };
+        cb_extract_timeout(req, options);
+
+        if (!NIL_P(settings)) {
+            if (VALUE max_expiry = rb_hash_aref(settings, rb_id2sym(rb_intern("max_expiry"))); !NIL_P(max_expiry)) {
+                if (TYPE(max_expiry) == T_FIXNUM) {
+                    req.max_expiry = FIX2UINT(max_expiry);
+                } else {
+                    throw ruby_exception(rb_eArgError,
+                                         rb_sprintf("collection max expiry must be an Integer, given %+" PRIsVALUE, max_expiry));
+                }
+            }
+            if (VALUE history = rb_hash_aref(settings, rb_id2sym(rb_intern("history"))); !NIL_P(history)) {
+                req.history = RTEST(history);
+            }
+        }
+
+        auto barrier = std::make_shared<std::promise<couchbase::core::operations::management::collection_update_response>>();
+        auto f = barrier->get_future();
+        cluster->execute(req, [barrier](couchbase::core::operations::management::collection_update_response&& resp) {
+            barrier->set_value(std::move(resp));
+        });
+        auto resp = cb_wait_for_future(f);
+        if (resp.ctx.ec) {
+            cb_throw_error_code(
+              resp.ctx,
+              fmt::format(
+                R"(unable update the collection "{}.{}" on the bucket "{}")", req.scope_name, req.collection_name, req.bucket_name));
+        }
+        return ULL2NUM(resp.uid);
+    } catch (const std::system_error& se) {
+        rb_exc_raise(cb_map_error_code(se.code(), fmt::format("failed to perform {}: {}", __func__, se.what()), false));
+    } catch (const ruby_exception& e) {
+        rb_exc_raise(e.exception_object());
+    }
+    return Qnil;
+}
+
 static VALUE
 cb_Backend_collection_drop(VALUE self, VALUE bucket_name, VALUE scope_name, VALUE collection_name, VALUE options)
 {
@@ -9190,6 +9310,7 @@ init_backend(VALUE mCouchbase)
     rb_define_method(cBackend, "scope_create", VALUE_FUNC(cb_Backend_scope_create), 3);
     rb_define_method(cBackend, "scope_drop", VALUE_FUNC(cb_Backend_scope_drop), 3);
     rb_define_method(cBackend, "collection_create", VALUE_FUNC(cb_Backend_collection_create), 5);
+    rb_define_method(cBackend, "collection_update", VALUE_FUNC(cb_Backend_collection_update), 5);
     rb_define_method(cBackend, "collection_drop", VALUE_FUNC(cb_Backend_collection_drop), 4);
 
     rb_define_method(cBackend, "query_index_get_all", VALUE_FUNC(cb_Backend_query_index_get_all), 2);

data/ext/revisions.rb

@@ -1,3 +1,3 @@
-cmake_flags << "-DEXT_GIT_REVISION=167d2e58559c91239675f1e7f7ffa2f6176f0512"
-cmake_flags << "-DCOUCHBASE_CXX_CLIENT_GIT_REVISION=43cf66a592d1f8112141a73e5a563d7187ee0ee6"
-cmake_flags << "-DCOUCHBASE_CXX_CLIENT_GIT_DESCRIBE=1.0.0-dp.8-0-g43cf66a"
+cmake_flags << "-DEXT_GIT_REVISION=276c680f5d7d8c33d270470f473a42a9d91c11c7"
+cmake_flags << "-DCOUCHBASE_CXX_CLIENT_GIT_REVISION=a873bb91aa487fab8acd3b619355b911b1588fc1"
+cmake_flags << "-DCOUCHBASE_CXX_CLIENT_GIT_DESCRIBE=1.0.0-dp.9-0-ga873bb9"

data/lib/couchbase/collection_options.rb

@@ -169,7 +169,6 @@ module Couchbase
         field = get_field_at_index(path_or_index)
 
         raise field.error unless field.error.nil?
-        raise Error::PathNotFound, "Path is not found: #{path_or_index}" unless field.exists
 
         transcoder.decode(field.value, :json)
       end
@@ -191,7 +190,7 @@ module Couchbase
           end
         return false unless field
 
-        raise field.error unless field.error.nil?
+        raise field.error unless field.error.nil? || field.error.is_a?(Error::PathNotFound)
 
         field.exists
       end