couchbase 3.0.0.alpha.4-x86_64-linux → 3.5.0-x86_64-linux

data/lib/couchbase/management/query_index_manager.rb

@@ -1,4 +1,4 @@
-#    Copyright 2020 Couchbase, Inc.
+#  Copyright 2020-2021 Couchbase, Inc.
 #
 #  Licensed under the Apache License, Version 2.0 (the "License");
 #  you may not use this file except in compliance with the License.
@@ -13,11 +13,374 @@
 #  limitations under the License.
 
 require "couchbase/errors"
+require "couchbase/options"
+require "couchbase/utils/time"
 
 module Couchbase
   module Management
+    module Options
+      module Query
+        # Options for {QueryIndexManager#get_all_indexes}
+        class GetAllIndexes < ::Couchbase::Options::Base
+          attr_accessor :scope_name # @return [String, nil]
+          attr_accessor :collection_name # @return [String, nil]
+
+          # Creates an instance of options for {QueryIndexManager#get_all_indexes}
+          #
+          # @param [String, nil] scope_name the name of the scope
+          # @param [String, nil] collection_name the name of the collection
+          #
+          # @param [Integer, #in_milliseconds, nil] timeout the time in milliseconds allowed for the operation to complete
+          # @param [Proc, nil] retry_strategy the custom retry strategy, if set
+          # @param [Hash, nil] client_context the client context data, if set
+          # @param [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [GetAllScopes] self
+          def initialize(scope_name: nil,
+                         collection_name: nil,
+                         timeout: nil,
+                         retry_strategy: nil,
+                         client_context: nil,
+                         parent_span: nil)
+            super(timeout: timeout, retry_strategy: retry_strategy, client_context: client_context, parent_span: parent_span)
+            @scope_name = scope_name
+            @collection_name = collection_name
+            yield self if block_given?
+          end
+
+          # @api private
+          def to_backend
+            {
+              timeout: Utils::Time.extract_duration(@timeout),
+              scope_name: @scope_name,
+              collection_name: @collection_name,
+            }
+          end
+        end
+
+        # Options for {QueryIndexManager#create_index}
+        class CreateIndex < ::Couchbase::Options::Base
+          attr_accessor :ignore_if_exists # @return [Boolean]
+          attr_accessor :num_replicas # @return [Integer, nil]
+          attr_accessor :deferred # @return [Boolean]
+          attr_accessor :condition # @return [String, nil]
+          attr_accessor :scope_name # @return [String, nil]
+          attr_accessor :collection_name # @return [String, nil]
+
+          # Creates an instance of options for {QueryIndexManager#create_index}
+          #
+          # @param [Boolean] ignore_if_exists do not raise error if the index already exist
+          # @param [Integer] num_replicas the number of replicas that this index should have
+          # @param [Boolean] deferred whether the index should be created as a deferred index.
+          # @param [String, nil] condition to apply to the index
+          # @param [String, nil] scope_name the name of the scope
+          # @param [String, nil] collection_name the name of the collection
+          #
+          # @param [Integer, #in_milliseconds, nil] timeout the time in milliseconds allowed for the operation to complete
+          # @param [Proc, nil] retry_strategy the custom retry strategy, if set
+          # @param [Hash, nil] client_context the client context data, if set
+          # @param [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [CreateIndex] self
+          def initialize(ignore_if_exists: false,
+                         num_replicas: nil,
+                         deferred: false,
+                         condition: nil,
+                         scope_name: nil,
+                         collection_name: nil,
+                         timeout: nil,
+                         retry_strategy: nil,
+                         client_context: nil,
+                         parent_span: nil)
+            super(timeout: timeout, retry_strategy: retry_strategy, client_context: client_context, parent_span: parent_span)
+            @ignore_if_exists = ignore_if_exists
+            @num_replicas = num_replicas
+            @deferred = deferred
+            @condition = condition
+            @scope_name = scope_name
+            @collection_name = collection_name
+            yield self if block_given?
+          end
+
+          # @api private
+          def to_backend
+            {
+              timeout: Utils::Time.extract_duration(@timeout),
+              ignore_if_exists: @ignore_if_exists,
+              condition: @condition,
+              deferred: @deferred,
+              num_replicas: @num_replicas,
+              scope_name: @scope_name,
+              collection_name: @collection_name,
+            }
+          end
+        end
+
+        # Options for {QueryIndexManager#create_primary_index}
+        class CreatePrimaryIndex < ::Couchbase::Options::Base
+          attr_accessor :ignore_if_exists # @return [Boolean]
+          attr_accessor :num_replicas # @return [Integer, nil]
+          attr_accessor :deferred # @return [Boolean]
+          attr_accessor :index_name # @return [String. nil]
+          attr_accessor :scope_name # @return [String, nil]
+          attr_accessor :collection_name # @return [String, nil]
+
+          # Creates an instance of options for {QueryIndexManager#create_primary_index}
+          #
+          # @param [Boolean] ignore_if_exists do not raise error if the index already exist
+          # @param [Integer] num_replicas the number of replicas that this index should have
+          # @param [Boolean] deferred whether the index should be created as a deferred index.
+          # @param [String, nil] index_name the custom name of the primary index.
+          # @param [String, nil] scope_name the name of the scope
+          # @param [String, nil] collection_name the name of the collection
+          #
+          # @param [Integer, #in_milliseconds, nil] timeout the time in milliseconds allowed for the operation to complete
+          # @param [Proc, nil] retry_strategy the custom retry strategy, if set
+          # @param [Hash, nil] client_context the client context data, if set
+          # @param [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [CreatePrimaryIndex] self
+          def initialize(ignore_if_exists: false,
+                         num_replicas: nil,
+                         deferred: false,
+                         index_name: nil,
+                         scope_name: nil,
+                         collection_name: nil,
+                         timeout: nil,
+                         retry_strategy: nil,
+                         client_context: nil,
+                         parent_span: nil)
+            super(timeout: timeout, retry_strategy: retry_strategy, client_context: client_context, parent_span: parent_span)
+            @ignore_if_exists = ignore_if_exists
+            @num_replicas = num_replicas
+            @deferred = deferred
+            @index_name = index_name
+            @scope_name = scope_name
+            @collection_name = collection_name
+            yield self if block_given?
+          end
+
+          # @api private
+          def to_backend
+            {
+              timeout: Utils::Time.extract_duration(@timeout),
+              ignore_if_exists: @ignore_if_exists,
+              deferred: @deferred,
+              num_replicas: @num_replicas,
+              index_name: @index_name,
+              scope_name: @scope_name,
+              collection_name: @collection_name,
+            }
+          end
+        end
+
+        # Options for {QueryIndexManager#drop_index}
+        class DropIndex < ::Couchbase::Options::Base
+          attr_accessor :ignore_if_does_not_exist # @return [Boolean]
+          attr_accessor :scope_name # @return [String, nil]
+          attr_accessor :collection_name # @return [String, nil]
+
+          # Creates an instance of options for {QueryIndexManager#drop_index}
+          #
+          # @param [Boolean] ignore_if_does_not_exist do not raise error if the index does not exist
+          # @param [String, nil] scope_name the name of the scope
+          # @param [String, nil] collection_name the name of the collection
+          #
+          # @param [Integer, #in_milliseconds, nil] timeout the time in milliseconds allowed for the operation to complete
+          # @param [Proc, nil] retry_strategy the custom retry strategy, if set
+          # @param [Hash, nil] client_context the client context data, if set
+          # @param [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [DropIndex] self
+          def initialize(ignore_if_does_not_exist: false,
+                         scope_name: nil,
+                         collection_name: nil,
+                         timeout: nil,
+                         retry_strategy: nil,
+                         client_context: nil,
+                         parent_span: nil)
+            super(timeout: timeout, retry_strategy: retry_strategy, client_context: client_context, parent_span: parent_span)
+            @ignore_if_does_not_exist = ignore_if_does_not_exist
+            @scope_name = scope_name
+            @collection_name = collection_name
+            yield self if block_given?
+          end
+
+          # @api private
+          def to_backend
+            {
+              timeout: Utils::Time.extract_duration(@timeout),
+              ignore_if_does_not_exist: @ignore_if_does_not_exist,
+              scope_name: @scope_name,
+              collection_name: @collection_name,
+            }
+          end
+        end
+
+        # Options for {QueryIndexManager#drop_primary_index}
+        class DropPrimaryIndex < ::Couchbase::Options::Base
+          attr_accessor :ignore_if_does_not_exist # @return [Boolean]
+          attr_accessor :scope_name # @return [String, nil]
+          attr_accessor :collection_name # @return [String, nil]
+
+          # Creates an instance of options for {QueryIndexManager#drop_primary_index}
+          #
+          # @param [Boolean] ignore_if_does_not_exist do not raise error if the index does not exist
+          # @param [String, nil] scope_name the name of the scope
+          # @param [String, nil] collection_name the name of the collection
+          #
+          # @param [Integer, #in_milliseconds, nil] timeout the time in milliseconds allowed for the operation to complete
+          # @param [Proc, nil] retry_strategy the custom retry strategy, if set
+          # @param [Hash, nil] client_context the client context data, if set
+          # @param [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [DropPrimaryIndex] self
+          def initialize(ignore_if_does_not_exist: false,
+                         scope_name: nil,
+                         collection_name: nil,
+                         timeout: nil,
+                         retry_strategy: nil,
+                         client_context: nil,
+                         parent_span: nil)
+            super(timeout: timeout, retry_strategy: retry_strategy, client_context: client_context, parent_span: parent_span)
+            @ignore_if_does_not_exist = ignore_if_does_not_exist
+            @scope_name = scope_name
+            @collection_name = collection_name
+            yield self if block_given?
+          end
+
+          # @api private
+          def to_backend
+            {
+              timeout: Utils::Time.extract_duration(@timeout),
+              ignore_if_does_not_exist: @ignore_if_does_not_exist,
+              scope_name: @scope_name,
+              collection_name: @collection_name,
+            }
+          end
+        end
+
+        # Options for {QueryIndexManager#build_deferred_indexes}
+        class BuildDeferredIndexes < ::Couchbase::Options::Base
+          attr_accessor :scope_name # @return [String, nil]
+          attr_accessor :collection_name # @return [String, nil]
+
+          # Creates an instance of options for {QueryIndexManager#build_deferred_indexes}
+          # @param [String, nil] scope_name the name of the scope
+          # @param [String, nil] collection_name the name of the collection
+          #
+          # @param [Integer, #in_milliseconds, nil] timeout the time in milliseconds allowed for the operation to complete
+          # @param [Proc, nil] retry_strategy the custom retry strategy, if set
+          # @param [Hash, nil] client_context the client context data, if set
+          # @param [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [GetAllScopes] self
+          def initialize(scope_name: nil,
+                         collection_name: nil,
+                         timeout: nil,
+                         retry_strategy: nil,
+                         client_context: nil,
+                         parent_span: nil)
+            super(timeout: timeout, retry_strategy: retry_strategy, client_context: client_context, parent_span: parent_span)
+            @scope_name = scope_name
+            @collection_name = collection_name
+            yield self if block_given?
+          end
+
+          # @api private
+          def to_backend
+            {
+              timeout: Utils::Time.extract_duration(@timeout),
+              scope_name: @scope_name,
+              collection_name: @collection_name,
+            }
+          end
+        end
+
+        # Options for {QueryIndexManager#watch_indexes}
+        class WatchIndexes < ::Couchbase::Options::Base
+          attr_accessor :watch_primary # @return [Boolean]
+          attr_accessor :scope_name # @return [String, nil]
+          attr_accessor :collection_name # @return [String, nil]
+
+          # Creates an instance of options for {QueryIndexManager#watch_indexes}
+          #
+          # @param [Boolean] watch_primary whether or not to watch the primary index
+          # @param [String, nil] scope_name the name of the scope
+          # @param [String, nil] collection_name the name of the collection
+          #
+          # @param [Proc, nil] retry_strategy the custom retry strategy, if set
+          # @param [Hash, nil] client_context the client context data, if set
+          # @param [Span, nil] parent_span if set holds the parent span, that should be used for this request
+          #
+          # @yieldparam [GetAllScopes] self
+          def initialize(watch_primary: false,
+                         scope_name: nil,
+                         collection_name: nil,
+                         retry_strategy: nil,
+                         client_context: nil,
+                         parent_span: nil)
+            super(timeout: nil, retry_strategy: retry_strategy, client_context: client_context, parent_span: parent_span)
+            @watch_primary = watch_primary
+            @scope_name = scope_name
+            @collection_name = collection_name
+            yield self if block_given?
+          end
+
+          # @api private
+          def to_backend
+            {
+              watch_primary: @watch_primary,
+              scope_name: @scope_name,
+              collection_name: @collection_name,
+            }
+          end
+        end
+
+        # rubocop:disable Naming/MethodName constructor shortcuts
+        module_function
+
+        # Construct {GetAllIndexes} options for {QueryIndexManager#get_all_indexes}
+        #
+        # @return [GetAllIndexes]
+        def GetAllIndexes(**args)
+          GetAllIndexes.new(**args)
+        end
+
+        # Construct {CreateIndex} options for {QueryIndexManager#create_index}
+        #
+        # @return [CreateIndex]
+        def CreateIndex(**args)
+          CreateIndex.new(**args)
+        end
+
+        # Construct {CreatePrimaryIndex} options for {QueryIndexManager#create_index}
+        #
+        # @return [CreatePrimaryIndex]
+        def CreatePrimaryIndex(**args)
+          CreatePrimaryIndex.new(**args)
+        end
+
+        # Construct {DropIndex} options for {QueryIndexManager#drop_index}
+        #
+        # @return [DropIndex]
+        def DropIndex(**args)
+          DropIndex.new(**args)
+        end
+
+        # Construct {DropPrimaryIndex} options for {QueryIndexManager#drop_primary_index}
+        #
+        # @return [DropPrimaryIndex]
+        def DropPrimaryIndex(**args)
+          DropPrimaryIndex.new(**args)
+        end
+
+        # rubocop:enable Naming/MethodName
+      end
+    end
+
     class QueryIndexManager
-      alias_method :inspect, :to_s
+      alias inspect to_s
 
       # @param [Couchbase::Backend] backend
       def initialize(backend)
@@ -27,23 +390,29 @@ module Couchbase
       # Fetches all indexes from the server
       #
       # @param [String] bucket_name name of the bucket
-      # @param [GetAllIndexOptions] options
+      # @param [Options::Query::GetAllIndexes] options
       #
       # @return [Array<QueryIndex>]
       #
       # @raise [ArgumentError]
       def get_all_indexes(bucket_name, options = GetAllIndexOptions.new)
-        res = @backend.query_index_get_all(bucket_name, options.timeout)
+        unless options.scope_name.nil? && options.collection_name.nil?
+          warn "The attributes 'scope_name' and 'collection_name' have been deprecated. Use 'collection.query_indexes' instead"
+        end
+
+        res = @backend.query_index_get_all(bucket_name, options.to_backend)
         res[:indexes].map do |idx|
           QueryIndex.new do |index|
             index.name = idx[:name]
             index.is_primary = idx[:is_primary]
             index.type = idx[:type]
             index.state = idx[:state]
-            index.key_space = idx[:keyspace_id]
-            index.name_space = idx[:namespace_id]
+            index.bucket = idx[:bucket_name]
+            index.scope = idx[:scope_name]
+            index.collection = idx[:collection_name]
             index.index_key = idx[:index_key]
             index.condition = idx[:condition]
+            index.partition = idx[:partition]
           end
         end
       end
@@ -53,203 +422,149 @@ module Couchbase
       # @param [String] bucket_name  name of the bucket
       # @param [String] index_name name of the index
       # @param [Array<String>] fields the lists of fields to create th index over
-      # @param [CreateIndexOptions] options
+      # @param [Options::Query::CreateIndex] options
       #
       # @return void
       #
       # @raise [ArgumentError]
       # @raise [Error::IndexExists]
-      def create_index(bucket_name, index_name, fields, options = CreateIndexOptions.new)
-        @backend.query_index_create(bucket_name, index_name, fields, {
-            ignore_if_exists: options.ignore_if_exists,
-            condition: options.condition,
-            deferred: options.deferred,
-            num_replicas: options.num_replicas,
-        }, options.timeout)
+      def create_index(bucket_name, index_name, fields, options = Options::Query::CreateIndex.new)
+        unless options.scope_name.nil? && options.collection_name.nil?
+          warn "The attributes 'scope_name' and 'collection_name' have been deprecated. Use 'collection.query_indexes' instead"
+        end
+
+        @backend.query_index_create(bucket_name, index_name, fields, options.to_backend)
       end
 
       # Creates new primary index
       #
       # @param [String] bucket_name name of the bucket
-      # @param [CreatePrimaryIndexOptions] options
+      # @param [Options::Query::CreatePrimaryIndex] options
       #
       # @return void
       #
       # @raise [ArgumentError]
       # @raise [Error::IndexExists]
-      def create_primary_index(bucket_name, options = CreatePrimaryIndexOptions.new)
-        @backend.query_index_create_primary(bucket_name, {
-            ignore_if_exists: options.ignore_if_exists,
-            deferred: options.deferred,
-            num_replicas: options.num_replicas,
-        }, options.timeout)
+      def create_primary_index(bucket_name, options = Options::Query::CreatePrimaryIndex.new)
+        unless options.scope_name.nil? && options.collection_name.nil?
+          warn "The attributes 'scope_name' and 'collection_name' have been deprecated. Use 'collection.query_indexes' instead"
+        end
+
+        @backend.query_index_create_primary(bucket_name, options.to_backend)
       end
 
       # Drops the index
       #
       # @param [String] bucket_name name of the bucket
       # @param [String] index_name name of the index
-      # @param [DropIndexOptions] options
+      # @param [Options::Query::DropIndex] options
       #
       # @return void
       #
       # @raise [ArgumentError]
       # @raise [Error::IndexNotFound]
-      def drop_index(bucket_name, index_name, options = DropIndexOptions.new)
-        @backend.query_index_drop(bucket_name, index_name, {
-            ignore_if_does_not_exist: options.ignore_if_does_not_exist,
-        }, options.timeout)
-        true
+      def drop_index(bucket_name, index_name, options = Options::Query::DropIndex.new)
+        unless options.scope_name.nil? && options.collection_name.nil?
+          warn "The attributes 'scope_name' and 'collection_name' have been deprecated. Use 'collection.query_indexes' instead"
+        end
+
+        @backend.query_index_drop(bucket_name, index_name, options.to_backend)
       end
 
       # Drops the primary index
       #
       # @param [String] bucket_name name of the bucket
-      # @param [DropPrimaryIndexOptions] options
+      # @param [Options::Query::DropPrimaryIndex] options
       #
       # @return void
       #
       # @raise [ArgumentError]
       # @raise [Error::IndexNotFound]
-      def drop_primary_index(bucket_name, options = DropPrimaryIndexOptions.new)
-        @backend.query_index_drop_primary(bucket_name, {
-            ignore_if_does_not_exist: options.ignore_if_does_not_exist,
-            index_name: options.index_name,
-        }, options.timeout)
-        true
+      def drop_primary_index(bucket_name, options = Options::Query::DropPrimaryIndex.new)
+        unless options.scope_name.nil? && options.collection_name.nil?
+          warn "The attributes 'scope_name' and 'collection_name' have been deprecated. Use 'collection.query_indexes' instead"
+        end
+
+        @backend.query_index_drop_primary(bucket_name, options.to_backend)
       end
 
       # Build all indexes which are currently in deferred state
       #
       # @param [String] bucket_name name of the bucket
-      # @param [BuildDeferredIndexOptions] options
+      # @param [Options::Query::BuildDeferredIndexes] options
       #
-      # @return void
+      # @return
       #
       # @raise [ArgumentError]
-      def build_deferred_indexes(bucket_name, options = BuildDeferredIndexOptions.new)
-        @backend.query_index_build_deferred(bucket_name, options.timeout)
+      def build_deferred_indexes(bucket_name, options = Options::Query::BuildDeferredIndexes.new)
+        unless options.scope_name.nil? && options.collection_name.nil?
+          warn "The attributes 'scope_name' and 'collection_name' have been deprecated. Use 'collection.query_indexes' instead"
+        end
+
+        @backend.query_index_build_deferred(bucket_name, options.to_backend)
       end
 
       # Polls indexes until they are online
       #
       # @param [String] bucket_name name of the bucket
       # @param [Array<String>] index_names names of the indexes to watch
-      # @param [Integer] timeout
-      # @param [WatchIndexesOptions] options
+      # @param [Integer, #in_milliseconds] timeout the time in milliseconds allowed for the operation to complete
+      # @param [Options::Query::WatchIndexes] options
       #
       # @raise [ArgumentError]
       # @raise [Error::IndexNotFound]
-      def watch_indexes(bucket_name, index_names, timeout, options = WatchIndexesOptions.new)
-        @backend.query_index_watch(bucket_name, index_names, timeout, {})
-      end
-
-      class GetAllIndexOptions
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
-
-        # @yieldparam [GetAllIndexOptions] self
-        def initialize
-          yield self if block_given?
+      def watch_indexes(bucket_name, index_names, timeout, options = Options::Query::WatchIndexes.new)
+        unless options.scope_name.nil? && options.collection_name.nil?
+          warn "The attributes 'scope_name' and 'collection_name' have been deprecated. Use 'collection.query_indexes' instead"
         end
-      end
-
-      class CreateIndexOptions
-        # @return [Boolean] do not raise error if the index already exist
-        attr_accessor :ignore_if_exists
 
-        # @return [Integer] the number of replicas that this index should have
-        attr_accessor :num_replicas
+        index_names.append("#primary") if options.watch_primary
 
-        # @return [Boolean] whether the index should be created as a deferred index.
-        attr_accessor :deferred
+        interval_millis = 50
+        deadline = Time.now + (Utils::Time.extract_duration(timeout) * 0.001)
+        while Time.now <= deadline
+          get_all_opts = Options::Query::GetAllIndexes.new(timeout: ((deadline - Time.now) * 1000).round)
+          indexes = get_all_indexes(bucket_name, get_all_opts).select { |idx| index_names.include? idx.name }
+          indexes_not_found = index_names - indexes.map(&:name)
+          raise Error::IndexNotFound, "Failed to find the indexes: #{indexes_not_found.join(', ')}" unless indexes_not_found.empty?
 
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
+          all_online = indexes.all? { |idx| idx.state == :online }
+          return if all_online
 
-        # @return [String] condition to apply to the index
-        attr_accessor :condition
-
-        # @yieldparam [CreateIndexOptions] self
-        def initialize
-          @ignore_if_exists = false
-          yield self if block_given?
+          sleep(interval_millis / 1000)
+          interval_millis += 500
+          interval_millis = 1000 if interval_millis > 1000
         end
+        raise Error::UnambiguousTimeout, "Failed to find all indexes online within the allotted time"
       end
 
-      class CreatePrimaryIndexOptions
-        # @return [String] name of the index
-        attr_accessor :index_name
+      # @api private
+      # TODO: deprecate after 3.2
+      GetAllIndexOptions = ::Couchbase::Management::Options::Query::GetAllIndexes
 
-        # @return [Boolean] do not raise error if the index already exist
-        attr_accessor :ignore_if_exists
+      # @api private
+      # TODO: deprecate after 3.2
+      CreateIndexOptions = ::Couchbase::Management::Options::Query::CreateIndex
 
-        # @return [Integer] the number of replicas that this index should have
-        attr_accessor :num_replicas
+      # @api private
+      # TODO: deprecate after 3.2
+      CreatePrimaryIndexOptions = ::Couchbase::Management::Options::Query::CreatePrimaryIndex
 
-        # @return [Boolean] whether the index should be created as a deferred index.
-        attr_accessor :deferred
+      # @api private
+      # TODO: deprecate after 3.2
+      DropIndexOptions = ::Couchbase::Management::Options::Query::DropIndex
 
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
+      # @api private
+      # TODO: deprecate after 3.2
+      DropPrimaryIndexOptions = ::Couchbase::Management::Options::Query::DropPrimaryIndex
 
-        # @yieldparam [CreatePrimaryIndexOptions] self
-        def initialize
-          @ignore_if_exists = false
-          yield self if block_given?
-        end
-      end
-
-      class DropIndexOptions
-        # @return [Boolean] do not raise error if the index does not exist
-        attr_accessor :ignore_if_does_not_exist
-
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
-
-        # @yieldparam [DropIndexOptions] self
-        def initialize
-          @ignore_if_does_not_exist = false
-          yield self if block_given?
-        end
-      end
-
-      class DropPrimaryIndexOptions
-        # @return [String] name of the index
-        attr_accessor :index_name
-
-        # @return [Boolean] do not raise error if the index does not exist
-        attr_accessor :ignore_if_does_not_exist
-
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
-
-        # @yieldparam [DropPrimaryIndexOptions] self
-        def initialize
-          @ignore_if_does_not_exist = false
-          yield self if block_given?
-        end
-      end
-
-      class WatchIndexesOptions
-        # @return [Boolean] whether or not to watch the primary index
-        attr_accessor :watch_primary
-
-        # @yieldparam [WatchIndexesOptions] self
-        def initialize
-          yield self if block_given?
-        end
-      end
-
-      class BuildDeferredIndexOptions
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
+      # @api private
+      # TODO: deprecate after 3.2
+      BuildDeferredIndexOptions = ::Couchbase::Management::Options::Query::BuildDeferredIndexes
 
-        # @yieldparam [BuildDeferredIndexOptions] self
-        def initialize
-          yield self if block_given?
-        end
-      end
+      # @api private
+      # TODO: deprecate after 3.2
+      WatchIndexesOptions = ::Couchbase::Management::Options::Query::WatchIndexes
     end
 
     class QueryIndex
@@ -258,7 +573,7 @@ module Couchbase
 
       # @return [Boolean] true if this is a primary index
       attr_accessor :is_primary
-      alias_method :primary?, :is_primary
+      alias primary? is_primary
 
       # @return [:gsi, :view] type of the index
       attr_accessor :type
@@ -266,11 +581,14 @@ module Couchbase
       # @return [Symbol] state
       attr_accessor :state
 
-      # @return [String] the key space for the index, typically the bucket name.
-      attr_accessor :key_space
+      # @return [String, nil] the name of the bucket
+      attr_accessor :bucket
+
+      # @return [String, nil] the name of the scope
+      attr_accessor :scope
 
-      # @return [String] the namespace for the index. A namespace is a resource pool that contains multiple key spaces.
-      attr_accessor :name_space
+      # @return [String, nil] the name of the collection
+      attr_accessor :collection
 
       # @return [Array<String>] an array of Strings that represent the index key(s). The array is empty in the case of a
       #   PRIMARY INDEX.
@@ -279,7 +597,6 @@ module Couchbase
       #   instance, it will show the indexed fields in an escaped format (surrounded by backticks).
       attr_accessor :index_key
 
-
       # @return [String] the string representation of the index's condition (the WHERE clause of the index),
       #   or an empty Optional if no condition was set.
       #
@@ -288,6 +605,9 @@ module Couchbase
       #   (surrounded by backticks).
       attr_accessor :condition
 
+      # @return [String] the string representation of the index's partition
+      attr_accessor :partition
+
       # @yieldparam [QueryIndex] self
       def initialize
         yield self if block_given?