couchbase 3.4.1 → 3.4.3

data/ext/couchbase/third_party/snappy/snappy.h

@@ -39,7 +39,9 @@
 #ifndef THIRD_PARTY_SNAPPY_SNAPPY_H__
 #define THIRD_PARTY_SNAPPY_SNAPPY_H__
 
-#include <cstddef>
+#include <stddef.h>
+#include <stdint.h>
+
 #include <string>
 
 #include "snappy-stubs-public.h"
@@ -63,20 +65,27 @@ namespace snappy {
   // Also note that this leaves "*source" in a state that is unsuitable for
   // further operations, such as RawUncompress(). You will need to rewind
   // or recreate the source yourself before attempting any further calls.
-  bool GetUncompressedLength(Source* source, uint32* result);
+  bool GetUncompressedLength(Source* source, uint32_t* result);
 
   // ------------------------------------------------------------------------
   // Higher-level string based routines (should be sufficient for most users)
   // ------------------------------------------------------------------------
 
-  // Sets "*compressed" to the compressed version of "input[0,input_length-1]".
+  // Sets "*compressed" to the compressed version of "input[0..input_length-1]".
   // Original contents of *compressed are lost.
   //
   // REQUIRES: "input[]" is not an alias of "*compressed".
   size_t Compress(const char* input, size_t input_length,
                   std::string* compressed);
 
-  // Decompresses "compressed[0,compressed_length-1]" to "*uncompressed".
+  // Same as `Compress` above but taking an `iovec` array as input. Note that
+  // this function preprocesses the inputs to compute the sum of
+  // `iov[0..iov_cnt-1].iov_len` before reading. To avoid this, use
+  // `RawCompressFromIOVec` below.
+  size_t CompressFromIOVec(const struct iovec* iov, size_t iov_cnt,
+                           std::string* compressed);
+
+  // Decompresses "compressed[0..compressed_length-1]" to "*uncompressed".
   // Original contents of "*uncompressed" are lost.
   //
   // REQUIRES: "compressed[]" is not an alias of "*uncompressed".
@@ -122,6 +131,12 @@ namespace snappy {
                    char* compressed,
                    size_t* compressed_length);
 
+  // Same as `RawCompress` above but taking an `iovec` array as input. Note that
+  // `uncompressed_length` is the total number of bytes to be read from the
+  // elements of `iov` (_not_ the number of elements in `iov`).
+  void RawCompressFromIOVec(const struct iovec* iov, size_t uncompressed_length,
+                            char* compressed, size_t* compressed_length);
+
   // Given data in "compressed[0..compressed_length-1]" generated by
   // calling the Snappy::Compress routine, this routine
   // stores the uncompressed data to

data/ext/couchbase.cxx

@@ -270,9 +270,9 @@ init_versions(VALUE mCouchbase)
     VALUE cb_CoreInfo = rb_hash_new();
     for (const auto& [name, value] : couchbase::core::meta::sdk_build_info()) {
         if (name == "version_major" || name == "version_minor" || name == "version_patch" || name == "version_build" ||
-            name == "__cplusplus" || name == "_MSC_VER") {
+            name == "__cplusplus" || name == "_MSC_VER" || name == "mozilla_ca_bundle_size") {
             rb_hash_aset(cb_CoreInfo, rb_id2sym(rb_intern(name.c_str())), INT2FIX(std::stoi(value)));
-        } else if (name == "snapshot" || name == "static_stdlib" || name == "static_openssl") {
+        } else if (name == "snapshot" || name == "static_stdlib" || name == "static_openssl" || name == "mozilla_ca_bundle_embedded") {
             rb_hash_aset(cb_CoreInfo, rb_id2sym(rb_intern(name.c_str())), value == "true" ? Qtrue : Qfalse);
         } else {
             rb_hash_aset(cb_CoreInfo, rb_id2sym(rb_intern(name.c_str())), rb_str_freeze(rb_str_new_cstr(value.c_str())));
@@ -1253,9 +1253,7 @@ cb_map_error_code(const couchbase::core::error_context::search& ctx, const std::
     rb_hash_aset(error_context, rb_id2sym(rb_intern("error")), cb_str_new(error));
     rb_hash_aset(error_context, rb_id2sym(rb_intern("client_context_id")), cb_str_new(ctx.client_context_id));
     rb_hash_aset(error_context, rb_id2sym(rb_intern("index_name")), cb_str_new(ctx.index_name));
-    if (ctx.query) {
-        rb_hash_aset(error_context, rb_id2sym(rb_intern("query")), cb_str_new(ctx.query.value()));
-    }
+    rb_hash_aset(error_context, rb_id2sym(rb_intern("query")), cb_str_new(ctx.query));
     if (ctx.parameters) {
         rb_hash_aset(error_context, rb_id2sym(rb_intern("parameters")), cb_str_new(ctx.parameters.value()));
     }
@@ -1592,7 +1590,7 @@ extract_durability_level(VALUE options)
     if (VALUE val = rb_hash_aref(options, property_name); !NIL_P(val)) {
         ID level = rb_sym2id(val);
         if (level == rb_intern("none")) {
-            return couchbase::durability_level::none;
+            return {};
         }
         if (level == rb_intern("majority")) {
             return couchbase::durability_level::majority;
@@ -1615,7 +1613,7 @@ extract_legacy_durability_persist_to(VALUE options)
     if (VALUE val = rb_hash_aref(options, property_name); !NIL_P(val)) {
         ID mode = rb_sym2id(val);
         if (mode == rb_intern("none")) {
-            return couchbase::persist_to::none;
+            return {};
         }
         if (mode == rb_intern("active")) {
             return couchbase::persist_to::active;
@@ -1644,7 +1642,7 @@ extract_legacy_durability_replicate_to(VALUE options)
     if (VALUE val = rb_hash_aref(options, property_name); !NIL_P(val)) {
         ID mode = rb_sym2id(val);
         if (mode == rb_intern("none")) {
-            return couchbase::replicate_to::none;
+            return {};
         }
         if (mode == rb_intern("one")) {
             return couchbase::replicate_to::one;
@@ -1799,8 +1797,9 @@ cb_extract_cas(couchbase::cas& field, VALUE cas)
     }
 }
 
+template<typename Boolean>
 static void
-cb_extract_option_bool(bool& field, VALUE options, const char* name)
+cb_extract_option_bool(Boolean& field, VALUE options, const char* name)
 {
     if (!NIL_P(options) && TYPE(options) == T_HASH) {
         VALUE val = rb_hash_aref(options, rb_id2sym(rb_intern(name)));
@@ -1820,8 +1819,9 @@ cb_extract_option_bool(bool& field, VALUE options, const char* name)
     }
 }
 
+template<typename Integer>
 static void
-cb_extract_option_number(std::size_t& field, VALUE options, const char* name)
+cb_extract_option_number(Integer& field, VALUE options, const char* name)
 {
     if (!NIL_P(options) && TYPE(options) == T_HASH) {
         VALUE val = rb_hash_aref(options, rb_id2sym(rb_intern(name)));
@@ -1830,10 +1830,10 @@ cb_extract_option_number(std::size_t& field, VALUE options, const char* name)
         }
         switch (TYPE(val)) {
             case T_FIXNUM:
-                field = FIX2ULONG(val);
+                field = static_cast<Integer>(FIX2ULONG(val));
                 break;
             case T_BIGNUM:
-                field = NUM2ULL(val);
+                field = static_cast<Integer>(NUM2ULL(val));
                 break;
             default:
                 throw ruby_exception(rb_eArgError, rb_sprintf("%s must be a Integer, but given %+" PRIsVALUE, name, val));
@@ -1884,6 +1884,25 @@ cb_extract_option_string(std::string& target, VALUE options, const char* name);
 static void
 cb_extract_option_symbol(VALUE& val, VALUE options, const char* name);
 
+static void
+cb_extract_dns_config(couchbase::core::io::dns::dns_config& config, VALUE options)
+{
+    if (!NIL_P(options) && TYPE(options) == T_HASH) {
+        return;
+    }
+
+    auto timeout{ couchbase::core::timeout_defaults::dns_srv_timeout };
+    cb_extract_option_milliseconds(timeout, options, "dns_srv_timeout");
+
+    std::string nameserver{ couchbase::core::io::dns::dns_config::default_nameserver };
+    cb_extract_option_string(nameserver, options, "dns_srv_nameserver");
+
+    std::uint16_t port{ couchbase::core::io::dns::dns_config::default_port };
+    cb_extract_option_number(port, options, "dns_srv_port");
+
+    config = couchbase::core::io::dns::dns_config(nameserver, port, timeout);
+}
+
 static VALUE
 cb_Backend_open(VALUE self, VALUE connection_string, VALUE credentials, VALUE options)
 {
@@ -1983,13 +2002,14 @@ cb_Backend_open(VALUE self, VALUE connection_string, VALUE credentials, VALUE op
         cb_extract_option_milliseconds(origin.options().analytics_timeout, options, "analytics_timeout");
         cb_extract_option_milliseconds(origin.options().search_timeout, options, "search_timeout");
         cb_extract_option_milliseconds(origin.options().management_timeout, options, "management_timeout");
-        cb_extract_option_milliseconds(origin.options().dns_srv_timeout, options, "dns_srv_timeout");
         cb_extract_option_milliseconds(origin.options().tcp_keep_alive_interval, options, "tcp_keep_alive_interval");
         cb_extract_option_milliseconds(origin.options().config_poll_interval, options, "config_poll_interval");
         cb_extract_option_milliseconds(origin.options().config_poll_floor, options, "config_poll_floor");
         cb_extract_option_milliseconds(origin.options().config_idle_redial_timeout, options, "config_idle_redial_timeout");
         cb_extract_option_milliseconds(origin.options().idle_http_connection_timeout, options, "idle_http_connection_timeout");
 
+        cb_extract_dns_config(origin.options().dns_config, options);
+
         cb_extract_option_number(origin.options().max_http_connections, options, "max_http_connections");
 
         cb_extract_option_bool(origin.options().enable_tls, options, "enable_tls");
@@ -5069,6 +5089,14 @@ cb_Backend_query_index_get_all(VALUE self, VALUE bucket_name, VALUE options)
         couchbase::core::operations::management::query_index_get_all_request req{};
         req.bucket_name = cb_string_new(bucket_name);
         cb_extract_timeout(req, options);
+        if (!NIL_P(options)) {
+            if (VALUE scope_name = rb_hash_aref(options, rb_id2sym(rb_intern("scope_name"))); TYPE(scope_name) == T_STRING) {
+                req.scope_name = cb_string_new(scope_name);
+            }
+            if (VALUE collection_name = rb_hash_aref(options, rb_id2sym(rb_intern("collection_name"))); TYPE(collection_name) == T_STRING) {
+                req.collection_name = cb_string_new(collection_name);
+            }
+        }
         auto barrier = std::make_shared<std::promise<couchbase::core::operations::management::query_index_get_all_response>>();
         auto f = barrier->get_future();
         cluster->execute(req, [barrier](couchbase::core::operations::management::query_index_get_all_response&& resp) {
@@ -5445,15 +5473,50 @@ cb_Backend_query_index_build_deferred(VALUE self, VALUE bucket_name, VALUE optio
     }
 
     try {
-        couchbase::build_query_index_options opts;
-        couchbase::ruby::set_timeout(opts, options);
-        auto bucket = cb_string_new(bucket_name);
+        couchbase::core::operations::management::query_index_build_deferred_request req{};
+        cb_extract_timeout(req, options);
+        req.bucket_name = cb_string_new(bucket_name);
+
+        if (!NIL_P(options)) {
+            if (VALUE scope_name = rb_hash_aref(options, rb_id2sym(rb_intern("scope_name"))); TYPE(scope_name) == T_STRING) {
+                req.scope_name = cb_string_new(scope_name);
+            }
+            if (VALUE collection_name = rb_hash_aref(options, rb_id2sym(rb_intern("collection_name"))); TYPE(collection_name) == T_STRING) {
+                req.collection_name = cb_string_new(collection_name);
+            }
+        }
 
-        auto f = couchbase::cluster(cluster).query_indexes().build_deferred_indexes(bucket, opts);
-        if (auto ctx = cb_wait_for_future(f); ctx.ec()) {
-            cb_throw_error_code(ctx, fmt::format("unable to trigger build for deferred indexes for the bucket \"{}\"", bucket));
+        auto barrier = std::make_shared<std::promise<couchbase::core::operations::management::query_index_build_deferred_response>>();
+        auto f = barrier->get_future();
+        cluster->execute(req, [barrier](couchbase::core::operations::management::query_index_build_deferred_response&& resp) {
+            barrier->set_value(std::move(resp));
+        });
+        auto resp = cb_wait_for_future(f);
+        if (resp.ctx.ec) {
+            if (!resp.errors.empty()) {
+                const auto& first_error = resp.errors.front();
+                cb_throw_error_code(resp.ctx,
+                                    fmt::format(R"(unable to build deferred indexes on the bucket "{}" ({}: {}))",
+                                                req.bucket_name,
+                                                first_error.code,
+                                                first_error.message));
+            } else {
+                cb_throw_error_code(resp.ctx, fmt::format(R"(unable to build deferred indexes on the bucket "{}")", req.bucket_name));
+            }
         }
-        return Qtrue;
+        VALUE res = rb_hash_new();
+        rb_hash_aset(res, rb_id2sym(rb_intern("status")), cb_str_new(resp.status));
+        if (!resp.errors.empty()) {
+            VALUE errors = rb_ary_new_capa(static_cast<long>(resp.errors.size()));
+            for (const auto& err : resp.errors) {
+                VALUE error = rb_hash_new();
+                rb_hash_aset(error, rb_id2sym(rb_intern("code")), ULL2NUM(err.code));
+                rb_hash_aset(error, rb_id2sym(rb_intern("message")), cb_str_new(err.message));
+                rb_ary_push(errors, error);
+            }
+            rb_hash_aset(res, rb_id2sym(rb_intern("errors")), errors);
+        }
+        return res;
     } 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) {
@@ -6819,12 +6882,12 @@ cb_Backend_dns_srv(VALUE self, VALUE hostname, VALUE service)
         if (tls) {
             service_name = "_couchbases";
         }
-        auto barrier = std::make_shared<std::promise<couchbase::core::io::dns::dns_client::dns_srv_response>>();
+        auto barrier = std::make_shared<std::promise<couchbase::core::io::dns::dns_srv_response>>();
         auto f = barrier->get_future();
         client.query_srv(host_name,
                          service_name,
                          couchbase::core::io::dns::dns_config::system_config(),
-                         [barrier](couchbase::core::io::dns::dns_client::dns_srv_response&& resp) { barrier->set_value(std::move(resp)); });
+                         [barrier](couchbase::core::io::dns::dns_srv_response&& resp) { barrier->set_value(std::move(resp)); });
         ctx.run();
         auto resp = cb_wait_for_future(f);
         if (resp.ec) {

data/ext/revisions.rb

@@ -1,3 +1,3 @@
-cmake_flags << "-DEXT_GIT_REVISION=97ca42af94afb27b75d35a1f5ea5414a562036a5"
-cmake_flags << "-DCOUCHBASE_CXX_CLIENT_GIT_REVISION=b895551ebe99164be6e633e21147296cd7241c34"
-cmake_flags << "-DCOUCHBASE_CXX_CLIENT_GIT_DESCRIBE=1.0.0-dp.4-10-gb895551"
+cmake_flags << "-DEXT_GIT_REVISION=ef79cc86f921face060319b31c7cacbecfdefaa6"
+cmake_flags << "-DCOUCHBASE_CXX_CLIENT_GIT_REVISION=2c6a065499329f39963cc3a45c87f58c6bea5f28"
+cmake_flags << "-DCOUCHBASE_CXX_CLIENT_GIT_DESCRIBE=1.0.0-dp.5-0-g2c6a065"

data/lib/couchbase/authenticator.rb

@@ -28,7 +28,6 @@ module Couchbase
     def initialize(username, password)
       @username = username
       @password = password
-      @allowed_sasl_mechanisms = DEFAULT_SASL_MECHANISMS
     end
 
     # Creates a LDAP compatible password authenticator which is INSECURE if not used with TLS.

data/lib/couchbase/cluster.rb

@@ -32,13 +32,13 @@ module Couchbase
 
     # Connect to the Couchbase cluster
     #
-    # @overload connect(connection_string, options)
-    #   @param [String] connection_string connection string used to locate the Couchbase Cluster
+    # @overload connect(connection_string_or_config, options)
+    #   @param [String, Configuration] connection_string_or_config connection string used to locate the Couchbase Cluster
     #   @param [Options::Cluster] options custom options when creating the cluster connection
     #
-    # @overload connect(connection_string, username, password, options)
+    # @overload connect(connection_string_or_config, username, password, options)
     #   Shortcut for {PasswordAuthenticator}
-    #   @param [String] connection_string connection string used to locate the Couchbase Cluster
+    #   @param [String] connection_string_or_config connection string used to locate the Couchbase Cluster
     #   @param [String] username name of the user
     #   @param [String] password password of the user
     #   @param [Options::Cluster, nil] options custom options when creating the cluster connection
@@ -62,12 +62,16 @@ module Couchbase
     # @see https://docs.couchbase.com/server/current/manage/manage-security/configure-client-certificates.html
     #
     # @return [Cluster]
-    def self.connect(connection_string, *options)
-      regexp = /^((couchbases?|http):\/\/.*)$/i
-      if regexp.match?(connection_string) || !connection_string.include?("://")
-        Cluster.new(connection_string, *options)
+    def self.connect(connection_string_or_config, *options)
+      connection_string = if connection_string_or_config.is_a?(Configuration)
+                            connection_string_or_config.connection_string
+                          else
+                            connection_string_or_config
+                          end
+      if connection_string =~ /\Acouchbases?:\/\/.*\z/i || !connection_string.include?("://")
+        Cluster.new(connection_string_or_config, *options)
       else
-        ClusterRegistry.instance.connect(connection_string, *options)
+        ClusterRegistry.instance.connect(connection_string_or_config, *options)
       end
     end
 
@@ -382,8 +386,6 @@ module Couchbase
         raise ArgumentError, "missing connection_string" unless connection_string
         raise ArgumentError, "missing username" unless credentials[:username]
         raise ArgumentError, "missing password" unless credentials[:password]
-
-        open_options[:allowed_sasl_mechanisms] = PasswordAuthenticator::DEFAULT_SASL_MECHANISMS
       else
         options = args.shift
         case options
@@ -392,8 +394,6 @@ module Couchbase
           credentials[:password] = args.shift
           raise ArgumentError, "missing username" unless credentials[:username]
           raise ArgumentError, "missing password" unless credentials[:password]
-
-          open_options[:allowed_sasl_mechanisms] = PasswordAuthenticator::DEFAULT_SASL_MECHANISMS
         when Options::Cluster
           open_options = options&.to_backend || {}
           authenticator = options&.authenticator

data/lib/couchbase/cluster_registry.rb

@@ -26,9 +26,14 @@ module Couchbase
       @handlers = {}
     end
 
-    def connect(connection_string, *options)
+    def connect(connection_string_or_config, *options)
+      connection_string = if connection_string_or_config.is_a?(Configuration)
+                            connection_string_or_config.connection_string
+                          else
+                            connection_string_or_config
+                          end
       @handlers.each do |regexp, cluster_class|
-        return cluster_class.connect(connection_string, *options) if regexp.match?(connection_string)
+        return cluster_class.connect(connection_string_or_config, *options) if regexp.match?(connection_string)
       end
       raise(Error::FeatureNotAvailable, "Connection string '#{connection_string}' not supported.")
     end

data/lib/couchbase/config_profiles.rb

@@ -15,7 +15,7 @@
 module Couchbase
   module ConfigProfiles
     class Profiles
-      attr :profiles
+      attr_reader :profiles
 
       def initialize
         @profiles = {}

data/lib/couchbase/configuration.rb

@@ -33,10 +33,9 @@ module Couchbase
     private
 
     def load_configuration(settings)
-      configuration = settings.with_indifferent_access
-      @connection_string = configuration[:connection_string]
-      @username = configuration[:username]
-      @password = configuration[:password]
+      @connection_string = settings[:connection_string] || settings["connection_string"]
+      @username = settings[:username] || settings["username"]
+      @password = settings[:password] || settings["password"]
     end
 
     def load_yaml(path, environment)

data/lib/couchbase/json_transcoder.rb

@@ -14,18 +14,25 @@
 
 require "json"
 
+require "couchbase/transcoder_flags"
+
 module Couchbase
   class JsonTranscoder
     # @param [Object] document
     # @return [Array<String, Integer>] pair of encoded document and flags
     def encode(document)
-      [JSON.generate(document), (0x02 << 24) | 0x06]
+      raise Error::EncodingFailure, "The JsonTranscoder does not support binary data" if document.is_a?(String) && !document.valid_encoding?
+
+      [JSON.generate(document), TranscoderFlags.new(format: :json, lower_bits: 6).encode]
     end
 
-    # @param [String, nil] blob string of bytes, containing encoded representation of the document
-    # @param [Integer, :json] _flags bit field, describing how the data encoded
-    # @return Object decoded document
-    def decode(blob, _flags)
+    # @param [String] blob string of bytes, containing encoded representation of the document
+    # @param [Integer, :json] flags bit field, describing how the data encoded
+    # @return [Object] decoded document
+    def decode(blob, flags)
+      format = TranscoderFlags.decode(flags).format
+      raise Error::DecodingFailure, "Unable to decode #{format} with the JsonTranscoder" unless format == :json || format.nil?
+
       JSON.parse(blob) unless blob&.empty?
     end
   end

data/lib/couchbase/management/collection_query_index_manager.rb

@@ -14,6 +14,7 @@
 
 require "couchbase/management/query_index_manager"
 require "couchbase/utils/time"
+require "couchbase/errors"
 
 module Couchbase
   module Management
@@ -37,8 +38,18 @@ module Couchbase
       #
       # @return [Array<QueryIndex>]
       #
-      # @raise [ArgumentError]
+      # @raise [Error::InvalidArgument]
       def get_all_indexes(options = Options::Query::GetAllIndexes.new)
+        unless options.scope_name.nil?
+          raise Error::InvalidArgument,
+                "Scope name cannot be set in the options when using the Query Index manager at the collection level"
+        end
+
+        unless options.collection_name.nil?
+          raise Error::InvalidArgument,
+                "Collection name cannot be set in the options when using the Query Index manager at the collection level"
+        end
+
         res = @backend.collection_query_index_get_all(@bucket_name, @scope_name, @collection_name, options.to_backend)
         res[:indexes].map do |idx|
           QueryIndex.new do |index|
@@ -64,15 +75,17 @@ module Couchbase
       #
       # @return void
       #
-      # @raise [ArgumentError]
+      # @raise [Error::InvalidArgument]
       # @raise [Error::IndexExists]
       def create_index(index_name, fields, options = Options::Query::CreateIndex.new)
         unless options.scope_name.nil?
-          raise ArgumentError, "Scope name cannot be set in the options when using the Query Index manager at the collection level"
+          raise Error::InvalidArgument,
+                "Scope name cannot be set in the options when using the Query Index manager at the collection level"
         end
 
         unless options.collection_name.nil?
-          raise ArgumentError, "Collection name cannot be set in the options when using the Query Index manager at the collection level"
+          raise Error::InvalidArgument,
+                "Collection name cannot be set in the options when using the Query Index manager at the collection level"
         end
 
         @backend.collection_query_index_create(@bucket_name, @scope_name, @collection_name, index_name, fields, options.to_backend)
@@ -84,15 +97,17 @@ module Couchbase
       #
       # @return void
       #
-      # @raise [ArgumentError]
+      # @raise [Error::InvalidArgument]
       # @raise [Error::IndexExists]
       def create_primary_index(options = Options::Query::CreatePrimaryIndex.new)
         unless options.scope_name.nil?
-          raise ArgumentError, "Scope name cannot be set in the options when using the Query Index manager at the collection level"
+          raise Error::InvalidArgument,
+                "Scope name cannot be set in the options when using the Query Index manager at the collection level"
         end
 
         unless options.collection_name.nil?
-          raise ArgumentError, "Collection name cannot be set in the options when using the Query Index manager at the collection level"
+          raise Error::InvalidArgument,
+                "Collection name cannot be set in the options when using the Query Index manager at the collection level"
         end
 
         @backend.collection_query_index_create_primary(@bucket_name, @scope_name, @collection_name, options.to_backend)
@@ -105,15 +120,17 @@ module Couchbase
       #
       # @return void
       #
-      # @raise [ArgumentError]
+      # @raise [Error::InvalidArgument]
       # @raise [Error::IndexNotFound]
       def drop_index(index_name, options = Options::Query::DropIndex.new)
         unless options.scope_name.nil?
-          raise ArgumentError, "Scope name cannot be set in the options when using the Query Index manager at the collection level"
+          raise Error::InvalidArgument,
+                "Scope name cannot be set in the options when using the Query Index manager at the collection level"
         end
 
         unless options.collection_name.nil?
-          raise ArgumentError, "Collection name cannot be set in the options when using the Query Index manager at the collection level"
+          raise Error::InvalidArgument,
+                "Collection name cannot be set in the options when using the Query Index manager at the collection level"
         end
 
         @backend.collection_query_index_drop(@bucket_name, @scope_name, @collection_name, index_name, options.to_backend)
@@ -125,15 +142,17 @@ module Couchbase
       #
       # @return void
       #
-      # @raise [ArgumentError]
+      # @raise [Error::InvalidArgument]
       # @raise [Error::IndexNotFound]
       def drop_primary_index(options = Options::Query::DropPrimaryIndex.new)
         unless options.scope_name.nil?
-          raise ArgumentError, "Scope name cannot be set in the options when using the Query Index manager at the collection level"
+          raise Error::InvalidArgument,
+                "Scope name cannot be set in the options when using the Query Index manager at the collection level"
         end
 
         unless options.collection_name.nil?
-          raise ArgumentError, "Collection name cannot be set in the options when using the Query Index manager at the collection level"
+          raise Error::InvalidArgument,
+                "Collection name cannot be set in the options when using the Query Index manager at the collection level"
         end
 
         @backend.collection_query_index_drop_primary(@bucket_name, @scope_name, @collection_name, options.to_backend)
@@ -145,8 +164,18 @@ module Couchbase
       #
       # @return void
       #
-      # @raise [ArgumentError]
+      # @raise [Error::InvalidArgument]
       def build_deferred_indexes(options = Options::Query::BuildDeferredIndexes.new)
+        unless options.scope_name.nil?
+          raise Error::InvalidArgument,
+                "Scope name cannot be set in the options when using the Query Index manager at the collection level"
+        end
+
+        unless options.collection_name.nil?
+          raise Error::InvalidArgument,
+                "Collection name cannot be set in the options when using the Query Index manager at the collection level"
+        end
+
         @backend.collection_query_index_build_deferred(@bucket_name, @scope_name, @collection_name, options.to_backend)
       end
 
@@ -156,9 +185,19 @@ module Couchbase
       # @param [Integer, #in_milliseconds] timeout the time in milliseconds allowed for the operation to complete
       # @param [Options::Query::WatchIndexes] options
       #
-      # @raise [ArgumentError]
+      # @raise [Error::InvalidArgument]
       # @raise [Error::IndexNotFound]
       def watch_indexes(index_names, timeout, options = Options::Query::WatchIndexes.new)
+        unless options.scope_name.nil?
+          raise Error::InvalidArgument,
+                "Scope name cannot be set in the options when using the Query Index manager at the collection level"
+        end
+
+        unless options.collection_name.nil?
+          raise Error::InvalidArgument,
+                "Collection name cannot be set in the options when using the Query Index manager at the collection level"
+        end
+
         index_names.append("#primary") if options.watch_primary
 
         interval_millis = 50