couchbase 3.8.2 → 3.9.1

data/lib/couchbase/protostellar/collection.rb

@@ -138,6 +138,10 @@ module Couchbase
         ResponseConverter::KV.to_get_any_replica_result(resp, options)
       end
 
+      def get_replica(_id, _strategy, _options = Couchbase::Options::GetReplica::DEFAULT)
+        raise Couchbase::Error::FeatureNotAvailable, "The #{Protostellar::NAME} protocol does not support get replica"
+      end
+
       def get_all_replicas(id, options = Couchbase::Options::GetAllReplicas::DEFAULT)
         req = @kv_request_generator.get_all_replicas_request(id, options)
         resp = @client.send_request(req)

data/lib/couchbase/protostellar/error_handling.rb

@@ -144,7 +144,8 @@ module Couchbase
           when Google::Rpc::Code::FAILED_PRECONDITION
             case detail_block[:precondition_failure].violations[0].type
             when "LOCKED"
-              Retry::Orchestrator.maybe_retry(request, Retry::Reason::KV_LOCKED)
+              Retry::Orchestrator.maybe_retry(request, Retry::Reason::KV_LOCKED,
+                                              Couchbase::Error::DocumentLocked.new(message, request.error_context))
             when "DOC_TOO_DEEP"
               RequestBehaviour.fail(Couchbase::Error::PathTooDeep.new(message, request.error_context))
             when "DOC_NOT_JSON"

data/lib/couchbase/protostellar/request.rb

@@ -16,6 +16,7 @@
 
 require "couchbase/utils/time"
 require_relative "retry/strategies/best_effort"
+require_relative "retry/strategies/fail_fast"
 
 module Couchbase
   module Protostellar

data/lib/couchbase/protostellar/request_generator/kv.rb

@@ -347,7 +347,8 @@ module Couchbase
             **location,
           )
 
-          create_kv_request(proto_req, :get_all_replicas, options, idempotent: true)
+          create_kv_request(proto_req, :get_all_replicas, options,
+                            idempotent: true, retry_strategy: Retry::Strategies::BestEffort::DEFAULT)
         end
 
         def get_any_replica_request(id, options)
@@ -357,16 +358,29 @@ module Couchbase
 
         private
 
-        def create_kv_request(proto_request, rpc, options, idempotent: false)
+        def create_kv_request(proto_request, rpc, options, idempotent: false,
+                              retry_strategy: kv_retry_strategy(options.retry_strategy))
           Request.new(
             service: :kv,
             rpc: rpc,
             proto_request: proto_request,
             timeout: options.timeout,
+            retry_strategy: retry_strategy,
             idempotent: idempotent,
           )
         end
 
+        def kv_retry_strategy(name)
+          case name
+          when nil, :best_effort
+            Retry::Strategies::BestEffort::DEFAULT
+          when :fail_fast
+            Retry::Strategies::FailFast::DEFAULT
+          else
+            raise Error::InvalidArgument, "retry_strategy must be :best_effort or :fail_fast, but given #{name.inspect}"
+          end
+        end
+
         def get_expiry(options_or_expiry)
           if options_or_expiry.respond_to?(:expiry)
             type, time_or_duration = Couchbase::Utils::Time.extract_expiry_time(options_or_expiry.expiry)

data/lib/couchbase/protostellar/request_generator/search.rb

@@ -16,6 +16,7 @@
 
 require "google/protobuf/well_known_types"
 
+require "couchbase/errors"
 require "couchbase/search_options"
 
 require "couchbase/protostellar/generated/search/v1/search_pb"
@@ -48,7 +49,7 @@ module Couchbase
             scan_consistency: SCAN_CONSISTENCY_MAP[options.scan_consistency],
             include_explanation: options.explain,
             highlight_style: HIGHLIGHT_STYLE_MAP[options.highlight_style],
-            disable_scoring: options.disable_scoring,
+            disable_scoring: get_disable_scoring(options),
             include_locations: options.include_locations,
           }
 
@@ -344,6 +345,21 @@ module Couchbase
           end
         end
 
+        # The only scoring mode supported by the protocol is {Couchbase::SearchScoring.none}.
+        # This will be updated to support all types of scoring once the protostellar protocol supports them.
+        def get_disable_scoring(options)
+          return options.disable_scoring if options.scoring.nil?
+
+          options.validate_scoring
+
+          unless options.scoring.is_a?(Couchbase::SearchScoring::SearchScoringNone)
+            raise Couchbase::Error::FeatureNotAvailable,
+                  "The #{Protostellar::NAME} protocol does not support #{options.scoring.class} scoring"
+          end
+
+          true
+        end
+
         def get_facets(options)
           return {} if options.facets.nil?
 

data/lib/couchbase/protostellar/retry/orchestrator.rb

@@ -24,7 +24,8 @@ module Couchbase
     module Retry
       # @api private
       class Orchestrator
-        def self.maybe_retry(request, reason)
+        # @param [Couchbase::Error::CouchbaseError, nil] cause raised when the strategy declines the retry
+        def self.maybe_retry(request, reason, cause = nil)
           if reason.always_retry
             retry_duration = get_controlled_backoff(request)
             request.add_retry_attempt(reason)
@@ -35,7 +36,7 @@ module Couchbase
             duration = retry_action.duration
             if duration.nil?
               # TODO: Log not retried
-              RequestBehaviour.fail(Couchbase::Error::RequestCanceled.new('Cannot retry request', request.error_context))
+              RequestBehaviour.fail(cause || Couchbase::Error::RequestCanceled.new('Cannot retry request', request.error_context))
             else
               request.add_retry_attempt(reason)
               # TODO: Log retry

data/lib/couchbase/protostellar/retry/strategies/fail_fast.rb

@@ -0,0 +1,33 @@
+#  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.
+
+# frozen_string_literal: true
+
+require_relative "../action"
+
+module Couchbase
+  module Protostellar
+    module Retry
+      module Strategies
+        class FailFast
+          def retry_after(_request, _reason)
+            Retry::Action.no_retry
+          end
+
+          DEFAULT = FailFast.new.freeze
+        end
+      end
+    end
+  end
+end

data/lib/couchbase/protostellar/retry/strategies.rb

@@ -15,6 +15,7 @@
 # frozen_string_literal: true
 
 require_relative "strategies/best_effort"
+require_relative "strategies/fail_fast"
 
 module Couchbase
   module Protostellar

data/lib/couchbase/search_options.rb

@@ -25,8 +25,6 @@ module Couchbase
     # @overload new(vector_search)
     #   Will run a +VectorSearch+
     #   @param [VectorSearch] vector_search
-    #
-    #   @!macro uncommitted
     def initialize(search)
       case search
       when SearchQuery
@@ -57,8 +55,6 @@ module Couchbase
     # @param [VectorSearch] query
     #
     # @return [SearchRequest] for chaining purposes
-    #
-    # @!macro uncommitted
     def vector_search(query)
       raise Error::InvalidArgument, "A VectorSearch has already been specified" unless @vector_search.nil?
 
@@ -1046,7 +1042,6 @@ module Couchbase
     end
   end
 
-  # @!macro uncommitted
   class VectorSearch
     # Constructs a +VectorSearch+ instance, which allows one or more individual vector queries to be executed.
     #
@@ -1065,7 +1060,6 @@ module Couchbase
     end
   end
 
-  # @!macro uncommitted
   class VectorQuery
     # @return [Integer, nil]
     attr_accessor :num_candidates
@@ -1259,6 +1253,101 @@ module Couchbase
     end
   end
 
+  # +SearchScoring+ specifies the scoring mode used for a search request. For a hybrid search (a traditional FTS
+  # query combined with one or more vector queries) a fusion strategy controls how the FTS and vector result
+  # sets are merged into a single ranked list.
+  #
+  class SearchScoring
+    # @yieldparam [SearchScoringReciprocalRankFusion]
+    #
+    # @!macro uncommitted
+    #
+    # @return [SearchScoringReciprocalRankFusion]
+    def self.reciprocal_rank_fusion(&)
+      SearchScoringReciprocalRankFusion.new(&)
+    end
+
+    # @yieldparam [SearchScoringRelativeScoreFusion]
+    #
+    # @!macro uncommitted
+    #
+    # @return [SearchScoringRelativeScoreFusion]
+    def self.relative_score_fusion(&)
+      SearchScoringRelativeScoreFusion.new(&)
+    end
+
+    # @return [SearchScoringNone]
+    def self.none
+      SearchScoringNone.new
+    end
+
+    # +SearchScoringReciprocalRankFusion+ merges the FTS and vector result sets of a hybrid search by rank rather
+    # than raw score.
+    #
+    # @!macro uncommitted
+    class SearchScoringReciprocalRankFusion < SearchScoring
+      # @return [Integer, nil] the rank constant used when merging the result sets (the server defaults this to 60)
+      attr_accessor :rank_constant
+
+      # @return [Integer, nil] how many results per list are considered for fusion (the server defaults this to the
+      #   request limit)
+      attr_accessor :window_size
+
+      # @yieldparam [SearchScoringReciprocalRankFusion]
+      def initialize
+        super
+        yield self if block_given?
+      end
+
+      # @api private
+      def to_backend
+        {
+          mode: :reciprocal_rank_fusion,
+          params: {
+            rank_constant: @rank_constant,
+            window_size: @window_size,
+          }.compact,
+        }
+      end
+    end
+
+    # +SearchScoringRelativeScoreFusion+ merges the FTS and vector result sets of a hybrid search by normalized
+    # score.
+    #
+    # @!macro uncommitted
+    class SearchScoringRelativeScoreFusion < SearchScoring
+      # @return [Integer, nil] how many results per list are considered for fusion (the server defaults this to the
+      #   request limit)
+      attr_accessor :window_size
+
+      # @yieldparam [SearchScoringRelativeScoreFusion]
+      def initialize
+        super
+        yield self if block_given?
+      end
+
+      # @api private
+      def to_backend
+        {
+          mode: :relative_score_fusion,
+          params: {
+            window_size: @window_size,
+          }.compact,
+        }
+      end
+    end
+
+    # +SearchScoringNone+ disables scoring.
+    class SearchScoringNone < SearchScoring
+      # @api private
+      def to_backend
+        {
+          mode: :none,
+        }
+      end
+    end
+  end
+
   class SearchFacet
     # @param [String] field_name
     # @return [SearchFacetTerm]

data/lib/couchbase/version.rb

@@ -21,5 +21,5 @@ module Couchbase
   #   $ ruby -rcouchbase -e 'pp Couchbase::VERSION'
   #   {:sdk=>"3.4.0", :ruby_abi=>"3.1.0", :revision=>"416fe68e6029ec8a4c40611cf6e6b30d3b90d20f"}
   VERSION = {} unless defined?(VERSION) # rubocop:disable Style/MutableConstant
-  VERSION.update(:sdk => "3.8.2")
+  VERSION.update(:sdk => "3.9.1")
 end