couchbase 3.0.0.alpha.2 → 3.0.0

data/lib/couchbase/management/user_manager.rb

@@ -17,7 +17,7 @@ require "couchbase/errors"
 module Couchbase
   module Management
     class UserManager
-      alias_method :inspect, :to_s
+      alias inspect to_s
 
       # @param [Couchbase::Backend] backend
       def initialize(backend)
@@ -288,7 +288,7 @@ module Couchbase
       # @return [User]
       attr_reader :user
 
-      # @return [List<RoleAndOrigins>]
+      # @return [Array<RoleAndOrigins>]
       attr_reader :effective_roles
 
       # @return [Time]

data/lib/couchbase/management/view_index_manager.rb

@@ -32,7 +32,10 @@ module Couchbase
     # development document or a production document. The type of this argument is [Symbol] with allowed values
     # +:production+ and +:development+.
     class ViewIndexManager
-      alias_method :inspect, :to_s
+      alias inspect to_s
+
+      # @return [String] name of the bucket
+      attr_accessor :bucket_name
 
       # @param [Couchbase::Backend] backend
       # @param [String] bucket_name
@@ -51,7 +54,8 @@ module Couchbase
       #
       # @raise [Error::DesignDocumentNotFound]
       def get_design_document(name, namespace, options = GetDesignDocumentOptions.new)
-        # GET /{bucket_name}/_design/{namespace}_{name}
+        resp = @backend.view_index_get(@bucket_name, name, namespace, options.timeout)
+        extract_design_document(resp)
       end
 
       # Fetches all design documents from the server
@@ -61,7 +65,10 @@ module Couchbase
       #
       # @return [Array<DesignDocument>]
       def get_all_design_documents(namespace, options = GetAllDesignDocumentsOptions.new)
-        # GET /pools/default/buckets/{bucket_name}/ddocs
+        resp = @backend.view_index_get_all(@bucket_name, namespace, options.timeout)
+        resp.map do |entry|
+          extract_design_document(entry)
+        end
       end
 
       # Updates or inserts the design document
@@ -69,8 +76,19 @@ module Couchbase
       # @param [DesignDocument] document
       # @param [:production, :development] namespace the namespace
       # @param [UpsertDesignDocumentOptions] options
+      #
+      # @return [void]
       def upsert_design_document(document, namespace, options = UpsertDesignDocumentOptions.new)
-        # PUT /{bucket_name}/_design/{namespace}_{name}
+        @backend.view_index_upsert(@bucket_name, {
+          name: document.name,
+          views: document.views.map do |name, view|
+            {
+              name: name,
+              map: view.map_function,
+              reduce: view.reduce_function,
+            }
+          end,
+        }, namespace, options.timeout)
       end
 
       # Removes the design document
@@ -79,9 +97,11 @@ module Couchbase
       # @param [:production, :development] namespace the namespace
       # @param [DropDesignDocumentOptions] options
       #
+      # @return [void]
+      #
       # @raise [Error::DesignDocumentNotFound]
       def drop_design_document(name, namespace, options = DropDesignDocumentOptions.new)
-        # DELETE /{bucket_name}/_design/{namespace}_{name}
+        @backend.view_index_drop(@bucket_name, name, namespace, options.timeout)
       end
 
       # Publishes the design document.
@@ -92,9 +112,13 @@ module Couchbase
       # @param [String] name design document name
       # @param [PublishDesignDocumentOptions] options
       #
+      # @return [void]
+      #
       # @raise [ArgumentError]
       # @raise [Error::DesignDocumentNotFound]
       def publish_design_document(name, options = PublishDesignDocumentOptions.new)
+        document = get_design_document(name, :development, GetDesignDocumentOptions.new { |o| o.timeout = options.timeout })
+        upsert_design_document(document, :production, UpsertDesignDocumentOptions.new { |o| o.timeout = options.timeout })
       end
 
       class GetDesignDocumentOptions
@@ -147,17 +171,48 @@ module Couchbase
         end
       end
 
+      private
+
+      def extract_design_document(resp)
+        DesignDocument.new do |design_document|
+          design_document.name = resp[:name]
+          design_document.namespace = resp[:namespace]
+          resp[:views].each do |name, view_resp|
+            design_document.views[name] = View.new(view_resp[:map], view_resp[:reduce])
+          end
+        end
+      end
     end
 
     class View
-      # @return [String] map function in javascript
-      attr_accessor :map
+      # @return [String] name of the view
+      attr_accessor :view
 
-      # @return [String] reduce function in javascript
-      attr_accessor :reduce
+      # @return [String] map function in javascript as String
+      attr_accessor :map_function
+      alias map map_function
 
+      # @return [String] reduce function in javascript as String
+      attr_accessor :reduce_function
+      alias reduce reduce_function
+
+      # @return [Boolean] true if map function is defined
+      def has_map?
+        !@map_function.nil?
+      end
+
+      # @return [Boolean] true if map function is defined
+      def has_reduce?
+        !@reduce_function.nil?
+      end
+
+      # @param [String] map
+      # @param [String] reduce
+      #
       # @yieldparam [View] self
-      def initialize
+      def initialize(map = nil, reduce = nil)
+        @map_function = map
+        @reduce_function = reduce
         yield self if block_given?
       end
     end
@@ -166,11 +221,15 @@ module Couchbase
       # @return [String] name
       attr_accessor :name
 
-      # @return [Hash<String, View>]
+      # @return [Hash<String => View>]
       attr_accessor :views
 
+      # @return [:production, :development]
+      attr_accessor :namespace
+
       # @yieldparam [DesignDocument] self
       def initialize
+        @views = {}
         yield self if block_given?
       end
     end

data/lib/couchbase/mutation_state.rb

@@ -30,6 +30,7 @@ module Couchbase
   end
 
   class MutationState
+    # @return [Array<MutationToken>]
     attr_accessor :tokens
 
     # Create a mutation state from one or more MutationTokens
@@ -46,5 +47,17 @@ module Couchbase
     def add(*mutation_tokens)
       @tokens |= mutation_tokens
     end
+
+    # @api private
+    def to_a
+      @tokens.map do |t|
+        {
+          bucket_name: t.bucket_name,
+          partition_id: t.partition_id,
+          partition_uuid: t.partition_uuid,
+          sequence_number: t.sequence_number,
+        }
+      end
+    end
   end
 end

data/lib/couchbase/query_options.rb

@@ -0,0 +1,256 @@
+#    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 'json'
+
+module Couchbase
+  class Cluster
+    class QueryOptions
+      # @return [Integer] Timeout in milliseconds
+      attr_accessor :timeout
+
+      # @return [Boolean] Allows turning this request into a prepared statement query
+      attr_accessor :adhoc
+
+      # @return [String] Provides a custom client context ID for this query
+      attr_accessor :client_context_id
+
+      # @return [Integer] Allows overriding the default maximum parallelism for the query execution on the server side.
+      attr_accessor :max_parallelism
+
+      # @return [Boolean] Allows explicitly marking a query as being readonly and not mutating any 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
+
+      # @return [Integer] Supports customizing the number of items execution operators can batch for fetch from the KV layer on the server.
+      attr_accessor :pipeline_batch
+
+      # @return [Integer] Allows customizing the maximum number of items each execution operator can buffer between various operators on the
+      #   server.
+      attr_accessor :pipeline_cap
+
+      # @return [Boolean] Enables per-request metrics in the trailing section of the query
+      attr_accessor :metrics
+
+      # @return [:off, :phases, :timings] Customize server profile level for this query
+      attr_accessor :profile
+
+      # Associate scope qualifier (also known as +query_context+) with the query.
+      #
+      # The qualifier must be in form +{bucket_name}.{scope_name}+ or +default:{bucket_name}.{scope_name}+.
+      #
+      # @api uncommitted
+      # @return [String]
+      attr_accessor :scope_qualifier
+
+      # @return [:not_bounded, :request_plus]
+      attr_reader :scan_consistency
+
+      # @api private
+      # @return [MutationState]
+      attr_reader :mutation_state
+
+      # @api private
+      # @return [Hash<String => #to_json>]
+      attr_reader :raw_parameters
+
+      # @yieldparam [QueryOptions] self
+      def initialize
+        @timeout = 75_000 # ms
+        @adhoc = true
+        @raw_parameters = {}
+        @positional_parameters = nil
+        @named_parameters = nil
+        @scan_consistency = nil
+        @mutation_state = nil
+        @scope_qualifier = 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)
+        @raw_parameters[key] = JSON.generate(value)
+      end
+
+      # Customizes the consistency guarantees for this query
+      #
+      # @note overrides consistency level set by {#consistent_with}
+      #
+      # [+: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).
+      #
+      # [+: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] 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
+
+      # Sets positional parameters for the query
+      #
+      # @param [Array] positional the list of parameters that have to be substituted in the statement
+      def positional_parameters(positional)
+        @positional_parameters = positional
+        @named_parameters = nil
+      end
+
+      # @api private
+      # @return [Array<String>, nil]
+      def export_positional_parameters
+        @positional_parameters&.map { |p| JSON.dump(p) }
+      end
+
+      # Sets named parameters for the query
+      #
+      # @param [Hash] named the key/value map of the parameters to substitute in the statement
+      def named_parameters(named)
+        @named_parameters = named
+        @positional_parameters = nil
+      end
+
+      # @api private
+      # @return [Hash<String => String>, nil]
+      def export_named_parameters
+        @named_parameters&.each_with_object({}) { |(n, v), o| o[n.to_s] = JSON.dump(v) }
+      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 [Array<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
+  end
+end

data/lib/couchbase/scope.rb

@@ -13,13 +13,14 @@
 #  limitations under the License.
 
 require "couchbase/collection"
+require "couchbase/query_options"
 
 module Couchbase
   class Scope
     attr_reader :bucket_name
     attr_reader :name
 
-    alias_method :inspect, :to_s
+    alias inspect to_s
 
     # @param [Couchbase::Backend] backend
     # @param [String] bucket_name name of the bucket
@@ -30,13 +31,6 @@ module Couchbase
       @name = scope_name
     end
 
-    # Opens the default collection for this scope
-    #
-    # @return [Collection]
-    def default_collection
-      Collection.new(@backend, @bucket_name, @name, :_default)
-    end
-
     # Opens the default collection for this scope
     #
     # @param [String] collection_name name of the collection
@@ -45,5 +39,64 @@ module Couchbase
     def collection(collection_name)
       Collection.new(@backend, @bucket_name, @name, collection_name)
     end
+
+    # Performs a query against the query (N1QL) services.
+    #
+    # The query will be implicitly scoped using current bucket and scope names.
+    #
+    # @see QueryOptions#scope_qualifier
+    # @see Cluster#query
+    #
+    # @param [String] statement the N1QL query statement
+    # @param [QueryOptions] options the custom options for this query
+    #
+    # @return [QueryResult]
+    def query(statement, options = Cluster::QueryOptions.new)
+      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.export_positional_parameters,
+        named_parameters: options.export_named_parameters,
+        scope_name: @name,
+        bucket_name: @bucket_name,
+        scope_qualifier: options.scope_qualifier,
+        raw_parameters: options.raw_parameters,
+        scan_consistency: options.scan_consistency,
+        mutation_state: options.mutation_state&.to_a,
+      })
+
+      Cluster::QueryResult.new do |res|
+        res.meta_data = Cluster::QueryMetaData.new do |meta|
+          meta.status = resp[:meta][:status]
+          meta.request_id = resp[:meta][:request_id]
+          meta.client_context_id = resp[:meta][:client_context_id]
+          meta.signature = JSON.parse(resp[:meta][:signature]) if resp[:meta][:signature]
+          meta.profile = JSON.parse(resp[:meta][:profile]) if resp[:meta][:profile]
+          meta.metrics = Cluster::QueryMetrics.new do |metrics|
+            if resp[:meta][:metrics]
+              metrics.elapsed_time = resp[:meta][:metrics][:elapsed_time]
+              metrics.execution_time = resp[:meta][:metrics][:execution_time]
+              metrics.sort_count = resp[:meta][:metrics][:sort_count]
+              metrics.result_count = resp[:meta][:metrics][:result_count]
+              metrics.result_size = resp[:meta][:metrics][:result_size]
+              metrics.mutation_count = resp[:meta][:metrics][:mutation_count]
+              metrics.error_count = resp[:meta][:metrics][:error_count]
+              metrics.warning_count = resp[:meta][:metrics][:warning_count]
+            end
+          end
+          res[:warnings] = resp[:warnings].map { |warn| QueryWarning.new(warn[:code], warn[:message]) } if resp[:warnings]
+        end
+        res.instance_variable_set("@rows", resp[:rows])
+      end
+    end
   end
 end