couchbase 3.0.0.alpha.3-universal-darwin-19 → 3.0.0.alpha.4-universal-darwin-19

data/examples/managing_view_indexes.rb

@@ -0,0 +1,54 @@
+require "couchbase"
+include Couchbase
+
+def measure(msg)
+  start = Time.now
+  yield
+  printf "%s in %.2f seconds\n", msg, Time.now - start
+end
+
+def display_indexes(manager, namespace)
+  indexes = manager.get_all_design_documents(namespace)
+  puts "\"#{namespace}\" namespace of the bucket \"#{manager.bucket_name}\" contains #{indexes.size} design documents:"
+  indexes.each do |index|
+    puts "  * #{index.name} (#{index.views.size} views)"
+    index.views.each do |name, view|
+      puts "    - #{name}"
+      puts "      map:\n#{view.map.strip.gsub(/^/, "      | ")}" if view.has_map?
+      puts "      reduce:\n#{view.reduce.strip.gsub(/^/, "      | ")}" if view.has_reduce?
+    end
+  end
+end
+
+bucket_name = "beer-sample"
+
+options = Cluster::ClusterOptions.new
+options.authenticate("Administrator", "password")
+cluster = Cluster.connect("couchbase://localhost", options)
+
+bucket = cluster.bucket(bucket_name)
+manager = bucket.view_indexes
+
+display_indexes(manager, :production)
+
+design_document_name = "test"
+begin
+  manager.drop_design_document(design_document_name, :development)
+rescue Error::DesignDocumentNotFound
+  # ignore
+end
+
+view = Management::View.new
+view.map_function = "function (doc, meta) { emit(meta.id, null) }"
+
+design_document = Management::DesignDocument.new
+design_document.name = design_document_name
+design_document.views["get_all"] = view
+
+manager.upsert_design_document(design_document, :development)
+
+display_indexes(manager, :development)
+
+# copy design document from development namespace to production
+manager.publish_design_document(design_document_name)
+display_indexes(manager, :production)

data/examples/search_with_consistency.rb

@@ -0,0 +1,84 @@
+require 'couchbase'
+
+include Couchbase
+
+options = Cluster::ClusterOptions.new
+options.authenticate("Administrator", "password")
+cluster = Cluster.connect("couchbase://localhost", options)
+
+bucket_name = "default"
+# create index definition, if it does not exist already
+search_index_name = "knob_search"
+begin
+  cluster.search_indexes.get_index(search_index_name)
+rescue Error::IndexNotFound
+  index = Management::SearchIndex.new
+  index.type = "fulltext-index"
+  index.name = search_index_name
+  index.source_type = "couchbase"
+  index.source_name = bucket_name
+  index.params = {
+      mapping: {
+          types: {
+              "knob" => {
+                  properties: {
+                      "name" => {
+                          fields: [
+                              {
+                                  name: "name",
+                                  type: "text",
+                                  include_in_all: true,
+                                  include_term_vectors: true,
+                                  index: true,
+                                  store: true,
+                                  docvalues: true,
+                              }
+                          ]
+                      },
+                  }
+              }
+          }
+      }
+  }
+
+  cluster.search_indexes.upsert_index(index)
+
+  num_indexed = 0
+  loop do
+    sleep(1)
+    num = cluster.search_indexes.get_indexed_documents_count(search_index_name)
+    break if num_indexed == num
+    num_indexed = num
+    puts "indexing #{search_index_name.inspect}: #{num_indexed} documents"
+  end
+end
+
+collection = cluster.bucket(bucket_name).default_collection
+
+# The application need to to know exactly which mutation affect the result,
+# and supply mutation tokens from those operations.
+random_string = ("a".."z").to_a.sample(10).join
+res = collection.upsert("user:#{random_string}", {
+    "name" => "Brass Doorknob",
+    "email" => "brass.doorknob@example.com",
+    "data" => random_string,
+})
+
+state = MutationState.new(res.mutation_token)
+# state.add(*tokens) could be used to add more tokens
+
+query = Cluster::SearchQuery.term("doorknob")
+options = Cluster::SearchOptions.new
+options.timeout = 10_000
+options.consistent_with(state)
+res = cluster.search_query(search_index_name, query, options)
+
+res.rows.each do |row|
+  if row.id == "user:#{random_string}"
+    puts "--- Found our newly created document!"
+  end
+  if ENV['REMOVE_DOOR_KNOBS']
+    puts "Removing #{row.id} (requested via env)"
+    collection.remove(row.id)
+  end
+end

data/examples/view.rb

@@ -0,0 +1,50 @@
+# coding: utf-8
+#
+require 'couchbase'
+
+include Couchbase
+
+options = Cluster::ClusterOptions.new
+options.authenticate("Administrator", "password")
+cluster = Cluster.connect("couchbase://localhost", options)
+
+bucket = cluster.bucket("beer-sample")
+collection = bucket.default_collection
+
+options = Bucket::ViewOptions.new
+options.reduce = true
+options.group_level = 1
+res = bucket.view_query("beer", "by_location", options)
+puts "Breweries by country:"
+res.rows.each do |row|
+  puts "#{row.key.first}: #{row.value} breweries"
+end
+
+options = Bucket::ViewOptions.new
+options.limit = 10
+options.order = :descending
+res = bucket.view_query("beer", "brewery_beers", options)
+puts "\nTotal documents in 'beer/brewery_beers' index: #{res.meta_data.total_rows}"
+puts "Last #{options.limit} documents:"
+res.rows.each_with_index do |row|
+  doc = collection.get(row.id)
+  puts "#{row.id} (type: #{doc.content['type']}, key: #{row.key})"
+end
+
+
+random_number = rand(0..1_000_000_000)
+unique_brewery_id = "random_brewery:#{random_number}"
+collection.upsert("random_brewery:#{random_number}", {
+    "name" => "Random brewery: #{random_number}",
+    "type" => "brewery"
+})
+puts "\nRequest with consistency. Generated brewery name: #{unique_brewery_id}"
+options = Bucket::ViewOptions.new
+options.start_key = ["random_brewery:"]
+options.scan_consistency = :request_plus
+res = bucket.view_query("beer", "brewery_beers", options)
+res.rows.each do |row|
+  if row.id == unique_brewery_id
+    puts "Found newly created document: #{collection.get(row.id).content}"
+  end
+end

data/ext/.clang-tidy

@@ -18,4 +18,5 @@ Checks: |-
   -cppcoreguidelines-pro-bounds-pointer-arithmetic,
   -modernize-use-trailing-return-type,
   -llvmlibc-callee-namespace,
+  -abseil-*,
   -fuchsia-*

data/ext/build_version.hxx.in

@@ -22,5 +22,5 @@
 #define BACKEND_C_COMPILER "@CMAKE_C_COMPILER_ID@ @CMAKE_C_COMPILER_VERSION@"
 #define BACKEND_SYSTEM "@CMAKE_SYSTEM@"
 #define BACKEND_SYSTEM_PROCESSOR "@CMAKE_SYSTEM_PROCESSOR@"
-#define BACKEND_GIT_REVISION "86b887957baf7230bfbe853de48b4507b9c2c18d"
+#define BACKEND_GIT_REVISION "bb2110dbfe863e98cd246a07a3ae54f87a7a20b1"
 

data/ext/couchbase/bucket.hxx

@@ -86,7 +86,6 @@ class bucket
     }
 
   private:
-
     asio::io_context& ctx_;
     std::string name_;
     configuration config_;

data/ext/couchbase/couchbase.cxx

@@ -29,6 +29,9 @@
 #include <cluster.hxx>
 #include <operations.hxx>
 
+#include <io/dns_client.hxx>
+#include <utils/connection_string.hxx>
+
 #include <ruby.h>
 #if defined(HAVE_RUBY_VERSION_H)
 #include <ruby/version.h>
@@ -989,6 +992,8 @@ cb_Backend_document_upsert(VALUE self, VALUE bucket, VALUE collection, VALUE id,
                 ID level = rb_sym2id(durability_level);
                 if (level == rb_intern("none")) {
                     req.durability_level = couchbase::protocol::durability_level::none;
+                } else if (level == rb_intern("majority")) {
+                    req.durability_level = couchbase::protocol::durability_level::majority;
                 } else if (level == rb_intern("majority_and_persist_to_active")) {
                     req.durability_level = couchbase::protocol::durability_level::majority_and_persist_to_active;
                 } else if (level == rb_intern("persist_to_majority")) {
@@ -1060,6 +1065,8 @@ cb_Backend_document_replace(VALUE self, VALUE bucket, VALUE collection, VALUE id
                 ID level = rb_sym2id(durability_level);
                 if (level == rb_intern("none")) {
                     req.durability_level = couchbase::protocol::durability_level::none;
+                } else if (level == rb_intern("majority")) {
+                    req.durability_level = couchbase::protocol::durability_level::majority;
                 } else if (level == rb_intern("majority_and_persist_to_active")) {
                     req.durability_level = couchbase::protocol::durability_level::majority_and_persist_to_active;
                 } else if (level == rb_intern("persist_to_majority")) {
@@ -1142,6 +1149,8 @@ cb_Backend_document_insert(VALUE self, VALUE bucket, VALUE collection, VALUE id,
                 ID level = rb_sym2id(durability_level);
                 if (level == rb_intern("none")) {
                     req.durability_level = couchbase::protocol::durability_level::none;
+                } else if (level == rb_intern("majority")) {
+                    req.durability_level = couchbase::protocol::durability_level::majority;
                 } else if (level == rb_intern("majority_and_persist_to_active")) {
                     req.durability_level = couchbase::protocol::durability_level::majority_and_persist_to_active;
                 } else if (level == rb_intern("persist_to_majority")) {
@@ -1208,6 +1217,8 @@ cb_Backend_document_remove(VALUE self, VALUE bucket, VALUE collection, VALUE id,
                 ID level = rb_sym2id(durability_level);
                 if (level == rb_intern("none")) {
                     req.durability_level = couchbase::protocol::durability_level::none;
+                } else if (level == rb_intern("majority")) {
+                    req.durability_level = couchbase::protocol::durability_level::majority;
                 } else if (level == rb_intern("majority_and_persist_to_active")) {
                     req.durability_level = couchbase::protocol::durability_level::majority_and_persist_to_active;
                 } else if (level == rb_intern("persist_to_majority")) {
@@ -1268,6 +1279,8 @@ cb_Backend_document_increment(VALUE self, VALUE bucket, VALUE collection, VALUE
                 ID level = rb_sym2id(durability_level);
                 if (level == rb_intern("none")) {
                     req.durability_level = couchbase::protocol::durability_level::none;
+                } else if (level == rb_intern("majority")) {
+                    req.durability_level = couchbase::protocol::durability_level::majority;
                 } else if (level == rb_intern("majority_and_persist_to_active")) {
                     req.durability_level = couchbase::protocol::durability_level::majority_and_persist_to_active;
                 } else if (level == rb_intern("persist_to_majority")) {
@@ -1358,6 +1371,8 @@ cb_Backend_document_decrement(VALUE self, VALUE bucket, VALUE collection, VALUE
                 ID level = rb_sym2id(durability_level);
                 if (level == rb_intern("none")) {
                     req.durability_level = couchbase::protocol::durability_level::none;
+                } else if (level == rb_intern("majority")) {
+                    req.durability_level = couchbase::protocol::durability_level::majority;
                 } else if (level == rb_intern("majority_and_persist_to_active")) {
                     req.durability_level = couchbase::protocol::durability_level::majority_and_persist_to_active;
                 } else if (level == rb_intern("persist_to_majority")) {
@@ -1650,6 +1665,8 @@ cb_Backend_document_mutate_in(VALUE self,
                 ID level = rb_sym2id(durability_level);
                 if (level == rb_intern("none")) {
                     req.durability_level = couchbase::protocol::durability_level::none;
+                } else if (level == rb_intern("majority")) {
+                    req.durability_level = couchbase::protocol::durability_level::majority;
                 } else if (level == rb_intern("majority_and_persist_to_active")) {
                     req.durability_level = couchbase::protocol::durability_level::majority_and_persist_to_active;
                 } else if (level == rb_intern("persist_to_majority")) {
@@ -3886,68 +3903,1417 @@ cb_Backend_document_search(VALUE self, VALUE index_name, VALUE query, VALUE opti
     return Qnil;
 }
 
-static void
-init_backend(VALUE mCouchbase)
+static VALUE
+cb_Backend_dns_srv(VALUE self, VALUE hostname, VALUE service)
 {
-    VALUE cBackend = rb_define_class_under(mCouchbase, "Backend", rb_cBasicObject);
-    rb_define_alloc_func(cBackend, cb_Backend_allocate);
-    rb_define_method(cBackend, "open", VALUE_FUNC(cb_Backend_open), 3);
-    rb_define_method(cBackend, "close", VALUE_FUNC(cb_Backend_close), 0);
-    rb_define_method(cBackend, "open_bucket", VALUE_FUNC(cb_Backend_open_bucket), 1);
+    (void)self;
+    Check_Type(hostname, T_STRING);
+    Check_Type(service, T_SYMBOL);
 
-    rb_define_method(cBackend, "document_get", VALUE_FUNC(cb_Backend_document_get), 4);
-    rb_define_method(cBackend, "document_get_projected", VALUE_FUNC(cb_Backend_document_get_projected), 7);
-    rb_define_method(cBackend, "document_get_and_lock", VALUE_FUNC(cb_Backend_document_get_and_lock), 5);
-    rb_define_method(cBackend, "document_get_and_touch", VALUE_FUNC(cb_Backend_document_get_and_touch), 5);
-    rb_define_method(cBackend, "document_insert", VALUE_FUNC(cb_Backend_document_insert), 7);
-    rb_define_method(cBackend, "document_replace", VALUE_FUNC(cb_Backend_document_replace), 7);
-    rb_define_method(cBackend, "document_upsert", VALUE_FUNC(cb_Backend_document_upsert), 7);
-    rb_define_method(cBackend, "document_remove", VALUE_FUNC(cb_Backend_document_remove), 5);
-    rb_define_method(cBackend, "document_lookup_in", VALUE_FUNC(cb_Backend_document_lookup_in), 6);
-    rb_define_method(cBackend, "document_mutate_in", VALUE_FUNC(cb_Backend_document_mutate_in), 7);
-    rb_define_method(cBackend, "document_query", VALUE_FUNC(cb_Backend_document_query), 2);
-    rb_define_method(cBackend, "document_touch", VALUE_FUNC(cb_Backend_document_touch), 5);
-    rb_define_method(cBackend, "document_exists", VALUE_FUNC(cb_Backend_document_exists), 4);
-    rb_define_method(cBackend, "document_unlock", VALUE_FUNC(cb_Backend_document_unlock), 5);
-    rb_define_method(cBackend, "document_increment", VALUE_FUNC(cb_Backend_document_increment), 5);
-    rb_define_method(cBackend, "document_decrement", VALUE_FUNC(cb_Backend_document_decrement), 5);
-    rb_define_method(cBackend, "document_search", VALUE_FUNC(cb_Backend_document_search), 3);
+    bool tls = false;
 
-    rb_define_method(cBackend, "bucket_create", VALUE_FUNC(cb_Backend_bucket_create), 2);
-    rb_define_method(cBackend, "bucket_update", VALUE_FUNC(cb_Backend_bucket_update), 2);
-    rb_define_method(cBackend, "bucket_drop", VALUE_FUNC(cb_Backend_bucket_drop), 2);
-    rb_define_method(cBackend, "bucket_flush", VALUE_FUNC(cb_Backend_bucket_flush), 2);
-    rb_define_method(cBackend, "bucket_get_all", VALUE_FUNC(cb_Backend_bucket_get_all), 1);
-    rb_define_method(cBackend, "bucket_get", VALUE_FUNC(cb_Backend_bucket_get), 2);
+    ID type = rb_sym2id(service);
+    if (type == rb_intern("couchbase")) {
+        tls = false;
+    } else if (type == rb_intern("couchbases")) {
+        tls = true;
+    } else {
+        rb_raise(rb_eArgError, "Unsupported service type: %+" PRIsVALUE, service);
+    }
+    VALUE exc = Qnil;
+    do {
+        asio::io_context ctx;
 
-    rb_define_method(cBackend, "cluster_enable_developer_preview!", VALUE_FUNC(cb_Backend_cluster_enable_developer_preview), 0);
+        couchbase::io::dns::dns_client client(ctx);
+        std::string host_name(RSTRING_PTR(hostname), static_cast<size_t>(RSTRING_LEN(hostname)));
+        std::string service_name("_couchbase");
+        if (tls) {
+            service_name = "_couchbases";
+        }
+        auto barrier = std::make_shared<std::promise<couchbase::io::dns::dns_client::dns_srv_response>>();
+        auto f = barrier->get_future();
+        client.query_srv(
+          host_name, service_name, [barrier](couchbase::io::dns::dns_client::dns_srv_response resp) mutable { barrier->set_value(resp); });
+        ctx.run();
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(resp.ec, fmt::format("DNS SRV query failure for name \"{}\" (service: {})", host_name, service_name));
+            break;
+        }
 
-    rb_define_method(cBackend, "scope_get_all", VALUE_FUNC(cb_Backend_scope_get_all), 2);
-    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_drop", VALUE_FUNC(cb_Backend_collection_drop), 4);
+        VALUE res = rb_ary_new();
+        for (const auto& target : resp.targets) {
+            VALUE addr = rb_hash_new();
+            rb_hash_aset(
+              addr, rb_id2sym(rb_intern("hostname")), rb_str_new(target.hostname.data(), static_cast<long>(target.hostname.size())));
+            rb_hash_aset(addr, rb_id2sym(rb_intern("port")), UINT2NUM(target.port));
+            rb_ary_push(res, addr);
+        }
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
 
-    rb_define_method(cBackend, "query_index_get_all", VALUE_FUNC(cb_Backend_query_index_get_all), 2);
-    rb_define_method(cBackend, "query_index_create", VALUE_FUNC(cb_Backend_query_index_create), 5);
-    rb_define_method(cBackend, "query_index_create_primary", VALUE_FUNC(cb_Backend_query_index_create_primary), 3);
-    rb_define_method(cBackend, "query_index_drop", VALUE_FUNC(cb_Backend_query_index_drop), 4);
-    rb_define_method(cBackend, "query_index_drop_primary", VALUE_FUNC(cb_Backend_query_index_drop_primary), 3);
-    rb_define_method(cBackend, "query_index_build_deferred", VALUE_FUNC(cb_Backend_query_index_build_deferred), 2);
-    rb_define_method(cBackend, "query_index_watch", VALUE_FUNC(cb_Backend_query_index_watch), 4);
+static VALUE
+cb_Backend_analytics_get_pending_mutations(VALUE self, VALUE timeout)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
 
-    rb_define_method(cBackend, "search_index_get_all", VALUE_FUNC(cb_Backend_search_index_get_all), 1);
-    rb_define_method(cBackend, "search_index_get", VALUE_FUNC(cb_Backend_search_index_get), 2);
-    rb_define_method(cBackend, "search_index_upsert", VALUE_FUNC(cb_Backend_search_index_upsert), 2);
-    rb_define_method(cBackend, "search_index_drop", VALUE_FUNC(cb_Backend_search_index_drop), 2);
-    rb_define_method(cBackend, "search_index_get_documents_count", VALUE_FUNC(cb_Backend_search_index_get_documents_count), 2);
-    rb_define_method(cBackend, "search_index_pause_ingest", VALUE_FUNC(cb_Backend_search_index_pause_ingest), 2);
-    rb_define_method(cBackend, "search_index_resume_ingest", VALUE_FUNC(cb_Backend_search_index_resume_ingest), 2);
-    rb_define_method(cBackend, "search_index_allow_querying", VALUE_FUNC(cb_Backend_search_index_allow_querying), 2);
-    rb_define_method(cBackend, "search_index_disallow_querying", VALUE_FUNC(cb_Backend_search_index_disallow_querying), 2);
-    rb_define_method(cBackend, "search_index_freeze_plan", VALUE_FUNC(cb_Backend_search_index_freeze_plan), 2);
-    rb_define_method(cBackend, "search_index_unfreeze_plan", VALUE_FUNC(cb_Backend_search_index_unfreeze_plan), 2);
-    rb_define_method(cBackend, "search_index_analyze_document", VALUE_FUNC(cb_Backend_search_index_analyze_document), 3);
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::analytics_get_pending_mutations_request req{};
+        cb__extract_timeout(req, timeout);
+        auto barrier = std::make_shared<std::promise<couchbase::operations::analytics_get_pending_mutations_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::analytics_get_pending_mutations_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            if (resp.errors.empty()) {
+                exc = cb__map_error_code(resp.ec, "unable to get pending mutations for the analytics service");
+            } else {
+                const auto& first_error = resp.errors.front();
+                exc = cb__map_error_code(
+                  resp.ec,
+                  fmt::format("unable to get pending mutations for the analytics service ({}: {})", first_error.code, first_error.message));
+            }
+            break;
+        }
+        VALUE res = rb_hash_new();
+        for (const auto& entry : resp.stats) {
+            rb_hash_aset(res, rb_str_new(entry.first.data(), static_cast<long>(entry.first.size())), ULL2NUM(entry.second));
+        }
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_analytics_dataset_get_all(VALUE self, VALUE timeout)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
+
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::analytics_dataset_get_all_request req{};
+        cb__extract_timeout(req, timeout);
+        auto barrier = std::make_shared<std::promise<couchbase::operations::analytics_dataset_get_all_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::analytics_dataset_get_all_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            if (resp.errors.empty()) {
+                exc = cb__map_error_code(resp.ec, "unable to fetch all datasets");
+            } else {
+                const auto& first_error = resp.errors.front();
+                exc =
+                  cb__map_error_code(resp.ec, fmt::format("unable to fetch all datasets ({}: {})", first_error.code, first_error.message));
+            }
+            break;
+        }
+        VALUE res = rb_ary_new_capa(static_cast<long>(resp.datasets.size()));
+        for (const auto& ds : resp.datasets) {
+            VALUE dataset = rb_hash_new();
+            rb_hash_aset(dataset, rb_id2sym(rb_intern("name")), rb_str_new(ds.name.data(), static_cast<long>(ds.name.size())));
+            rb_hash_aset(dataset,
+                         rb_id2sym(rb_intern("dataverse_name")),
+                         rb_str_new(ds.dataverse_name.data(), static_cast<long>(ds.dataverse_name.size())));
+            rb_hash_aset(
+              dataset, rb_id2sym(rb_intern("link_name")), rb_str_new(ds.link_name.data(), static_cast<long>(ds.link_name.size())));
+            rb_hash_aset(
+              dataset, rb_id2sym(rb_intern("bucket_name")), rb_str_new(ds.bucket_name.data(), static_cast<long>(ds.bucket_name.size())));
+            rb_ary_push(res, dataset);
+        }
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_analytics_dataset_drop(VALUE self, VALUE dataset_name, VALUE dataverse_name, VALUE ignore_if_does_not_exist, VALUE timeout)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
+
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    Check_Type(dataset_name, T_STRING);
+    if (!NIL_P(dataverse_name)) {
+        Check_Type(dataverse_name, T_STRING);
+    }
+
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::analytics_dataset_drop_request req{};
+        cb__extract_timeout(req, timeout);
+        req.dataset_name.assign(RSTRING_PTR(dataset_name), static_cast<size_t>(RSTRING_LEN(dataset_name)));
+        if (!NIL_P(dataverse_name)) {
+            req.dataverse_name.assign(RSTRING_PTR(dataverse_name), static_cast<size_t>(RSTRING_LEN(dataverse_name)));
+        }
+        if (!NIL_P(ignore_if_does_not_exist)) {
+            req.ignore_if_does_not_exist = RTEST(ignore_if_does_not_exist);
+        }
+        auto barrier = std::make_shared<std::promise<couchbase::operations::analytics_dataset_drop_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::analytics_dataset_drop_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            if (resp.errors.empty()) {
+                exc = cb__map_error_code(resp.ec, fmt::format("unable to drop dataset `{}`.`{}`", req.dataverse_name, req.dataset_name));
+            } else {
+                const auto& first_error = resp.errors.front();
+                exc = cb__map_error_code(resp.ec,
+                                         fmt::format("unable to drop dataset `{}`.`{}` ({}: {})",
+                                                     req.dataverse_name,
+                                                     req.dataset_name,
+                                                     first_error.code,
+                                                     first_error.message));
+            }
+            break;
+        }
+        return Qtrue;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_analytics_dataset_create(VALUE self,
+                                    VALUE dataset_name,
+                                    VALUE bucket_name,
+                                    VALUE condition,
+                                    VALUE dataverse_name,
+                                    VALUE ignore_if_exists,
+                                    VALUE timeout)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
+
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    Check_Type(dataset_name, T_STRING);
+    Check_Type(bucket_name, T_STRING);
+    if (!NIL_P(condition)) {
+        Check_Type(condition, T_STRING);
+    }
+    if (!NIL_P(dataverse_name)) {
+        Check_Type(dataverse_name, T_STRING);
+    }
+
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::analytics_dataset_create_request req{};
+        cb__extract_timeout(req, timeout);
+        req.dataset_name.assign(RSTRING_PTR(dataset_name), static_cast<size_t>(RSTRING_LEN(dataset_name)));
+        req.bucket_name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
+        if (!NIL_P(condition)) {
+            req.condition.emplace(std::string(RSTRING_PTR(condition), static_cast<size_t>(RSTRING_LEN(condition))));
+        }
+        if (!NIL_P(dataverse_name)) {
+            req.dataverse_name.assign(RSTRING_PTR(dataverse_name), static_cast<size_t>(RSTRING_LEN(dataverse_name)));
+        }
+        if (!NIL_P(ignore_if_exists)) {
+            req.ignore_if_exists = RTEST(ignore_if_exists);
+        }
+        auto barrier = std::make_shared<std::promise<couchbase::operations::analytics_dataset_create_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::analytics_dataset_create_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            if (resp.errors.empty()) {
+                exc = cb__map_error_code(resp.ec, fmt::format("unable to create dataset `{}`.`{}`", req.dataverse_name, req.dataset_name));
+            } else {
+                const auto& first_error = resp.errors.front();
+                exc = cb__map_error_code(resp.ec,
+                                         fmt::format("unable to create dataset `{}`.`{}` ({}: {})",
+                                                     req.dataverse_name,
+                                                     req.dataset_name,
+                                                     first_error.code,
+                                                     first_error.message));
+            }
+            break;
+        }
+        return Qtrue;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_analytics_dataverse_drop(VALUE self, VALUE dataverse_name, VALUE ignore_if_does_not_exist, VALUE timeout)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
+
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    Check_Type(dataverse_name, T_STRING);
+
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::analytics_dataverse_drop_request req{};
+        cb__extract_timeout(req, timeout);
+        req.dataverse_name.assign(RSTRING_PTR(dataverse_name), static_cast<size_t>(RSTRING_LEN(dataverse_name)));
+        if (!NIL_P(ignore_if_does_not_exist)) {
+            req.ignore_if_does_not_exist = RTEST(ignore_if_does_not_exist);
+        }
+        auto barrier = std::make_shared<std::promise<couchbase::operations::analytics_dataverse_drop_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::analytics_dataverse_drop_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            if (resp.errors.empty()) {
+                exc = cb__map_error_code(resp.ec, fmt::format("unable to drop dataverse `{}`", req.dataverse_name));
+            } else {
+                const auto& first_error = resp.errors.front();
+                exc = cb__map_error_code(
+                  resp.ec,
+                  fmt::format("unable to drop dataverse `{}` ({}: {})", req.dataverse_name, first_error.code, first_error.message));
+            }
+            break;
+        }
+        return Qtrue;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_analytics_dataverse_create(VALUE self, VALUE dataverse_name, VALUE ignore_if_exists, VALUE timeout)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
+
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    Check_Type(dataverse_name, T_STRING);
+    if (!NIL_P(dataverse_name)) {
+        Check_Type(dataverse_name, T_STRING);
+    }
+
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::analytics_dataverse_create_request req{};
+        cb__extract_timeout(req, timeout);
+        req.dataverse_name.assign(RSTRING_PTR(dataverse_name), static_cast<size_t>(RSTRING_LEN(dataverse_name)));
+        if (!NIL_P(ignore_if_exists)) {
+            req.ignore_if_exists = RTEST(ignore_if_exists);
+        }
+        auto barrier = std::make_shared<std::promise<couchbase::operations::analytics_dataverse_create_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::analytics_dataverse_create_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            if (resp.errors.empty()) {
+                exc = cb__map_error_code(resp.ec, fmt::format("unable to create dataverse `{}`", req.dataverse_name));
+            } else {
+                const auto& first_error = resp.errors.front();
+                exc = cb__map_error_code(
+                  resp.ec,
+                  fmt::format("unable to create dataverse `{}` ({}: {})", req.dataverse_name, first_error.code, first_error.message));
+            }
+            break;
+        }
+        return Qtrue;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_analytics_index_get_all(VALUE self, VALUE timeout)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
+
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::analytics_index_get_all_request req{};
+        cb__extract_timeout(req, timeout);
+        auto barrier = std::make_shared<std::promise<couchbase::operations::analytics_index_get_all_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::analytics_index_get_all_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            if (resp.errors.empty()) {
+                exc = cb__map_error_code(resp.ec, "unable to fetch all indexes");
+            } else {
+                const auto& first_error = resp.errors.front();
+                exc =
+                  cb__map_error_code(resp.ec, fmt::format("unable to fetch all indexes ({}: {})", first_error.code, first_error.message));
+            }
+            break;
+        }
+        VALUE res = rb_ary_new_capa(static_cast<long>(resp.indexes.size()));
+        for (const auto& idx : resp.indexes) {
+            VALUE index = rb_hash_new();
+            rb_hash_aset(index, rb_id2sym(rb_intern("name")), rb_str_new(idx.name.data(), static_cast<long>(idx.name.size())));
+            rb_hash_aset(
+              index, rb_id2sym(rb_intern("dataset_name")), rb_str_new(idx.dataset_name.data(), static_cast<long>(idx.dataset_name.size())));
+            rb_hash_aset(index,
+                         rb_id2sym(rb_intern("dataverse_name")),
+                         rb_str_new(idx.dataverse_name.data(), static_cast<long>(idx.dataverse_name.size())));
+            rb_hash_aset(index, rb_id2sym(rb_intern("is_primary")), idx.is_primary ? Qtrue : Qfalse);
+            rb_ary_push(res, index);
+        }
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_analytics_index_create(VALUE self,
+                                  VALUE index_name,
+                                  VALUE dataset_name,
+                                  VALUE fields,
+                                  VALUE dataverse_name,
+                                  VALUE ignore_if_exists,
+                                  VALUE timeout)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
+
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    Check_Type(index_name, T_STRING);
+    Check_Type(dataset_name, T_STRING);
+    Check_Type(fields, T_ARRAY);
+    if (!NIL_P(dataverse_name)) {
+        Check_Type(dataverse_name, T_STRING);
+    }
+
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::analytics_index_create_request req{};
+        cb__extract_timeout(req, timeout);
+        req.index_name.assign(RSTRING_PTR(index_name), static_cast<size_t>(RSTRING_LEN(index_name)));
+        req.dataset_name.assign(RSTRING_PTR(dataset_name), static_cast<size_t>(RSTRING_LEN(dataset_name)));
+        auto fields_num = static_cast<size_t>(RARRAY_LEN(fields));
+        for (size_t i = 0; i < fields_num; ++i) {
+            VALUE entry = rb_ary_entry(fields, static_cast<long>(i));
+            Check_Type(entry, T_ARRAY);
+            if (RARRAY_LEN(entry) == 2) {
+                VALUE field = rb_ary_entry(entry, 0);
+                VALUE type = rb_ary_entry(entry, 1);
+                req.fields.emplace(std::string(RSTRING_PTR(field), static_cast<std::size_t>(RSTRING_LEN(field))),
+                                   std::string(RSTRING_PTR(type), static_cast<std::size_t>(RSTRING_LEN(type))));
+            }
+        }
+        if (!NIL_P(dataverse_name)) {
+            req.dataverse_name.assign(RSTRING_PTR(dataverse_name), static_cast<size_t>(RSTRING_LEN(dataverse_name)));
+        }
+        if (!NIL_P(ignore_if_exists)) {
+            req.ignore_if_exists = RTEST(ignore_if_exists);
+        }
+        auto barrier = std::make_shared<std::promise<couchbase::operations::analytics_index_create_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::analytics_index_create_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            if (resp.errors.empty()) {
+                exc = cb__map_error_code(
+                  resp.ec, fmt::format("unable to create index `{}` on `{}`.`{}`", req.index_name, req.dataverse_name, req.dataset_name));
+            } else {
+                const auto& first_error = resp.errors.front();
+                exc = cb__map_error_code(resp.ec,
+                                         fmt::format("unable to create index `{}` on `{}`.`{}` ({}: {})",
+                                                     req.index_name,
+                                                     req.dataverse_name,
+                                                     req.dataset_name,
+                                                     first_error.code,
+                                                     first_error.message));
+            }
+            break;
+        }
+        return Qtrue;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_analytics_index_drop(VALUE self,
+                                VALUE index_name,
+                                VALUE dataset_name,
+                                VALUE dataverse_name,
+                                VALUE ignore_if_does_not_exist,
+                                VALUE timeout)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
+
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    Check_Type(index_name, T_STRING);
+    Check_Type(dataset_name, T_STRING);
+    if (!NIL_P(dataverse_name)) {
+        Check_Type(dataverse_name, T_STRING);
+    }
+
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::analytics_index_drop_request req{};
+        cb__extract_timeout(req, timeout);
+        req.index_name.assign(RSTRING_PTR(index_name), static_cast<size_t>(RSTRING_LEN(index_name)));
+        req.dataset_name.assign(RSTRING_PTR(dataset_name), static_cast<size_t>(RSTRING_LEN(dataset_name)));
+        if (!NIL_P(dataverse_name)) {
+            req.dataverse_name.assign(RSTRING_PTR(dataverse_name), static_cast<size_t>(RSTRING_LEN(dataverse_name)));
+        }
+        if (!NIL_P(ignore_if_does_not_exist)) {
+            req.ignore_if_does_not_exist = RTEST(ignore_if_does_not_exist);
+        }
+        auto barrier = std::make_shared<std::promise<couchbase::operations::analytics_index_drop_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::analytics_index_drop_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            if (resp.errors.empty()) {
+                exc = cb__map_error_code(
+                  resp.ec, fmt::format("unable to drop index `{}`.`{}`.`{}`", req.dataverse_name, req.dataset_name, req.index_name));
+            } else {
+                const auto& first_error = resp.errors.front();
+                exc = cb__map_error_code(resp.ec,
+                                         fmt::format("unable to drop index `{}`.`{}`.`{}` ({}: {})",
+                                                     req.dataverse_name,
+                                                     req.dataset_name,
+                                                     req.index_name,
+                                                     first_error.code,
+                                                     first_error.message));
+            }
+            break;
+        }
+        return Qtrue;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_analytics_link_connect(VALUE self, VALUE link_name, VALUE force, VALUE dataverse_name, VALUE timeout)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
+
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    Check_Type(link_name, T_STRING);
+    if (!NIL_P(dataverse_name)) {
+        Check_Type(dataverse_name, T_STRING);
+    }
+
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::analytics_link_connect_request req{};
+        cb__extract_timeout(req, timeout);
+        req.link_name.assign(RSTRING_PTR(link_name), static_cast<size_t>(RSTRING_LEN(link_name)));
+        if (!NIL_P(dataverse_name)) {
+            req.dataverse_name.assign(RSTRING_PTR(dataverse_name), static_cast<size_t>(RSTRING_LEN(dataverse_name)));
+        }
+        if (!NIL_P(force)) {
+            req.force = RTEST(force);
+        }
+        auto barrier = std::make_shared<std::promise<couchbase::operations::analytics_link_connect_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::analytics_link_connect_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            if (resp.errors.empty()) {
+                exc = cb__map_error_code(resp.ec, fmt::format("unable to connect link `{}` on `{}`", req.link_name, req.dataverse_name));
+            } else {
+                const auto& first_error = resp.errors.front();
+                exc = cb__map_error_code(resp.ec,
+                                         fmt::format("unable to connect link `{}` on `{}` ({}: {})",
+                                                     req.link_name,
+                                                     req.dataverse_name,
+                                                     first_error.code,
+                                                     first_error.message));
+            }
+            break;
+        }
+        return Qtrue;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_analytics_link_disconnect(VALUE self, VALUE link_name, VALUE dataverse_name, VALUE timeout)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
+
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    Check_Type(link_name, T_STRING);
+    if (!NIL_P(dataverse_name)) {
+        Check_Type(dataverse_name, T_STRING);
+    }
+
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::analytics_link_disconnect_request req{};
+        cb__extract_timeout(req, timeout);
+        req.link_name.assign(RSTRING_PTR(link_name), static_cast<size_t>(RSTRING_LEN(link_name)));
+        if (!NIL_P(dataverse_name)) {
+            req.dataverse_name.assign(RSTRING_PTR(dataverse_name), static_cast<size_t>(RSTRING_LEN(dataverse_name)));
+        }
+        auto barrier = std::make_shared<std::promise<couchbase::operations::analytics_link_disconnect_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::analytics_link_disconnect_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            if (resp.errors.empty()) {
+                exc = cb__map_error_code(resp.ec, fmt::format("unable to disconnect link `{}` on `{}`", req.link_name, req.dataverse_name));
+            } else {
+                const auto& first_error = resp.errors.front();
+                exc = cb__map_error_code(resp.ec,
+                                         fmt::format("unable to disconnect link `{}` on `{}` ({}: {})",
+                                                     req.link_name,
+                                                     req.dataverse_name,
+                                                     first_error.code,
+                                                     first_error.message));
+            }
+            break;
+        }
+        return Qtrue;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static int
+cb__for_each_named_param__analytics(VALUE key, VALUE value, VALUE arg)
+{
+    auto* preq = reinterpret_cast<couchbase::operations::analytics_request*>(arg);
+    Check_Type(key, T_STRING);
+    Check_Type(value, T_STRING);
+    preq->named_parameters.emplace(
+      std::string_view(RSTRING_PTR(key), static_cast<std::size_t>(RSTRING_LEN(key))),
+      tao::json::from_string(std::string_view(RSTRING_PTR(value), static_cast<std::size_t>(RSTRING_LEN(value)))));
+    return ST_CONTINUE;
+}
+
+static VALUE
+cb_Backend_document_analytics(VALUE self, VALUE statement, VALUE options)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
+
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    Check_Type(statement, T_STRING);
+    Check_Type(options, T_HASH);
+
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::analytics_request req;
+        req.statement.assign(RSTRING_PTR(statement), static_cast<size_t>(RSTRING_LEN(statement)));
+        VALUE client_context_id = rb_hash_aref(options, rb_id2sym(rb_intern("client_context_id")));
+        if (!NIL_P(client_context_id)) {
+            Check_Type(client_context_id, T_STRING);
+            req.client_context_id.assign(RSTRING_PTR(client_context_id), static_cast<size_t>(RSTRING_LEN(client_context_id)));
+        }
+        cb__extract_timeout(req, rb_hash_aref(options, rb_id2sym(rb_intern("timeout"))));
+        VALUE readonly = rb_hash_aref(options, rb_id2sym(rb_intern("readonly")));
+        if (!NIL_P(readonly)) {
+            req.readonly = RTEST(readonly);
+        }
+        VALUE priority = rb_hash_aref(options, rb_id2sym(rb_intern("priority")));
+        if (!NIL_P(priority)) {
+            req.priority = RTEST(priority);
+        }
+        VALUE scan_wait = rb_hash_aref(options, rb_id2sym(rb_intern("scan_wait")));
+        if (!NIL_P(scan_wait)) {
+            req.scan_wait = NUM2ULONG(scan_wait);
+        }
+        VALUE positional_params = rb_hash_aref(options, rb_id2sym(rb_intern("positional_parameters")));
+        if (!NIL_P(positional_params)) {
+            Check_Type(positional_params, T_ARRAY);
+            auto entries_num = static_cast<size_t>(RARRAY_LEN(positional_params));
+            req.positional_parameters.reserve(entries_num);
+            for (size_t i = 0; i < entries_num; ++i) {
+                VALUE entry = rb_ary_entry(positional_params, static_cast<long>(i));
+                Check_Type(entry, T_STRING);
+                req.positional_parameters.emplace_back(
+                  tao::json::from_string(std::string_view(RSTRING_PTR(entry), static_cast<std::size_t>(RSTRING_LEN(entry)))));
+            }
+        }
+        VALUE named_params = rb_hash_aref(options, rb_id2sym(rb_intern("named_parameters")));
+        if (!NIL_P(named_params)) {
+            Check_Type(named_params, T_HASH);
+            rb_hash_foreach(named_params, INT_FUNC(cb__for_each_named_param__analytics), reinterpret_cast<VALUE>(&req));
+        }
+        VALUE scan_consistency = rb_hash_aref(options, rb_id2sym(rb_intern("scan_consistency")));
+        if (!NIL_P(scan_consistency)) {
+            Check_Type(scan_consistency, T_SYMBOL);
+            ID type = rb_sym2id(scan_consistency);
+            if (type == rb_intern("not_bounded")) {
+                req.scan_consistency = couchbase::operations::analytics_request::scan_consistency_type::not_bounded;
+            } else if (type == rb_intern("request_plus")) {
+                req.scan_consistency = couchbase::operations::analytics_request::scan_consistency_type::request_plus;
+            }
+        }
+
+        VALUE raw_params = rb_hash_aref(options, rb_id2sym(rb_intern("raw_parameters")));
+        if (!NIL_P(raw_params)) {
+            Check_Type(raw_params, T_HASH);
+            rb_hash_foreach(raw_params, INT_FUNC(cb__for_each_named_param__analytics), reinterpret_cast<VALUE>(&req));
+        }
+
+        auto barrier = std::make_shared<std::promise<couchbase::operations::analytics_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(req,
+                                       [barrier](couchbase::operations::analytics_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            if (resp.payload.meta_data.errors && !resp.payload.meta_data.errors->empty()) {
+                const auto& first_error = resp.payload.meta_data.errors->front();
+                exc = cb__map_error_code(resp.ec,
+                                         fmt::format("unable to execute analytics query: \"{}{}\" ({}: {})",
+                                                     req.statement.substr(0, 50),
+                                                     req.statement.size() > 50 ? "..." : "",
+                                                     first_error.code,
+                                                     first_error.message));
+            } else {
+                exc = cb__map_error_code(resp.ec,
+                                         fmt::format("unable to execute analytics query: \"{}{}\"",
+                                                     req.statement.substr(0, 50),
+                                                     req.statement.size() > 50 ? "..." : ""));
+            }
+            break;
+        }
+        VALUE res = rb_hash_new();
+        VALUE rows = rb_ary_new_capa(static_cast<long>(resp.payload.rows.size()));
+        rb_hash_aset(res, rb_id2sym(rb_intern("rows")), rows);
+        for (auto& row : resp.payload.rows) {
+            rb_ary_push(rows, rb_str_new(row.data(), static_cast<long>(row.size())));
+        }
+        VALUE meta = rb_hash_new();
+        rb_hash_aset(res, rb_id2sym(rb_intern("meta")), meta);
+        rb_hash_aset(meta,
+                     rb_id2sym(rb_intern("status")),
+                     rb_id2sym(rb_intern2(resp.payload.meta_data.status.data(), static_cast<long>(resp.payload.meta_data.status.size()))));
+        rb_hash_aset(meta,
+                     rb_id2sym(rb_intern("request_id")),
+                     rb_str_new(resp.payload.meta_data.request_id.data(), static_cast<long>(resp.payload.meta_data.request_id.size())));
+        rb_hash_aset(
+          meta,
+          rb_id2sym(rb_intern("client_context_id")),
+          rb_str_new(resp.payload.meta_data.client_context_id.data(), static_cast<long>(resp.payload.meta_data.client_context_id.size())));
+        if (resp.payload.meta_data.signature) {
+            rb_hash_aset(meta,
+                         rb_id2sym(rb_intern("signature")),
+                         rb_str_new(resp.payload.meta_data.signature->data(), static_cast<long>(resp.payload.meta_data.signature->size())));
+        }
+        if (resp.payload.meta_data.profile) {
+            rb_hash_aset(meta,
+                         rb_id2sym(rb_intern("profile")),
+                         rb_str_new(resp.payload.meta_data.profile->data(), static_cast<long>(resp.payload.meta_data.profile->size())));
+        }
+        VALUE metrics = rb_hash_new();
+        rb_hash_aset(meta, rb_id2sym(rb_intern("metrics")), metrics);
+        rb_hash_aset(metrics,
+                     rb_id2sym(rb_intern("elapsed_time")),
+                     rb_str_new(resp.payload.meta_data.metrics.elapsed_time.data(),
+                                static_cast<long>(resp.payload.meta_data.metrics.elapsed_time.size())));
+        rb_hash_aset(metrics,
+                     rb_id2sym(rb_intern("execution_time")),
+                     rb_str_new(resp.payload.meta_data.metrics.execution_time.data(),
+                                static_cast<long>(resp.payload.meta_data.metrics.execution_time.size())));
+        rb_hash_aset(metrics, rb_id2sym(rb_intern("result_count")), ULL2NUM(resp.payload.meta_data.metrics.result_count));
+        rb_hash_aset(metrics, rb_id2sym(rb_intern("result_size")), ULL2NUM(resp.payload.meta_data.metrics.result_count));
+        if (resp.payload.meta_data.metrics.sort_count) {
+            rb_hash_aset(metrics, rb_id2sym(rb_intern("sort_count")), ULL2NUM(*resp.payload.meta_data.metrics.sort_count));
+        }
+        if (resp.payload.meta_data.metrics.mutation_count) {
+            rb_hash_aset(metrics, rb_id2sym(rb_intern("mutation_count")), ULL2NUM(*resp.payload.meta_data.metrics.mutation_count));
+        }
+        if (resp.payload.meta_data.metrics.error_count) {
+            rb_hash_aset(metrics, rb_id2sym(rb_intern("error_count")), ULL2NUM(*resp.payload.meta_data.metrics.error_count));
+        }
+        if (resp.payload.meta_data.metrics.warning_count) {
+            rb_hash_aset(metrics, rb_id2sym(rb_intern("warning_count")), ULL2NUM(*resp.payload.meta_data.metrics.warning_count));
+        }
+
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_parse_connection_string(VALUE self, VALUE connection_string)
+{
+    (void)self;
+    Check_Type(connection_string, T_STRING);
+
+    std::string input(RSTRING_PTR(connection_string), static_cast<size_t>(RSTRING_LEN(connection_string)));
+    auto connstr = couchbase::utils::parse_connection_string(input);
+
+    VALUE res = rb_hash_new();
+    if (!connstr.scheme.empty()) {
+        rb_hash_aset(res, rb_id2sym(rb_intern("scheme")), rb_str_new(connstr.scheme.data(), static_cast<long>(connstr.scheme.size())));
+        rb_hash_aset(res, rb_id2sym(rb_intern("tls")), connstr.tls ? Qtrue : Qfalse);
+    }
+
+    VALUE nodes = rb_ary_new_capa(static_cast<long>(connstr.bootstrap_nodes.size()));
+    for (const auto& entry : connstr.bootstrap_nodes) {
+        VALUE node = rb_hash_new();
+        rb_hash_aset(node, rb_id2sym(rb_intern("address")), rb_str_new(entry.address.data(), static_cast<long>(entry.address.size())));
+        if (entry.port > 0) {
+            rb_hash_aset(node, rb_id2sym(rb_intern("port")), UINT2NUM(entry.port));
+        }
+        switch (entry.mode) {
+            case couchbase::utils::connection_string::bootstrap_mode::gcccp:
+                rb_hash_aset(node, rb_id2sym(rb_intern("mode")), rb_id2sym(rb_intern("gcccp")));
+                break;
+            case couchbase::utils::connection_string::bootstrap_mode::http:
+                rb_hash_aset(node, rb_id2sym(rb_intern("mode")), rb_id2sym(rb_intern("http")));
+                break;
+            case couchbase::utils::connection_string::bootstrap_mode::unspecified:
+                break;
+        }
+        switch (entry.type) {
+            case couchbase::utils::connection_string::address_type::ipv4:
+                rb_hash_aset(node, rb_id2sym(rb_intern("type")), rb_id2sym(rb_intern("ipv4")));
+                break;
+            case couchbase::utils::connection_string::address_type::ipv6:
+                rb_hash_aset(node, rb_id2sym(rb_intern("type")), rb_id2sym(rb_intern("ipv6")));
+                break;
+            case couchbase::utils::connection_string::address_type::dns:
+                rb_hash_aset(node, rb_id2sym(rb_intern("type")), rb_id2sym(rb_intern("dns")));
+                break;
+        }
+        rb_ary_push(nodes, node);
+    }
+    rb_hash_aset(res, rb_id2sym(rb_intern("nodes")), nodes);
+
+    VALUE params = rb_hash_new();
+    for (const auto& param : connstr.params) {
+        rb_hash_aset(params,
+                     rb_str_new(param.first.data(), static_cast<long>(param.first.size())),
+                     rb_str_new(param.second.data(), static_cast<long>(param.second.size())));
+    }
+    rb_hash_aset(res, rb_id2sym(rb_intern("params")), params);
+
+    if (connstr.default_bucket_name) {
+        rb_hash_aset(res,
+                     rb_id2sym(rb_intern("default_bucket_name")),
+                     rb_str_new(connstr.default_bucket_name->data(), static_cast<long>(connstr.default_bucket_name->size())));
+    }
+    if (connstr.default_port > 0) {
+        rb_hash_aset(res, rb_id2sym(rb_intern("default_port")), UINT2NUM(connstr.default_port));
+    }
+    switch (connstr.default_mode) {
+        case couchbase::utils::connection_string::bootstrap_mode::gcccp:
+            rb_hash_aset(res, rb_id2sym(rb_intern("default_mode")), rb_id2sym(rb_intern("gcccp")));
+            break;
+        case couchbase::utils::connection_string::bootstrap_mode::http:
+            rb_hash_aset(res, rb_id2sym(rb_intern("default_mode")), rb_id2sym(rb_intern("http")));
+            break;
+        case couchbase::utils::connection_string::bootstrap_mode::unspecified:
+            break;
+    }
+    if (connstr.error) {
+        rb_hash_aset(res, rb_id2sym(rb_intern("error")), rb_str_new(connstr.error->data(), static_cast<long>(connstr.error->size())));
+    }
+    return res;
+}
+
+static VALUE
+cb_Backend_view_index_get_all(VALUE self, VALUE bucket_name, VALUE name_space, VALUE timeout)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
+
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    Check_Type(bucket_name, T_STRING);
+    Check_Type(name_space, T_SYMBOL);
+
+    couchbase::operations::design_document::name_space ns;
+    ID type = rb_sym2id(name_space);
+    if (type == rb_intern("development")) {
+        ns = couchbase::operations::design_document::name_space::development;
+    } else if (type == rb_intern("production")) {
+        ns = couchbase::operations::design_document::name_space::production;
+    } else {
+        rb_raise(rb_eArgError, "Unknown design document namespace: %+" PRIsVALUE, type);
+    }
+
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::view_index_get_all_request req{};
+        req.bucket_name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
+        req.name_space = ns;
+        cb__extract_timeout(req, timeout);
+        auto barrier = std::make_shared<std::promise<couchbase::operations::view_index_get_all_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::view_index_get_all_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(resp.ec, "unable to get list of the design documents");
+            break;
+        }
+        VALUE res = rb_ary_new_capa(static_cast<long>(resp.design_documents.size()));
+        for (const auto& entry : resp.design_documents) {
+            VALUE dd = rb_hash_new();
+            rb_hash_aset(dd, rb_id2sym(rb_intern("name")), rb_str_new(entry.name.data(), static_cast<long>(entry.name.size())));
+            rb_hash_aset(dd, rb_id2sym(rb_intern("rev")), rb_str_new(entry.rev.data(), static_cast<long>(entry.rev.size())));
+            switch (entry.ns) {
+                case couchbase::operations::design_document::name_space::development:
+                    rb_hash_aset(dd, rb_id2sym(rb_intern("namespace")), rb_id2sym(rb_intern("development")));
+                    break;
+                case couchbase::operations::design_document::name_space::production:
+                    rb_hash_aset(dd, rb_id2sym(rb_intern("namespace")), rb_id2sym(rb_intern("production")));
+                    break;
+            }
+            VALUE views = rb_hash_new();
+            for (const auto& view_entry : entry.views) {
+                VALUE view_name = rb_str_new(view_entry.first.data(), static_cast<long>(view_entry.first.size()));
+                VALUE view = rb_hash_new();
+                rb_hash_aset(view, rb_id2sym(rb_intern("name")), view_name);
+                if (view_entry.second.map) {
+                    rb_hash_aset(view,
+                                 rb_id2sym(rb_intern("map")),
+                                 rb_str_new(view_entry.second.map->data(), static_cast<long>(view_entry.second.map->size())));
+                }
+                if (view_entry.second.reduce) {
+                    rb_hash_aset(view,
+                                 rb_id2sym(rb_intern("reduce")),
+                                 rb_str_new(view_entry.second.reduce->data(), static_cast<long>(view_entry.second.reduce->size())));
+                }
+                rb_hash_aset(views, view_name, view);
+            }
+            rb_hash_aset(dd, rb_id2sym(rb_intern("views")), views);
+            rb_ary_push(res, dd);
+        }
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_view_index_get(VALUE self, VALUE bucket_name, VALUE document_name, VALUE name_space, VALUE timeout)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
+
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    Check_Type(bucket_name, T_STRING);
+    Check_Type(document_name, T_STRING);
+    Check_Type(name_space, T_SYMBOL);
+
+    couchbase::operations::design_document::name_space ns;
+    ID type = rb_sym2id(name_space);
+    if (type == rb_intern("development")) {
+        ns = couchbase::operations::design_document::name_space::development;
+    } else if (type == rb_intern("production")) {
+        ns = couchbase::operations::design_document::name_space::production;
+    } else {
+        rb_raise(rb_eArgError, "Unknown design document namespace: %+" PRIsVALUE, type);
+    }
+
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::view_index_get_request req{};
+        req.bucket_name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
+        req.document_name.assign(RSTRING_PTR(document_name), static_cast<size_t>(RSTRING_LEN(document_name)));
+        req.name_space = ns;
+        cb__extract_timeout(req, timeout);
+        auto barrier = std::make_shared<std::promise<couchbase::operations::view_index_get_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::view_index_get_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(
+              resp.ec,
+              fmt::format(R"(unable to get design document "{}" ({}) on bucket "{}")", req.document_name, req.name_space, req.bucket_name));
+            break;
+        }
+        VALUE res = rb_hash_new();
+        rb_hash_aset(
+          res, rb_id2sym(rb_intern("name")), rb_str_new(resp.document.name.data(), static_cast<long>(resp.document.name.size())));
+        rb_hash_aset(res, rb_id2sym(rb_intern("rev")), rb_str_new(resp.document.rev.data(), static_cast<long>(resp.document.rev.size())));
+        switch (resp.document.ns) {
+            case couchbase::operations::design_document::name_space::development:
+                rb_hash_aset(res, rb_id2sym(rb_intern("namespace")), rb_id2sym(rb_intern("development")));
+                break;
+            case couchbase::operations::design_document::name_space::production:
+                rb_hash_aset(res, rb_id2sym(rb_intern("namespace")), rb_id2sym(rb_intern("production")));
+                break;
+        }
+        VALUE views = rb_hash_new();
+        for (const auto& view_entry : resp.document.views) {
+            VALUE view_name = rb_str_new(view_entry.first.data(), static_cast<long>(view_entry.first.size()));
+            VALUE view = rb_hash_new();
+            rb_hash_aset(view, rb_id2sym(rb_intern("name")), view_name);
+            if (view_entry.second.map) {
+                rb_hash_aset(view,
+                             rb_id2sym(rb_intern("map")),
+                             rb_str_new(view_entry.second.map->data(), static_cast<long>(view_entry.second.map->size())));
+            }
+            if (view_entry.second.reduce) {
+                rb_hash_aset(view,
+                             rb_id2sym(rb_intern("reduce")),
+                             rb_str_new(view_entry.second.reduce->data(), static_cast<long>(view_entry.second.reduce->size())));
+            }
+            rb_hash_aset(views, view_name, view);
+        }
+        rb_hash_aset(res, rb_id2sym(rb_intern("views")), views);
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_view_index_drop(VALUE self, VALUE bucket_name, VALUE document_name, VALUE name_space, VALUE timeout)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
+
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    Check_Type(bucket_name, T_STRING);
+    Check_Type(document_name, T_STRING);
+    Check_Type(name_space, T_SYMBOL);
+
+    couchbase::operations::design_document::name_space ns;
+    ID type = rb_sym2id(name_space);
+    if (type == rb_intern("development")) {
+        ns = couchbase::operations::design_document::name_space::development;
+    } else if (type == rb_intern("production")) {
+        ns = couchbase::operations::design_document::name_space::production;
+    } else {
+        rb_raise(rb_eArgError, "Unknown design document namespace: %+" PRIsVALUE, type);
+    }
+
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::view_index_drop_request req{};
+        req.bucket_name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
+        req.document_name.assign(RSTRING_PTR(document_name), static_cast<size_t>(RSTRING_LEN(document_name)));
+        req.name_space = ns;
+        cb__extract_timeout(req, timeout);
+        auto barrier = std::make_shared<std::promise<couchbase::operations::view_index_drop_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::view_index_drop_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(
+              resp.ec,
+              fmt::format(
+                R"(unable to drop design document "{}" ({}) on bucket "{}")", req.document_name, req.name_space, req.bucket_name));
+            break;
+        }
+        return Qtrue;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_view_index_upsert(VALUE self, VALUE bucket_name, VALUE document, VALUE name_space, VALUE timeout)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
+
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    Check_Type(bucket_name, T_STRING);
+    Check_Type(document, T_HASH);
+    Check_Type(name_space, T_SYMBOL);
+
+    couchbase::operations::design_document::name_space ns;
+    ID type = rb_sym2id(name_space);
+    if (type == rb_intern("development")) {
+        ns = couchbase::operations::design_document::name_space::development;
+    } else if (type == rb_intern("production")) {
+        ns = couchbase::operations::design_document::name_space::production;
+    } else {
+        rb_raise(rb_eArgError, "Unknown design document namespace: %+" PRIsVALUE, type);
+    }
+
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::view_index_upsert_request req{};
+        req.bucket_name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
+        req.document.ns = ns;
+        VALUE document_name = rb_hash_aref(document, rb_id2sym(rb_intern("name")));
+        if (!NIL_P(document_name)) {
+            Check_Type(document_name, T_STRING);
+            req.document.name.assign(RSTRING_PTR(document_name), static_cast<size_t>(RSTRING_LEN(document_name)));
+        }
+        VALUE views = rb_hash_aref(document, rb_id2sym(rb_intern("views")));
+        if (!NIL_P(views)) {
+            Check_Type(views, T_ARRAY);
+            auto entries_num = static_cast<size_t>(RARRAY_LEN(views));
+            for (size_t i = 0; i < entries_num; ++i) {
+                VALUE entry = rb_ary_entry(views, static_cast<long>(i));
+                Check_Type(entry, T_HASH);
+                couchbase::operations::design_document::view view;
+                VALUE name = rb_hash_aref(entry, rb_id2sym(rb_intern("name")));
+                Check_Type(name, T_STRING);
+                view.name.assign(RSTRING_PTR(name), static_cast<std::size_t>(RSTRING_LEN(name)));
+                VALUE map = rb_hash_aref(entry, rb_id2sym(rb_intern("map")));
+                if (!NIL_P(map)) {
+                    view.map.emplace(std::string(RSTRING_PTR(map), static_cast<std::size_t>(RSTRING_LEN(map))));
+                }
+                VALUE reduce = rb_hash_aref(entry, rb_id2sym(rb_intern("reduce")));
+                if (!NIL_P(reduce)) {
+                    view.reduce.emplace(std::string(RSTRING_PTR(reduce), static_cast<std::size_t>(RSTRING_LEN(reduce))));
+                }
+                req.document.views[view.name] = view;
+            }
+        }
+
+        cb__extract_timeout(req, timeout);
+        auto barrier = std::make_shared<std::promise<couchbase::operations::view_index_upsert_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(
+          req, [barrier](couchbase::operations::view_index_upsert_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            exc = cb__map_error_code(
+              resp.ec,
+              fmt::format(
+                R"(unable to store design document "{}" ({}) on bucket "{}")", req.document.name, req.document.ns, req.bucket_name));
+            break;
+        }
+        return Qtrue;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static VALUE
+cb_Backend_document_view(VALUE self, VALUE bucket_name, VALUE design_document_name, VALUE view_name, VALUE name_space, VALUE options)
+{
+    cb_backend_data* backend = nullptr;
+    TypedData_Get_Struct(self, cb_backend_data, &cb_backend_type, backend);
+
+    if (!backend->cluster) {
+        rb_raise(rb_eArgError, "Cluster has been closed already");
+    }
+
+    Check_Type(bucket_name, T_STRING);
+    Check_Type(design_document_name, T_STRING);
+    Check_Type(view_name, T_STRING);
+    Check_Type(name_space, T_SYMBOL);
+    couchbase::operations::design_document::name_space ns;
+    ID type = rb_sym2id(name_space);
+    if (type == rb_intern("development")) {
+        ns = couchbase::operations::design_document::name_space::development;
+    } else if (type == rb_intern("production")) {
+        ns = couchbase::operations::design_document::name_space::production;
+    } else {
+        rb_raise(rb_eArgError, "Unknown design document namespace: %+" PRIsVALUE, type);
+    }
+    if (!NIL_P(options)) {
+        Check_Type(options, T_HASH);
+    }
+
+    VALUE exc = Qnil;
+    do {
+        couchbase::operations::document_view_request req{};
+        req.bucket_name.assign(RSTRING_PTR(bucket_name), static_cast<size_t>(RSTRING_LEN(bucket_name)));
+        req.document_name.assign(RSTRING_PTR(design_document_name), static_cast<size_t>(RSTRING_LEN(design_document_name)));
+        req.view_name.assign(RSTRING_PTR(view_name), static_cast<size_t>(RSTRING_LEN(view_name)));
+        req.name_space = ns;
+        if (!NIL_P(options)) {
+            cb__extract_timeout(req, rb_hash_aref(options, rb_id2sym(rb_intern("timeout"))));
+            VALUE debug = rb_hash_aref(options, rb_id2sym(rb_intern("debug")));
+            if (!NIL_P(debug)) {
+                req.debug = RTEST(debug);
+            }
+            VALUE limit = rb_hash_aref(options, rb_id2sym(rb_intern("limit")));
+            if (!NIL_P(limit)) {
+                Check_Type(limit, T_FIXNUM);
+                req.limit = FIX2ULONG(limit);
+            }
+            VALUE skip = rb_hash_aref(options, rb_id2sym(rb_intern("skip")));
+            if (!NIL_P(skip)) {
+                Check_Type(skip, T_FIXNUM);
+                req.skip = FIX2ULONG(skip);
+            }
+            VALUE scan_consistency = rb_hash_aref(options, rb_id2sym(rb_intern("scan_consistency")));
+            if (!NIL_P(scan_consistency)) {
+                Check_Type(scan_consistency, T_SYMBOL);
+                ID consistency = rb_sym2id(scan_consistency);
+                if (consistency == rb_intern("request_plus")) {
+                    req.consistency = couchbase::operations::document_view_request::scan_consistency::request_plus;
+                } else if (consistency == rb_intern("update_after")) {
+                    req.consistency = couchbase::operations::document_view_request::scan_consistency::update_after;
+                } else if (consistency == rb_intern("not_bounded")) {
+                    req.consistency = couchbase::operations::document_view_request::scan_consistency::not_bounded;
+                }
+            }
+            VALUE key = rb_hash_aref(options, rb_id2sym(rb_intern("key")));
+            if (!NIL_P(key)) {
+                Check_Type(key, T_STRING);
+                req.key.emplace(RSTRING_PTR(key), static_cast<size_t>(RSTRING_LEN(key)));
+            }
+            VALUE start_key = rb_hash_aref(options, rb_id2sym(rb_intern("start_key")));
+            if (!NIL_P(start_key)) {
+                Check_Type(start_key, T_STRING);
+                req.start_key.emplace(RSTRING_PTR(start_key), static_cast<size_t>(RSTRING_LEN(start_key)));
+            }
+            VALUE end_key = rb_hash_aref(options, rb_id2sym(rb_intern("end_key")));
+            if (!NIL_P(end_key)) {
+                Check_Type(end_key, T_STRING);
+                req.end_key.emplace(RSTRING_PTR(end_key), static_cast<size_t>(RSTRING_LEN(end_key)));
+            }
+            VALUE start_key_doc_id = rb_hash_aref(options, rb_id2sym(rb_intern("start_key_doc_id")));
+            if (!NIL_P(start_key_doc_id)) {
+                Check_Type(start_key_doc_id, T_STRING);
+                req.start_key_doc_id.emplace(RSTRING_PTR(start_key_doc_id), static_cast<size_t>(RSTRING_LEN(start_key_doc_id)));
+            }
+            VALUE end_key_doc_id = rb_hash_aref(options, rb_id2sym(rb_intern("end_key_doc_id")));
+            if (!NIL_P(end_key_doc_id)) {
+                Check_Type(end_key_doc_id, T_STRING);
+                req.end_key_doc_id.emplace(RSTRING_PTR(end_key_doc_id), static_cast<size_t>(RSTRING_LEN(end_key_doc_id)));
+            }
+            VALUE inclusive_end = rb_hash_aref(options, rb_id2sym(rb_intern("inclusive_end")));
+            if (!NIL_P(inclusive_end)) {
+                req.inclusive_end = RTEST(inclusive_end);
+            }
+            VALUE reduce = rb_hash_aref(options, rb_id2sym(rb_intern("reduce")));
+            if (!NIL_P(reduce)) {
+                req.reduce = RTEST(reduce);
+            }
+            VALUE group = rb_hash_aref(options, rb_id2sym(rb_intern("group")));
+            if (!NIL_P(group)) {
+                req.group = RTEST(group);
+            }
+            VALUE group_level = rb_hash_aref(options, rb_id2sym(rb_intern("group_level")));
+            if (!NIL_P(group_level)) {
+                Check_Type(group_level, T_FIXNUM);
+                req.group_level = FIX2ULONG(group_level);
+            }
+            VALUE sort_order = rb_hash_aref(options, rb_id2sym(rb_intern("order")));
+            if (!NIL_P(sort_order)) {
+                Check_Type(sort_order, T_SYMBOL);
+                ID order = rb_sym2id(sort_order);
+                if (order == rb_intern("ascending")) {
+                    req.order = couchbase::operations::document_view_request::sort_order::ascending;
+                } else if (order == rb_intern("descending")) {
+                    req.order = couchbase::operations::document_view_request::sort_order::descending;
+                }
+            }
+            VALUE keys = rb_hash_aref(options, rb_id2sym(rb_intern("keys")));
+            if (!NIL_P(keys)) {
+                Check_Type(keys, T_ARRAY);
+                auto entries_num = static_cast<size_t>(RARRAY_LEN(keys));
+                req.keys.reserve(entries_num);
+                for (size_t i = 0; i < entries_num; ++i) {
+                    VALUE entry = rb_ary_entry(keys, static_cast<long>(i));
+                    Check_Type(entry, T_STRING);
+                    req.keys.emplace_back(std::string(RSTRING_PTR(entry), static_cast<std::size_t>(RSTRING_LEN(entry))));
+                }
+            }
+        }
+
+        auto barrier = std::make_shared<std::promise<couchbase::operations::document_view_response>>();
+        auto f = barrier->get_future();
+        backend->cluster->execute_http(req,
+                                       [barrier](couchbase::operations::document_view_response resp) mutable { barrier->set_value(resp); });
+        auto resp = f.get();
+        if (resp.ec) {
+            if (resp.error) {
+                exc = cb__map_error_code(
+                  resp.ec,
+                  fmt::format(R"(unable to execute query for view "{}" of design document "{}" ({}) on bucket "{}": {} ({}))",
+                              req.view_name,
+                              req.document_name,
+                              req.name_space,
+                              req.bucket_name,
+                              resp.error->code,
+                              resp.error->message));
+            } else {
+                exc = cb__map_error_code(resp.ec,
+                                         fmt::format(R"(unable to execute query for view "{}" of design document "{}" ({}) on bucket "{}")",
+                                                     req.view_name,
+                                                     req.document_name,
+                                                     req.name_space,
+                                                     req.bucket_name));
+            }
+            break;
+        }
+        VALUE res = rb_hash_new();
+
+        VALUE meta = rb_hash_new();
+        if (resp.meta_data.total_rows) {
+            rb_hash_aset(meta, rb_id2sym(rb_intern("total_rows")), ULL2NUM(*resp.meta_data.total_rows));
+        }
+        if (resp.meta_data.debug_info) {
+            rb_hash_aset(meta,
+                         rb_id2sym(rb_intern("debug_info")),
+                         rb_str_new(resp.meta_data.debug_info->data(), static_cast<long>(resp.meta_data.debug_info->size())));
+        }
+        rb_hash_aset(res, rb_id2sym(rb_intern("meta")), meta);
+
+        VALUE rows = rb_ary_new_capa(static_cast<long>(resp.rows.size()));
+        for (const auto& entry : resp.rows) {
+            VALUE row = rb_hash_new();
+            if (entry.id) {
+                rb_hash_aset(row, rb_id2sym(rb_intern("id")), rb_str_new(entry.id->data(), static_cast<long>(entry.id->size())));
+            }
+            rb_hash_aset(row, rb_id2sym(rb_intern("key")), rb_str_new(entry.key.data(), static_cast<long>(entry.key.size())));
+            rb_hash_aset(row, rb_id2sym(rb_intern("value")), rb_str_new(entry.value.data(), static_cast<long>(entry.value.size())));
+            rb_ary_push(rows, row);
+        }
+        rb_hash_aset(res, rb_id2sym(rb_intern("rows")), rows);
+
+        return res;
+    } while (false);
+    rb_exc_raise(exc);
+    return Qnil;
+}
+
+static void
+init_backend(VALUE mCouchbase)
+{
+    VALUE cBackend = rb_define_class_under(mCouchbase, "Backend", rb_cBasicObject);
+    rb_define_alloc_func(cBackend, cb_Backend_allocate);
+    rb_define_method(cBackend, "open", VALUE_FUNC(cb_Backend_open), 3);
+    rb_define_method(cBackend, "close", VALUE_FUNC(cb_Backend_close), 0);
+    rb_define_method(cBackend, "open_bucket", VALUE_FUNC(cb_Backend_open_bucket), 1);
+
+    rb_define_method(cBackend, "document_get", VALUE_FUNC(cb_Backend_document_get), 4);
+    rb_define_method(cBackend, "document_get_projected", VALUE_FUNC(cb_Backend_document_get_projected), 7);
+    rb_define_method(cBackend, "document_get_and_lock", VALUE_FUNC(cb_Backend_document_get_and_lock), 5);
+    rb_define_method(cBackend, "document_get_and_touch", VALUE_FUNC(cb_Backend_document_get_and_touch), 5);
+    rb_define_method(cBackend, "document_insert", VALUE_FUNC(cb_Backend_document_insert), 7);
+    rb_define_method(cBackend, "document_replace", VALUE_FUNC(cb_Backend_document_replace), 7);
+    rb_define_method(cBackend, "document_upsert", VALUE_FUNC(cb_Backend_document_upsert), 7);
+    rb_define_method(cBackend, "document_remove", VALUE_FUNC(cb_Backend_document_remove), 5);
+    rb_define_method(cBackend, "document_lookup_in", VALUE_FUNC(cb_Backend_document_lookup_in), 6);
+    rb_define_method(cBackend, "document_mutate_in", VALUE_FUNC(cb_Backend_document_mutate_in), 7);
+    rb_define_method(cBackend, "document_query", VALUE_FUNC(cb_Backend_document_query), 2);
+    rb_define_method(cBackend, "document_touch", VALUE_FUNC(cb_Backend_document_touch), 5);
+    rb_define_method(cBackend, "document_exists", VALUE_FUNC(cb_Backend_document_exists), 4);
+    rb_define_method(cBackend, "document_unlock", VALUE_FUNC(cb_Backend_document_unlock), 5);
+    rb_define_method(cBackend, "document_increment", VALUE_FUNC(cb_Backend_document_increment), 5);
+    rb_define_method(cBackend, "document_decrement", VALUE_FUNC(cb_Backend_document_decrement), 5);
+    rb_define_method(cBackend, "document_search", VALUE_FUNC(cb_Backend_document_search), 3);
+    rb_define_method(cBackend, "document_analytics", VALUE_FUNC(cb_Backend_document_analytics), 2);
+    rb_define_method(cBackend, "document_view", VALUE_FUNC(cb_Backend_document_view), 5);
+
+    rb_define_method(cBackend, "bucket_create", VALUE_FUNC(cb_Backend_bucket_create), 2);
+    rb_define_method(cBackend, "bucket_update", VALUE_FUNC(cb_Backend_bucket_update), 2);
+    rb_define_method(cBackend, "bucket_drop", VALUE_FUNC(cb_Backend_bucket_drop), 2);
+    rb_define_method(cBackend, "bucket_flush", VALUE_FUNC(cb_Backend_bucket_flush), 2);
+    rb_define_method(cBackend, "bucket_get_all", VALUE_FUNC(cb_Backend_bucket_get_all), 1);
+    rb_define_method(cBackend, "bucket_get", VALUE_FUNC(cb_Backend_bucket_get), 2);
+
+    rb_define_method(cBackend, "cluster_enable_developer_preview!", VALUE_FUNC(cb_Backend_cluster_enable_developer_preview), 0);
+
+    rb_define_method(cBackend, "scope_get_all", VALUE_FUNC(cb_Backend_scope_get_all), 2);
+    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_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);
+    rb_define_method(cBackend, "query_index_create", VALUE_FUNC(cb_Backend_query_index_create), 5);
+    rb_define_method(cBackend, "query_index_create_primary", VALUE_FUNC(cb_Backend_query_index_create_primary), 3);
+    rb_define_method(cBackend, "query_index_drop", VALUE_FUNC(cb_Backend_query_index_drop), 4);
+    rb_define_method(cBackend, "query_index_drop_primary", VALUE_FUNC(cb_Backend_query_index_drop_primary), 3);
+    rb_define_method(cBackend, "query_index_build_deferred", VALUE_FUNC(cb_Backend_query_index_build_deferred), 2);
+    rb_define_method(cBackend, "query_index_watch", VALUE_FUNC(cb_Backend_query_index_watch), 4);
+
+    rb_define_method(cBackend, "search_index_get_all", VALUE_FUNC(cb_Backend_search_index_get_all), 1);
+    rb_define_method(cBackend, "search_index_get", VALUE_FUNC(cb_Backend_search_index_get), 2);
+    rb_define_method(cBackend, "search_index_upsert", VALUE_FUNC(cb_Backend_search_index_upsert), 2);
+    rb_define_method(cBackend, "search_index_drop", VALUE_FUNC(cb_Backend_search_index_drop), 2);
+    rb_define_method(cBackend, "search_index_get_documents_count", VALUE_FUNC(cb_Backend_search_index_get_documents_count), 2);
+    rb_define_method(cBackend, "search_index_pause_ingest", VALUE_FUNC(cb_Backend_search_index_pause_ingest), 2);
+    rb_define_method(cBackend, "search_index_resume_ingest", VALUE_FUNC(cb_Backend_search_index_resume_ingest), 2);
+    rb_define_method(cBackend, "search_index_allow_querying", VALUE_FUNC(cb_Backend_search_index_allow_querying), 2);
+    rb_define_method(cBackend, "search_index_disallow_querying", VALUE_FUNC(cb_Backend_search_index_disallow_querying), 2);
+    rb_define_method(cBackend, "search_index_freeze_plan", VALUE_FUNC(cb_Backend_search_index_freeze_plan), 2);
+    rb_define_method(cBackend, "search_index_unfreeze_plan", VALUE_FUNC(cb_Backend_search_index_unfreeze_plan), 2);
+    rb_define_method(cBackend, "search_index_analyze_document", VALUE_FUNC(cb_Backend_search_index_analyze_document), 3);
+
+    rb_define_method(cBackend, "analytics_get_pending_mutations", VALUE_FUNC(cb_Backend_analytics_get_pending_mutations), 1);
+    rb_define_method(cBackend, "analytics_dataverse_drop", VALUE_FUNC(cb_Backend_analytics_dataverse_drop), 3);
+    rb_define_method(cBackend, "analytics_dataverse_create", VALUE_FUNC(cb_Backend_analytics_dataverse_create), 3);
+    rb_define_method(cBackend, "analytics_dataset_create", VALUE_FUNC(cb_Backend_analytics_dataset_create), 6);
+    rb_define_method(cBackend, "analytics_dataset_drop", VALUE_FUNC(cb_Backend_analytics_dataset_drop), 4);
+    rb_define_method(cBackend, "analytics_dataset_get_all", VALUE_FUNC(cb_Backend_analytics_dataset_get_all), 1);
+    rb_define_method(cBackend, "analytics_index_get_all", VALUE_FUNC(cb_Backend_analytics_index_get_all), 1);
+    rb_define_method(cBackend, "analytics_index_create", VALUE_FUNC(cb_Backend_analytics_index_create), 6);
+    rb_define_method(cBackend, "analytics_index_drop", VALUE_FUNC(cb_Backend_analytics_index_drop), 5);
+    rb_define_method(cBackend, "analytics_link_connect", VALUE_FUNC(cb_Backend_analytics_link_connect), 4);
+    rb_define_method(cBackend, "analytics_link_disconnect", VALUE_FUNC(cb_Backend_analytics_link_disconnect), 3);
+
+    rb_define_method(cBackend, "view_index_get_all", VALUE_FUNC(cb_Backend_view_index_get_all), 3);
+    rb_define_method(cBackend, "view_index_get", VALUE_FUNC(cb_Backend_view_index_get), 4);
+    rb_define_method(cBackend, "view_index_drop", VALUE_FUNC(cb_Backend_view_index_drop), 4);
+    rb_define_method(cBackend, "view_index_upsert", VALUE_FUNC(cb_Backend_view_index_upsert), 4);
+
+    rb_define_singleton_method(cBackend, "dns_srv", VALUE_FUNC(cb_Backend_dns_srv), 2);
+    rb_define_singleton_method(cBackend, "parse_connection_string", VALUE_FUNC(cb_Backend_parse_connection_string), 1);
 }
 
 extern "C" {