couchbase 3.0.0.alpha.1-universal-darwin-19 → 3.0.0.alpha.2-universal-darwin-19

data/lib/couchbase/binary_collection.rb

@@ -12,6 +12,8 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
+require "couchbase/binary_collection_options"
+
 module Couchbase
   class BinaryCollection
     alias_method :inspect, :to_s
@@ -19,15 +21,16 @@ module Couchbase
     # @param [Couchbase::Collection] collection parent collection
     def initialize(collection)
       @collection = collection
+      @backend = collection.instance_variable_get("@backend")
     end
 
     # Appends binary content to the document
-    # 
+    #
     # @param [String] id the document id which is used to uniquely identify it
     # @param [String] content the binary content to append to the document
     # @param [AppendOptions] options custom options to customize the request
     #
-    # @return [MutationResult]
+    # @return [Collection::MutationResult]
     def append(id, content, options = AppendOptions.new) end
 
     # Prepends binary content to the document
@@ -36,93 +39,47 @@ module Couchbase
     # @param [String] content the binary content to prepend to the document
     # @param [PrependOptions] options custom options to customize the request
     #
-    # @return [MutationResult]
+    # @return [Collection::MutationResult]
     def prepend(id, content, options = PrependOptions.new) end
 
     # Increments the counter document by one of the number defined in the options
-    # 
+    #
     # @param [String] id the document id which is used to uniquely identify it
     # @param [IncrementOptions] options custom options to customize the request
     #
     # @return [CounterResult]
-    def increment(id, options = IncrementOptions.new) end
+    def increment(id, options = IncrementOptions.new)
+      resp = @backend.document_increment(@collection.bucket_name, "#{@collection.scope_name}.#{@collection.name}", id, {
+          delta: options.delta,
+          initial_value: options.initial,
+          expiration: options.expiration,
+          durability_level: options.durability_level,
+      })
+      CounterResult.new do |res|
+        res.cas = resp[:cas]
+        res.content = resp[:content]
+        res.mutation_token = @collection.send(:extract_mutation_token, resp)
+      end
+    end
 
     # Decrements the counter document by one of the number defined in the options
     #
     # @param [String] id the document id which is used to uniquely identify it
-    # @param [IncrementOptions] options custom options to customize the request
+    # @param [DecrementOptions] options custom options to customize the request
     #
     # @return [CounterResult]
-    def decrement(id, options = DecrementOptions.new) end
-
-    class AppendOptions < CommonOptions
-      # @return [Integer] The default CAS used (0 means no CAS in this context)
-      attr_accessor :cas
-
-      def initialize
-        yield self if block_given?
-      end
-    end
-
-    class PrependOptions < CommonOptions
-      # @return [Integer] The default CAS used (0 means no CAS in this context)
-      attr_accessor :cas
-
-      def initialize
-        yield self if block_given?
-      end
-    end
-
-    class IncrementOptions < CommonOptions
-      # @return [Integer] the delta for the operation
-      attr_reader :delta
-
-      # @return [Integer] if present, holds the initial value
-      attr_accessor :initial
-
-      # @return [Integer] if set, holds the expiration for the operation
-      attr_accessor :expiration
-
-      # @return [Integer] if set, holds the CAS value for this operation
-      attr_accessor :cas
-
-      def initialize
-        @delta = 1
-        yield self if block_given?
-      end
-
-      def delta=(value)
-        if delta < 0
-          raise ArgumentError, "the delta cannot be less than 0"
-        end
-        @delta = value
-      end
-    end
-
-    class DecrementOptions < CommonOptions
-      # @return [Integer] the delta for the operation
-      attr_reader :delta
-
-      # @return [Integer] if present, holds the initial value
-      attr_accessor :initial
-
-      # @return [Integer] if set, holds the expiration for the operation
-      attr_accessor :expiration
-
-      # @return [Integer] if set, holds the CAS value for this operation
-      attr_accessor :cas
-
-      def initialize
-        @delta = 1
-        yield self if block_given?
-      end
-
-      def delta=(value)
-        if delta < 0
-          raise ArgumentError, "the delta cannot be less than 0"
-        end
-        @delta = value
+    def decrement(id, options = DecrementOptions.new)
+      resp = @backend.document_decrement(@collection.bucket_name, "#{@collection.scope_name}.#{@collection.name}", id, {
+          delta: options.delta,
+          initial_value: options.initial,
+          expiration: options.expiration,
+          durability_level: options.durability_level,
+      })
+      CounterResult.new do |res|
+        res.cas = resp[:cas]
+        res.content = resp[:content]
+        res.mutation_token = @collection.send(:extract_mutation_token, resp)
       end
     end
   end
-end
+end

data/lib/couchbase/binary_collection_options.rb

@@ -0,0 +1,94 @@
+#    Copyright 2020 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/collection_options"
+
+module Couchbase
+  class BinaryCollection
+    class AppendOptions < CommonOptions
+      # @return [Integer] The default CAS used (0 means no CAS in this context)
+      attr_accessor :cas
+
+      def initialize
+        yield self if block_given?
+      end
+    end
+
+    class PrependOptions < CommonOptions
+      # @return [Integer] The default CAS used (0 means no CAS in this context)
+      attr_accessor :cas
+
+      def initialize
+        yield self if block_given?
+      end
+    end
+
+    class IncrementOptions < CommonOptions
+      # @return [Integer] the delta for the operation
+      attr_reader :delta
+
+      # @return [Integer] if present, holds the initial value
+      attr_accessor :initial
+
+      # @return [Integer] if set, holds the expiration for the operation
+      attr_accessor :expiration
+
+      # @return [:none, :majority, :majority_and_persist_to_active, :persist_to_majority] level of durability
+      attr_accessor :durability_level
+
+      def initialize
+        @delta = 1
+        yield self if block_given?
+      end
+
+      def delta=(value)
+        if delta < 0
+          raise ArgumentError, "the delta cannot be less than 0"
+        end
+        @delta = value
+      end
+    end
+
+    class DecrementOptions < CommonOptions
+      # @return [Integer] the delta for the operation
+      attr_reader :delta
+
+      # @return [Integer] if present, holds the initial value
+      attr_accessor :initial
+
+      # @return [Integer] if set, holds the expiration for the operation
+      attr_accessor :expiration
+
+      # @return [:none, :majority, :majority_and_persist_to_active, :persist_to_majority] level of durability
+      attr_accessor :durability_level
+
+      def initialize
+        @delta = 1
+        yield self if block_given?
+      end
+
+      def delta=(value)
+        if delta < 0
+          raise ArgumentError, "the delta cannot be less than 0"
+        end
+        @delta = value
+      end
+    end
+
+    class CounterResult < ::Couchbase::Collection::MutationResult
+      # @return [Integer] current value of the counter
+      attr_accessor :content
+    end
+  end
+end

data/lib/couchbase/bucket.rb

@@ -12,7 +12,8 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-require 'couchbase/scope'
+require "couchbase/scope"
+require "couchbase/management/collection_manager"
 
 module Couchbase
   class Bucket
@@ -29,7 +30,7 @@ module Couchbase
     #
     # @return [Scope]
     def default_scope
-      Scope.new(@backend, @name, :default)
+      Scope.new(@backend, @name, :_default)
     end
 
     # Get a named scope
@@ -57,6 +58,11 @@ module Couchbase
       default_scope.default_collection
     end
 
+    # @return [Management::CollectionManager]
+    def collections
+      Management::CollectionManager.new(@backend, @name)
+    end
+
     # Performs application-level ping requests against services in the couchbase cluster
     #
     # @return [PingResult]
@@ -78,4 +84,4 @@ module Couchbase
       end
     end
   end
-end
+end

data/lib/couchbase/cluster.rb

@@ -12,14 +12,14 @@
 #  See the License for the specific language governing permissions and
 #  limitations under the License.
 
-require 'couchbase/authenticator'
-require 'couchbase/bucket'
+require "couchbase/authenticator"
+require "couchbase/bucket"
 
-require 'couchbase/management/user_manager'
-require 'couchbase/management/bucket_manager'
-require 'couchbase/management/query_index_manager'
-require 'couchbase/management/analytics_index_manager'
-require 'couchbase/management/search_index_manager'
+require "couchbase/management/user_manager"
+require "couchbase/management/bucket_manager"
+require "couchbase/management/query_index_manager"
+require "couchbase/management/analytics_index_manager"
+require "couchbase/management/search_index_manager"
 
 module Couchbase
   class Cluster
@@ -40,24 +40,36 @@ module Couchbase
     end
 
     # Performs a query against the query (N1QL) services
-    # 
+    #
     # @param [String] statement the N1QL query statement
     # @param [QueryOptions] options the custom options for this query
     #
     # @return [QueryResult]
     def query(statement, options = QueryOptions.new)
-      resp = @backend.query(statement, {
+      resp = @backend.document_query(statement, {
+          timeout: options.timeout,
           adhoc: options.adhoc,
           client_context_id: options.client_context_id,
           max_parallelism: options.max_parallelism,
           readonly: options.readonly,
+          scan_wait: options.scan_wait,
           scan_cap: options.scan_cap,
           pipeline_batch: options.pipeline_batch,
           pipeline_cap: options.pipeline_cap,
           metrics: options.metrics,
           profile: options.profile,
           positional_parameters: options.instance_variable_get("@positional_parameters")&.map { |p| JSON.dump(p) },
-          named_parameters: options.instance_variable_get("@named_parameters")&.each_with_object({}) { |(n, v), o| o[n.to_s] = JSON.dump(v) }
+          named_parameters: options.instance_variable_get("@named_parameters")&.each_with_object({}) { |(n, v), o| o[n.to_s] = JSON.dump(v) },
+          raw_parameters: options.instance_variable_get("@raw_parameters"),
+          scan_consistency: options.instance_variable_get("@scan_consistency"),
+          mutation_state: options.instance_variable_get("@mutation_state")&.tokens&.map { |t|
+            {
+                bucket_name: t.bucket_name,
+                partition_id: t.partition_id,
+                partition_uuid: t.partition_uuid,
+                sequence_number: t.sequence_number,
+            }
+          },
       })
 
       QueryResult.new do |res|
@@ -85,7 +97,7 @@ module Couchbase
     end
 
     # Performs an analytics query
-    # 
+    #
     # @param [String] statement the N1QL query statement
     # @param [AnalyticsOptions] options the custom options for this query
     #
@@ -101,24 +113,29 @@ module Couchbase
     # @return [QueryResult]
     def search_query(index_name, query, options = SearchOptions.new) end
 
+    # @return [Management::UserManager]
     def users
-      UserManager.new(@backend)
+      Management::UserManager.new(@backend)
     end
 
+    # @return [Management::BucketManager]
     def buckets
-      BucketManager.new(@backend)
+      Management::BucketManager.new(@backend)
     end
 
+    # @return [Management::QueryIndexManager]
     def query_indexes
-      QueryIndexManager.new(@backend)
+      Management::QueryIndexManager.new(@backend)
     end
 
+    # @return [Management::AnalyticsIndexManager]
     def analytics_indexes
-      AnalyticsIndexManager.new(@backend)
+      Management::AnalyticsIndexManager.new(@backend)
     end
 
+    # @return [Management::SearchIndexManager]
     def search_indexes
-      SearchIndexManager.new(@backend)
+      Management::SearchIndexManager.new(@backend)
     end
 
     def disconnect
@@ -141,6 +158,9 @@ module Couchbase
     end
 
     class QueryOptions
+      # @return [Integer] Timeout in milliseconds
+      attr_accessor :timeout
+
       # @return [Boolean] Allows turning this request into a prepared statement query
       attr_accessor :adhoc
 
@@ -153,6 +173,14 @@ module Couchbase
       # @return [Boolean] Allows explicitly marking a query as being readonly and not mutating and documents on the server side.
       attr_accessor :readonly
 
+      # Allows customizing how long (in milliseconds) the query engine is willing to wait until the index catches up to whatever scan consistency is asked for in this query.
+      #
+      # @note that if +:not_bounded+ consistency level is used, this method doesn't do anything
+      # at all. If no value is provided to this method, the server default is used.
+      #
+      # @return [Integer] The maximum duration (in milliseconds) the query engine is willing to wait before failing.
+      attr_accessor :scan_wait
+
       # @return [Integer] Supports customizing the maximum buffered channel size between the indexer and the query service
       attr_accessor :scan_cap
 
@@ -169,34 +197,45 @@ module Couchbase
       attr_accessor :profile
 
       def initialize
+        @timeout = 75_000 # ms
         @adhoc = true
-        yield self if block_given?
+        @raw_parameters = {}
         @positional_parameters = nil
         @named_parameters = nil
+        @scan_consistency = nil
+        @mutation_state = nil
+        yield self if block_given?
       end
 
       # Allows providing custom JSON key/value pairs for advanced usage
       #
       # @param [String] key the parameter name (key of the JSON property)
       # @param [Object] value the parameter value (value of the JSON property)
-      def raw(key, value) end
+      def raw(key, value)
+        @raw_parameters[key] = JSON.generate(value)
+      end
 
       # Customizes the consistency guarantees for this query
       #
-      # * +:not_bounded+ The indexer will return whatever state it has to the query engine at the time of query. This is the default (for single-statement requests).
+      # @note overrides consistency level set by {#consistent_with}
       #
-      # * +:request_plus+ The indexer will wait until all mutations have been processed at the time of request before returning to the query engine.
+      # [+:not_bounded+] The indexer will return whatever state it has to the query engine at the time of query. This is the default (for single-statement requests).
       #
-      # @param [:not_bounded, :request_plus] scan_consistency the index scan consistency to be used for this query
+      # [+:request_plus+] The indexer will wait until all mutations have been processed at the time of request before returning to the query engine.
+      #
+      # @param [:not_bounded, :request_plus] level the index scan consistency to be used for this query
       def scan_consistency=(level)
+        @mutation_state = nil if @mutation_state
         @scan_consistency = level
       end
 
       # Sets the mutation tokens this query should be consistent with
       #
+      # @note overrides consistency level set by {#scan_consistency=}
       #
-      # @param [MutationState] the mutation state containing the mutation tokens
+      # @param [MutationState] mutation_state the mutation state containing the mutation tokens
       def consistent_with(mutation_state)
+        @scan_consistency = nil if @scan_consistency
         @mutation_state = mutation_state
       end
 
@@ -217,6 +256,105 @@ module Couchbase
       end
     end
 
+    class QueryResult
+      # @return [QueryMetaData] returns object representing additional metadata associated with this query
+      attr_accessor :meta_data
+
+      attr_accessor :transcoder
+
+      # Returns all rows converted using a transcoder
+      #
+      # @return [Array]
+      def rows(transcoder = self.transcoder)
+        @rows.lazy.map do |row|
+          if transcoder == :json
+            JSON.parse(row)
+          else
+            transcoder.call(row)
+          end
+        end
+      end
+
+      # @yieldparam [QueryResult] self
+      def initialize
+        yield self if block_given?
+        @transcoder = :json
+      end
+    end
+
+    class QueryMetaData
+      # @return [String] returns the request identifier string of the query request
+      attr_accessor :request_id
+
+      # @return [String] returns the client context identifier string set of the query request
+      attr_accessor :client_context_id
+
+      # @return [Symbol] returns raw query execution status as returned by the query engine
+      attr_accessor :status
+
+      # @return [Hash] returns the signature as returned by the query engine which is then decoded as JSON object
+      attr_accessor :signature
+
+      # @return [Hash] returns the profiling information returned by the query engine which is then decoded as JSON object
+      attr_accessor :profile
+
+      # @return [QueryMetrics] metrics as returned by the query engine, if enabled
+      attr_accessor :metrics
+
+      # @return [List<QueryWarning>] list of warnings returned by the query engine
+      attr_accessor :warnings
+
+      # @yieldparam [QueryMetaData] self
+      def initialize
+        yield self if block_given?
+      end
+    end
+
+    class QueryMetrics
+      # @return [Integer] The total time taken for the request, that is the time from when the request was received until the results were returned
+      attr_accessor :elapsed_time
+
+      # @return [Integer] The time taken for the execution of the request, that is the time from when query execution started until the results were returned
+      attr_accessor :execution_time
+
+      # @return [Integer] the total number of results selected by the engine before restriction through LIMIT clause.
+      attr_accessor :sort_count
+
+      # @return [Integer] The total number of objects in the results.
+      attr_accessor :result_count
+
+      # @return [Integer] The total number of bytes in the results.
+      attr_accessor :result_size
+
+      # @return [Integer] The number of mutations that were made during the request.
+      attr_accessor :mutation_count
+
+      # @return [Integer] The number of errors that occurred during the request.
+      attr_accessor :error_count
+
+      # @return [Integer] The number of warnings that occurred during the request.
+      attr_accessor :warning_count
+
+      # @yieldparam [QueryMetrics] self
+      def initialize
+        yield self if block_given?
+      end
+    end
+
+    # Represents a single warning returned from the query engine.
+    class QueryWarning
+      # @return [Integer]
+      attr_accessor :code
+
+      # @return [String]
+      attr_accessor :message
+
+      def initialize(code, message)
+        @code = code
+        @message = message
+      end
+    end
+
     class AnalyticsOptions
       def initialize
         yield self if block_given?
@@ -253,4 +391,4 @@ module Couchbase
       @backend.open(hostname, username, password)
     end
   end
-end
+end