couchbase 3.1.1-universal-darwin-20 → 3.2.0-universal-darwin-20

data/lib/couchbase/management/query_index_manager.rb

@@ -13,9 +13,318 @@
 #  limitations under the License.
 
 require "couchbase/errors"
+require "couchbase/options"
 
 module Couchbase
   module Management
+    module Options
+      module Query
+        # Options for {QueryIndexManager#get_all_indexes}
+        class GetAllIndexes < ::Couchbase::Options::Base
+          # Creates an instance of options for {QueryIndexManager#get_all_indexes}
+          #
+          # @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(timeout: nil,
+                         retry_strategy: nil,
+                         client_context: nil,
+                         parent_span: nil)
+            super
+            yield self if block_given?
+          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: @timeout.respond_to?(:in_milliseconds) ? @timeout.public_send(:in_milliseconds) : @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 :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] 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,
+                         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
+            @scope_name = scope_name
+            @collection_name = collection_name
+            yield self if block_given?
+          end
+
+          # @api private
+          def to_backend
+            {
+              timeout: @timeout.respond_to?(:in_milliseconds) ? @timeout.public_send(:in_milliseconds) : @timeout,
+              ignore_if_exists: @ignore_if_exists,
+              deferred: @deferred,
+              num_replicas: @num_replicas,
+              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: @timeout.respond_to?(:in_milliseconds) ? @timeout.public_send(:in_milliseconds) : @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: @timeout.respond_to?(:in_milliseconds) ? @timeout.public_send(:in_milliseconds) : @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
+          # Creates an instance of options for {QueryIndexManager#build_deferred_indexes}
+          #
+          # @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(timeout: nil,
+                         retry_strategy: nil,
+                         client_context: nil,
+                         parent_span: nil)
+            super
+            yield self if block_given?
+          end
+        end
+
+        # Options for {QueryIndexManager#watch_indexes}
+        class WatchIndexes < ::Couchbase::Options::Base
+          attr_accessor :watch_primary # @return [Boolean]
+
+          # Creates an instance of options for {QueryIndexManager#watch_indexes}
+          #
+          # @param [Boolean] watch_primary whether or not to watch the primary index
+          # @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,
+                         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
+            yield self if block_given?
+          end
+
+          # @api private
+          def to_backend
+            {
+              watch_primary: @watch_primary,
+            }
+          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 inspect to_s
 
@@ -27,13 +336,13 @@ 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)
+        res = @backend.query_index_get_all(bucket_name, options.to_backend)
         res[:indexes].map do |idx|
           QueryIndex.new do |index|
             index.name = idx[:name]
@@ -47,6 +356,7 @@ module Couchbase
             index.name_space = idx[:namespace_id]
             index.index_key = idx[:index_key]
             index.condition = idx[:condition]
+            index.partition = idx[:partition]
           end
         end
       end
@@ -56,237 +366,112 @@ 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,
-          scope_name: options.scope_name,
-          collection_name: options.collection_name,
-        }, options.timeout)
+      def create_index(bucket_name, index_name, fields, options = Options::Query::CreateIndex.new)
+        @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,
-          scope_name: options.scope_name,
-          collection_name: options.collection_name,
-        }, options.timeout)
+      def create_primary_index(bucket_name, options = Options::Query::CreatePrimaryIndex.new)
+        @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,
-          scope_name: options.scope_name,
-          collection_name: options.collection_name,
-        }, options.timeout)
+      def drop_index(bucket_name, index_name, options = Options::Query::DropIndex.new)
+        @backend.query_index_drop(bucket_name, index_name, options.to_backend)
         true
       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,
-          scope_name: options.scope_name,
-          collection_name: options.collection_name,
-        }, options.timeout)
+      def drop_primary_index(bucket_name, options = Options::Query::DropPrimaryIndex.new)
+        @backend.query_index_drop_primary(bucket_name, options.to_backend)
         true
       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
       #
       # @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)
+        @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, #in_milliseconds] 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, {
-          watch_primary: options.watch_primary,
-        })
-      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?
-        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
-
-        # @return [Boolean] whether the index should be created as a deferred index.
-        attr_accessor :deferred
-
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
-
-        # @return [String] condition to apply to the index
-        attr_accessor :condition
-
-        # @return [String] the name of the scope
-        attr_accessor :scope_name
-
-        # @return [String] the name of the collection
-        attr_accessor :collection_name
-
-        # @yieldparam [CreateIndexOptions] self
-        def initialize
-          @ignore_if_exists = false
-          yield self if block_given?
-        end
+      def watch_indexes(bucket_name, index_names, timeout, options = Options::Query::WatchIndexes.new)
+        @backend.query_index_watch(bucket_name, index_names,
+                                   timeout.respond_to?(:in_milliseconds) ? timeout.public_send(:in_milliseconds) : timeout,
+                                   options.to_backend)
       end
 
-      class CreatePrimaryIndexOptions
-        # @return [String] name of the index
-        attr_accessor :index_name
-
-        # @return [Boolean] do not raise error if the index already exist
-        attr_accessor :ignore_if_exists
+      # @api private
+      # TODO: deprecate after 3.2
+      GetAllIndexOptions = ::Couchbase::Management::Options::Query::GetAllIndexes
 
-        # @return [Integer] the number of replicas that this index should have
-        attr_accessor :num_replicas
+      # @api private
+      # TODO: deprecate after 3.2
+      CreateIndexOptions = ::Couchbase::Management::Options::Query::CreateIndex
 
-        # @return [Boolean] whether the index should be created as a deferred index.
-        attr_accessor :deferred
+      # @api private
+      # TODO: deprecate after 3.2
+      CreatePrimaryIndexOptions = ::Couchbase::Management::Options::Query::CreatePrimaryIndex
 
-        # @return [Integer] the time in milliseconds allowed for the operation to complete
-        attr_accessor :timeout
-
-        # @return [String] the name of the scope
-        attr_accessor :scope_name
-
-        # @return [String] the name of the collection
-        attr_accessor :collection_name
-
-        # @yieldparam [CreatePrimaryIndexOptions] self
-        def initialize
-          @ignore_if_exists = false
-          yield self if block_given?
-        end
-      end
+      # @api private
+      # TODO: deprecate after 3.2
+      DropIndexOptions = ::Couchbase::Management::Options::Query::DropIndex
 
-      class DropIndexOptions
-        # @return [Boolean] do not raise error if the index does not exist
-        attr_accessor :ignore_if_does_not_exist
+      # @api private
+      # TODO: deprecate after 3.2
+      DropPrimaryIndexOptions = ::Couchbase::Management::Options::Query::DropPrimaryIndex
 
-        # @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
 
-        # @return [String] the name of the scope
-        attr_accessor :scope_name
-
-        # @return [String] the name of the collection
-        attr_accessor :collection_name
-
-        # @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
-
-        # @return [String] the name of the scope
-        attr_accessor :scope_name
-
-        # @return [String] the name of the collection
-        attr_accessor :collection_name
-
-        # @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
-
-        # @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
@@ -333,6 +518,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?