couchbase 3.4.1 → 3.4.3

data/lib/couchbase/management/query_index_manager.rb

@@ -22,21 +22,40 @@ module Couchbase
       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(timeout: nil,
+          def initialize(scope_name: nil,
+                         collection_name: nil,
+                         timeout: nil,
                          retry_strategy: nil,
                          client_context: nil,
                          parent_span: nil)
-            super
+            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}
@@ -102,6 +121,7 @@ module Couchbase
           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]
 
@@ -110,6 +130,7 @@ module Couchbase
           # @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
           #
@@ -122,6 +143,7 @@ module Couchbase
           def initialize(ignore_if_exists: false,
                          num_replicas: nil,
                          deferred: false,
+                         index_name: nil,
                          scope_name: nil,
                          collection_name: nil,
                          timeout: nil,
@@ -132,6 +154,7 @@ module Couchbase
             @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?
@@ -144,6 +167,7 @@ module Couchbase
               ignore_if_exists: @ignore_if_exists,
               deferred: @deferred,
               num_replicas: @num_replicas,
+              index_name: @index_name,
               scope_name: @scope_name,
               collection_name: @collection_name,
             }
@@ -238,7 +262,12 @@ module Couchbase
 
         # 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
@@ -246,33 +275,55 @@ module Couchbase
           # @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,
+          def initialize(scope_name: nil,
+                         collection_name: nil,
+                         timeout: nil,
                          retry_strategy: nil,
                          client_context: nil,
                          parent_span: nil)
-            super
+            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
 
@@ -280,6 +331,8 @@ module Couchbase
           def to_backend
             {
               watch_primary: @watch_primary,
+              scope_name: @scope_name,
+              collection_name: @collection_name,
             }
           end
         end
@@ -343,6 +396,10 @@ module Couchbase
       #
       # @raise [ArgumentError]
       def get_all_indexes(bucket_name, options = GetAllIndexOptions.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
+
         res = @backend.query_index_get_all(bucket_name, options.to_backend)
         res[:indexes].map do |idx|
           QueryIndex.new do |index|
@@ -436,10 +493,14 @@ module Couchbase
       # @param [String] bucket_name name of the bucket
       # @param [Options::Query::BuildDeferredIndexes] options
       #
-      # @return void
+      # @return
       #
       # @raise [ArgumentError]
       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
 
@@ -453,6 +514,10 @@ module Couchbase
       # @raise [ArgumentError]
       # @raise [Error::IndexNotFound]
       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
+
         index_names.append("#primary") if options.watch_primary
 
         interval_millis = 50

data/lib/couchbase/options.rb

@@ -1029,10 +1029,38 @@ module Couchbase
     # Options for {BinaryCollection#append}
     class Append < Base
       attr_accessor :cas # @return [Integer]
+      attr_accessor :durability_level # @return [Symbol]
+      attr_accessor :replicate_to # @return [Symbol]
+      attr_accessor :persist_to # @return [Symbol]
 
       # Creates an instance of options for {BinaryCollection#append}
       #
       # @param [Integer] cas The default CAS used (0 means no CAS in this context)
+      # @param [Symbol] durability_level level of durability
+      #  +:none+::
+      #     no enhanced durability required for the mutation
+      #  +:majority+::
+      #     the mutation must be replicated to a majority of the Data Service nodes
+      #     (that is, held in the memory allocated to the bucket)
+      #  +:majority_and_persist_to_active+::
+      #     The mutation must be replicated to a majority of the Data Service nodes.
+      #     Additionally, it must be persisted (that is, written and synchronised to disk) on the
+      #     node hosting the active partition (vBucket) for the data.
+      #  +:persist_to_majority+::
+      #     The mutation must be persisted to a majority of the Data Service nodes.
+      #     Accordingly, it will be written to disk on those nodes.
+      # @param [Symbol] replicate_to number of nodes to replicate
+      #  +:none+:: do not apply any replication requirements.
+      #  +:one+::  wait for replication to at least one node.
+      #  +:two+::  wait for replication to at least two nodes.
+      #  +:three+:: wait for replication to at least three nodes.
+      # @param [Symbol] persist_to number of nodes to persist
+      #  +:none+:: do not apply any persistence requirements.
+      #  +:active+::  wait for persistence to active node
+      #  +:one+::  wait for persistence to at least one node.
+      #  +:two+:: wait for persistence to at least two nodes.
+      #  +:three+:: wait for persistence to at least three nodes.
+      #  +:four+:: wait for persistence to four nodes (active and replicas).
       #
       # @param [Integer, #in_milliseconds, nil] timeout
       # @param [Proc, nil] retry_strategy the custom retry strategy, if set
@@ -1041,12 +1069,23 @@ module Couchbase
       #
       # @yieldparam [Append] self
       def initialize(cas: nil,
+                     durability_level: :none,
+                     replicate_to: :none,
+                     persist_to: :none,
                      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)
         @cas = cas
+
+        if durability_level != :none && (replicate_to != :none || persist_to != :none)
+          raise ArgumentError, "durability_level conflicts with replicate_to and persist_to options"
+        end
+
+        @durability_level = durability_level
+        @replicate_to = replicate_to
+        @persist_to = persist_to
         yield self if block_given?
       end
 
@@ -1055,6 +1094,9 @@ module Couchbase
         {
           timeout: Utils::Time.extract_duration(@timeout),
           cas: @cas,
+          durability_level: @durability_level,
+          persist_to: @persist_to,
+          replicate_to: @replicate_to,
         }
       end
 
@@ -1064,12 +1106,39 @@ module Couchbase
 
     # Options for {BinaryCollection#prepend}
     class Prepend < Base
-      # @return [Integer] The default CAS used (0 means no CAS in this context)
-      attr_accessor :cas
+      attr_accessor :cas # @return [Integer]
+      attr_accessor :durability_level # @return [Symbol]
+      attr_accessor :replicate_to # @return [Symbol]
+      attr_accessor :persist_to # @return [Symbol]
 
       # Creates an instance of options for {BinaryCollection#prepend}
       #
       # @param [Integer] cas The default CAS used (0 means no CAS in this context)
+      # @param [Symbol] durability_level level of durability
+      #  +:none+::
+      #     no enhanced durability required for the mutation
+      #  +:majority+::
+      #     the mutation must be replicated to a majority of the Data Service nodes
+      #     (that is, held in the memory allocated to the bucket)
+      #  +:majority_and_persist_to_active+::
+      #     The mutation must be replicated to a majority of the Data Service nodes.
+      #     Additionally, it must be persisted (that is, written and synchronised to disk) on the
+      #     node hosting the active partition (vBucket) for the data.
+      #  +:persist_to_majority+::
+      #     The mutation must be persisted to a majority of the Data Service nodes.
+      #     Accordingly, it will be written to disk on those nodes.
+      # @param [Symbol] replicate_to number of nodes to replicate
+      #  +:none+:: do not apply any replication requirements.
+      #  +:one+::  wait for replication to at least one node.
+      #  +:two+::  wait for replication to at least two nodes.
+      #  +:three+:: wait for replication to at least three nodes.
+      # @param [Symbol] persist_to number of nodes to persist
+      #  +:none+:: do not apply any persistence requirements.
+      #  +:active+::  wait for persistence to active node
+      #  +:one+::  wait for persistence to at least one node.
+      #  +:two+:: wait for persistence to at least two nodes.
+      #  +:three+:: wait for persistence to at least three nodes.
+      #  +:four+:: wait for persistence to four nodes (active and replicas).
       #
       # @param [Integer, #in_milliseconds, nil] timeout
       # @param [Proc, nil] retry_strategy the custom retry strategy, if set
@@ -1078,12 +1147,23 @@ module Couchbase
       #
       # @yieldparam [Prepend] self
       def initialize(cas: nil,
+                     durability_level: :none,
+                     replicate_to: :none,
+                     persist_to: :none,
                      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)
         @cas = cas
+
+        if durability_level != :none && (replicate_to != :none || persist_to != :none)
+          raise ArgumentError, "durability_level conflicts with replicate_to and persist_to options"
+        end
+
+        @durability_level = durability_level
+        @replicate_to = replicate_to
+        @persist_to = persist_to
         yield self if block_given?
       end
 
@@ -1092,6 +1172,9 @@ module Couchbase
         {
           timeout: Utils::Time.extract_duration(@timeout),
           cas: @cas,
+          durability_level: @durability_level,
+          persist_to: @persist_to,
+          replicate_to: @replicate_to,
         }
       end
 

data/lib/couchbase/raw_binary_transcoder.rb

@@ -0,0 +1,37 @@
+#  Copyright 2023. Couchbase, Inc.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+require "couchbase/transcoder_flags"
+
+module Couchbase
+  class RawBinaryTranscoder
+    # @param [String] document
+    # @return [Array<String, Integer>] pair of encoded document and flags
+    def encode(document)
+      raise Error::EncodingFailure, "Only binary data supported by RawBinaryTranscoder" unless document.is_a?(String)
+
+      [document, TranscoderFlags.new(format: :binary).encode]
+    end
+
+    # @param [String] blob string of bytes, containing encoded representation of the document
+    # @param [Integer] flags bit field, describing how the data encoded
+    # @return [String] decoded document
+    def decode(blob, flags)
+      format = TranscoderFlags.decode(flags).format
+      raise Error::DecodingFailure, "Unable to decode #{format} with the RawBinaryTranscoder" unless format == :binary || format.nil?
+
+      blob
+    end
+  end
+end

data/lib/couchbase/raw_json_transcoder.rb

@@ -0,0 +1,38 @@
+#  Copyright 2023. Couchbase, Inc.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+require "couchbase/transcoder_flags"
+require "couchbase/errors"
+
+module Couchbase
+  class RawJsonTranscoder
+    # @param [String] document
+    # @return [Array<String, Integer>] pair of encoded document and flags
+    def encode(document)
+      raise Error::EncodingFailure, "Only String and binary data supported by RawJsonTranscoder" unless document.is_a?(String)
+
+      [document, TranscoderFlags.new(format: :json).encode]
+    end
+
+    # @param [String] blob string of bytes, containing encoded representation of the document
+    # @param [Integer] flags bit field, describing how the data encoded
+    # @return [String] decoded document
+    def decode(blob, flags)
+      format = TranscoderFlags.decode(flags).format
+      raise Error::DecodingFailure, "Unable to decode #{format} with the RawJsonTranscoder" unless format == :json || format.nil?
+
+      blob
+    end
+  end
+end

data/lib/couchbase/raw_string_transcoder.rb

@@ -0,0 +1,40 @@
+#  Copyright 2023. Couchbase, Inc.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+require "couchbase/transcoder_flags"
+require "couchbase/errors"
+
+module Couchbase
+  class RawStringTranscoder
+    # @param [String] document
+    # @return [Array<String, Integer>] pair of encoded document and flags
+    def encode(document)
+      unless document.is_a?(String) && document.valid_encoding?
+        raise Error::EncodingFailure, "Only String data supported by RawStringTranscoder"
+      end
+
+      [document, TranscoderFlags.new(format: :string).encode]
+    end
+
+    # @param [String] blob string of bytes, containing encoded representation of the document
+    # @param [Integer] flags bit field, describing how the data encoded
+    # @return [String] decoded document
+    def decode(blob, flags)
+      format = TranscoderFlags.decode(flags).format
+      raise Error::DecodingFailure, "Unable to decode #{format} with the RawStringTranscoder" unless format == :string || format.nil?
+
+      blob
+    end
+  end
+end