couchbase 3.0.0.alpha.3-universal-darwin-19 → 3.0.1-universal-darwin-19

data/lib/couchbase/datastructures/couchbase_set.rb

@@ -0,0 +1,139 @@
+#    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"
+require "couchbase/errors"
+
+module Couchbase
+  module Datastructures
+    # A {CouchbaseSet} is implements +Enumerable+ interface and backed by {Collection} document (more specifically
+    # a JSON array).
+    #
+    # Note: sets are restricted to containing primitive types only due to server-side comparison restrictions.
+    class CouchbaseSet
+      include Enumerable
+
+      # Create a new List, backed by the document identified by +id+ in +collection+.
+      #
+      # @param [String] id the id of the document to back the set.
+      # @param [Collection] collection the collection through which to interact with the document.
+      # @param [CouchbaseListOptions] options customization of the datastructure
+      def initialize(id, collection, options = CouchbaseSetOptions.new)
+        @id = id
+        @collection = collection
+        @options = options
+        @cas = 0
+      end
+
+      # Calls the given block once for each element in the set, passing that element as a parameter.
+      #
+      # @yieldparam [Object] item
+      #
+      # @return [CouchbaseSet, Enumerable]
+      def each
+        if block_given?
+          begin
+            result = @collection.get(@id, @options.get_options)
+            current = result.content
+            @cas = result.cas
+          rescue Error::DocumentNotFound
+            current = []
+            @cas = 0
+          end
+          current.each do |entry|
+            yield entry
+          end
+          self
+        else
+          enum_for(:each)
+        end
+      end
+
+      # @return [Integer] returns the number of elements in the set.
+      def length
+        result = @collection.lookup_in(@id, [
+                                         LookupInSpec.count(""),
+                                       ], @options.lookup_in_options)
+        result.content(0)
+      rescue Error::DocumentNotFound
+        0
+      end
+
+      alias size length
+
+      # @return [Boolean] returns true if set is empty
+      def empty?
+        size.zero?
+      end
+
+      # Adds the given value to the set
+      #
+      # @param [Object] obj
+      # @return [CouchbaseSet]
+      def add(obj)
+        begin
+          @collection.mutate_in(@id, [
+                                  MutateInSpec.array_add_unique("", obj),
+                                ], @options.mutate_in_options)
+        rescue Error::PathExists
+          # ignore
+        end
+        self
+      end
+
+      # Removes all elements from the set
+      def clear
+        @collection.remove(@id, @options.remove_options)
+        nil
+      rescue Error::DocumentNotFound
+        nil
+      end
+
+      # Deletes the given object from the set.
+      #
+      # @return [Boolean] true if the value has been removed
+      def delete(obj)
+        result = @collection.get(@id)
+        idx = result.content.index(obj)
+        return false unless idx
+
+        options = Collection::MutateInOptions.new
+        options.cas = result.cas
+        @collection.mutate_in(@id, [
+                                MutateInSpec.remove("[#{idx}]"),
+                              ], options)
+        true
+      rescue Error::CasMismatch
+        retry
+      rescue Error::DocumentNotFound
+        false
+      end
+    end
+
+    class CouchbaseSetOptions
+      attr_accessor :get_options
+      attr_accessor :lookup_in_options
+      attr_accessor :mutate_in_options
+      attr_accessor :remove_options
+
+      def initialize
+        @get_options = Collection::GetOptions.new
+        @remove_options = Collection::RemoveOptions.new
+        @lookup_in_options = Collection::LookupInOptions.new
+        @mutate_in_options = Collection::MutateInOptions.new
+        @mutate_in_options.store_semantics = :upsert
+      end
+    end
+  end
+end

data/lib/couchbase/errors.rb

@@ -14,211 +14,224 @@
 
 module Couchbase
   module Error
+    class CouchbaseError < StandardError
+    end
+
     # Common exceptions
 
-    class RequestCanceled < StandardError
+    class RequestCanceled < CouchbaseError
     end
 
-    class InvalidArgument < StandardError
+    class InvalidArgument < ArgumentError
     end
 
-    class ServiceNotAvailable < StandardError
+    class ServiceNotAvailable < CouchbaseError
     end
 
-    class InternalServerFailure < StandardError
+    class InternalServerFailure < CouchbaseError
     end
 
-    class AuthenticationFailure < StandardError
+    class AuthenticationFailure < CouchbaseError
     end
 
-    class TemporaryFailure < StandardError
+    class TemporaryFailure < CouchbaseError
     end
 
-    class ParsingFailure < StandardError
+    class ParsingFailure < CouchbaseError
     end
 
-    class CasMismatch < StandardError
+    class CasMismatch < CouchbaseError
     end
 
-    class BucketNotFound < StandardError
+    class BucketNotFound < CouchbaseError
     end
 
-    class CollectionNotFound < StandardError
+    class CollectionNotFound < CouchbaseError
     end
 
-    class ScopeNotFound < StandardError
+    class ScopeNotFound < CouchbaseError
     end
 
-    class IndexNotFound < StandardError
+    class IndexNotFound < CouchbaseError
     end
 
-    class IndexExists < StandardError
+    class IndexExists < CouchbaseError
     end
 
-    class EncodingFailure < StandardError
+    class EncodingFailure < CouchbaseError
     end
 
-    class DecodingFailure < StandardError
+    class DecodingFailure < CouchbaseError
     end
 
-    class UnsupportedOperation < StandardError
+    class UnsupportedOperation < CouchbaseError
     end
 
-    class AmbiguousTimeout < StandardError
+    class Timeout < CouchbaseError
     end
 
-    class UnambiguousTimeout < StandardError
+    class AmbiguousTimeout < Timeout
     end
 
-    class FeatureNotAvailable < StandardError
+    class UnambiguousTimeout < Timeout
+    end
+
+    class FeatureNotAvailable < CouchbaseError
     end
 
     # KeyValue exceptions
 
-    class DocumentNotFound < StandardError
+    class DocumentNotFound < CouchbaseError
     end
 
-    class DocumentIrretrievable < StandardError
+    class DocumentIrretrievable < CouchbaseError
     end
 
-    class DocumentLocked < StandardError
+    class DocumentLocked < CouchbaseError
     end
 
-    class ValueTooLarge < StandardError
+    class ValueTooLarge < CouchbaseError
     end
 
-    class DocumentExists < StandardError
+    class DocumentExists < CouchbaseError
     end
 
-    class DurabilityLevelNotAvailable < StandardError
+    class DurabilityLevelNotAvailable < CouchbaseError
     end
 
-    class DurabilityImpossible < StandardError
+    class DurabilityImpossible < CouchbaseError
     end
 
-    class DurabilityAmbiguous < StandardError
+    class DurabilityAmbiguous < CouchbaseError
     end
 
-    class DurableWriteInProgress < StandardError
+    class DurableWriteInProgress < CouchbaseError
     end
 
-    class DurableWriteReCommitInProgress < StandardError
+    class DurableWriteReCommitInProgress < CouchbaseError
     end
 
-    class PathNotFound < StandardError
+    class PathNotFound < CouchbaseError
     end
 
-    class PathMismatch < StandardError
+    class PathMismatch < CouchbaseError
     end
 
-    class PathInvalid < StandardError
+    class PathInvalid < CouchbaseError
     end
 
-    class PathTooDeep < StandardError
+    class PathTooDeep < CouchbaseError
     end
 
-    class PathTooBig < StandardError
+    class PathTooBig < CouchbaseError
     end
 
-    class ValueTooDeep < StandardError
+    class ValueTooDeep < CouchbaseError
     end
 
-    class ValueInvalid < StandardError
+    class ValueInvalid < CouchbaseError
     end
 
-    class DocumentNotJson < StandardError
+    class DocumentNotJson < CouchbaseError
     end
 
-    class NumberTooBig < StandardError
+    class NumberTooBig < CouchbaseError
     end
 
-    class DeltaInvalid < StandardError
+    class DeltaInvalid < CouchbaseError
     end
 
-    class PathExists < StandardError
+    class PathExists < CouchbaseError
     end
 
-    class XattrUnknownMacro < StandardError
+    class XattrUnknownMacro < CouchbaseError
     end
 
-    class XattrInvalidKeyCombo < StandardError
+    class XattrInvalidKeyCombo < CouchbaseError
     end
 
-    class XattrUnknownVirtualAttribute < StandardError
+    class XattrUnknownVirtualAttribute < CouchbaseError
     end
 
-    class XattrCannotModifyVirtualAttribute < StandardError
+    class XattrCannotModifyVirtualAttribute < CouchbaseError
     end
 
     # Query exceptions
 
-    class PlanningFailure < StandardError
+    class PlanningFailure < CouchbaseError
     end
 
-    class IndexFailure < StandardError
+    class IndexFailure < CouchbaseError
     end
 
-    class PreparedStatementFailure < StandardError
+    class PreparedStatementFailure < CouchbaseError
     end
 
-
     # Analytics exceptions
 
-    class CompilationFailure < StandardError
+    class CompilationFailure < CouchbaseError
     end
 
-    class JobQueueFull < StandardError
+    class JobQueueFull < CouchbaseError
     end
 
-    class DatasetNotFound < StandardError
+    class DatasetNotFound < CouchbaseError
     end
 
-    class DatasetExists < StandardError
+    class DatasetExists < CouchbaseError
     end
 
-    class DataverseExists < StandardError
+    class DataverseExists < CouchbaseError
     end
 
-    class DataverseNotFound < StandardError
+    class DataverseNotFound < CouchbaseError
+    end
+
+    class LinkNotFound < CouchbaseError
+    end
+
+    # Search exceptions
+
+    class IndexNotReady < CouchbaseError
     end
 
-    class LinkNotFound < StandardError
+    class ConsistencyMismatch < CouchbaseError
     end
 
     # View exceptions
 
-    class DesignDocumentNotFound < StandardError
+    class DesignDocumentNotFound < CouchbaseError
     end
 
-    class ViewNotFound < StandardError
+    class ViewNotFound < CouchbaseError
     end
 
     # Management exceptions
 
-    class CollectionExists < StandardError
+    class CollectionExists < CouchbaseError
     end
 
-    class ScopeExists < StandardError
+    class ScopeExists < CouchbaseError
     end
 
-    class UserExists < StandardError
+    class UserExists < CouchbaseError
     end
 
-    class BucketExists < StandardError
+    class BucketExists < CouchbaseError
     end
 
-    class BucketNotFlushable < StandardError
+    class BucketNotFlushable < CouchbaseError
     end
 
-    class GroupNotFound < StandardError
+    class GroupNotFound < CouchbaseError
     end
 
-    class UserNotFound < StandardError
+    class UserNotFound < CouchbaseError
     end
 
     # Library-specific exceptions
 
-    class BackendError < StandardError
+    class BackendError < CouchbaseError
     end
   end
-end
+end

data/lib/couchbase/json_transcoder.rb

@@ -23,9 +23,9 @@ module Couchbase
     end
 
     # @param [String, nil] blob string of bytes, containing encoded representation of the document
-    # @param [Integer, :json] flags bit field, describing how the data encoded
+    # @param [Integer, :json] _flags bit field, describing how the data encoded
     # @return Object decoded document
-    def decode(blob, flags)
+    def decode(blob, _flags)
       JSON.parse(blob) unless blob.nil?
     end
   end

data/lib/couchbase/management/analytics_index_manager.rb

@@ -17,7 +17,7 @@ require "couchbase/errors"
 module Couchbase
   module Management
     class AnalyticsIndexManager
-      alias_method :inspect, :to_s
+      alias inspect to_s
 
       # @param [Couchbase::Backend] backend
       def initialize(backend)
@@ -29,18 +29,34 @@ module Couchbase
       # @param [String] dataverse_name
       # @param [CreateDataverseOptions] options
       #
+      # @return [void]
+      #
       # @raise [ArgumentError]
       # @raise [Error::DataverseExists]
-      def create_dataverse(dataverse_name, options = CreateDataverseOptions.new) end
+      def create_dataverse(dataverse_name, options = CreateDataverseOptions.new)
+        @backend.analytics_dataverse_create(
+          dataverse_name,
+          options.ignore_if_exists,
+          options.timeout
+        )
+      end
 
       # Drops a dataverse
       #
       # @param [String] dataverse_name name of the dataverse
       # @param [DropDataverseOptions] options
       #
+      # @return [void]
+      #
       # @raise [ArgumentError]
       # @raise [Error::DataverseNotFound]
-      def drop_dataverse(dataverse_name, options = DropDataverseOptions.new) end
+      def drop_dataverse(dataverse_name, options = DropDataverseOptions.new)
+        @backend.analytics_dataverse_drop(
+          dataverse_name,
+          options.ignore_if_does_not_exist,
+          options.timeout
+        )
+      end
 
       # Creates a new dataset
       #
@@ -48,18 +64,39 @@ module Couchbase
       # @param [String] bucket_name name of the bucket
       # @param [CreateDatasetOptions] options
       #
+      # @return [void]
+      #
       # @raise [ArgumentError]
       # @raise [Error::DatasetExists]
-      def create_dataset(dataset_name, bucket_name, options = CreateDatasetOptions.new) end
+      # @raise [Error::LinkNotFound]
+      def create_dataset(dataset_name, bucket_name, options = CreateDatasetOptions.new)
+        @backend.analytics_dataset_create(
+          dataset_name,
+          bucket_name,
+          options.condition,
+          options.dataverse_name,
+          options.ignore_if_exists,
+          options.timeout
+        )
+      end
 
       # Drops a dataset
       #
       # @param [String] dataset_name name of the dataset
-      # @param [DropDataverseOptions] options
-      # 
+      # @param [DropDatasetOptions] options
+      #
+      # @return [void]
+      #
       # @raise [ArgumentError]
       # @raise [Error::DatasetNotFound]
-      def drop_dataset(dataset_name, options = DropDatasetOptions.new) end
+      def drop_dataset(dataset_name, options = DropDatasetOptions.new)
+        @backend.analytics_dataset_drop(
+          dataset_name,
+          options.dataverse_name,
+          options.ignore_if_does_not_exist,
+          options.timeout
+        )
+      end
 
       # Gets all datasets
       #
@@ -67,19 +104,38 @@ module Couchbase
       #
       # @return [Array<AnalyticsDataset>]
       def get_all_datasets(options = GetAllDatasetsOptions.new)
-        # SELECT d.* FROM Metadata.`Dataset` d WHERE d.DataverseName <> "Metadata"
+        resp = @backend.analytics_dataset_get_all(options.timeout)
+        resp.map do |entry|
+          AnalyticsDataset.new do |dataset|
+            dataset.name = entry[:name]
+            dataset.dataverse_name = entry[:dataverse_name]
+            dataset.link_name = entry[:link_name]
+            dataset.bucket_name = entry[:bucket_name]
+          end
+        end
       end
 
       # Creates a new index
       #
       # @param [String] index_name name of the index
       # @param [String] dataset_name name of the dataset
-      # @param [Hash<String, String>] fields mapping of the field name to field type
+      # @param [Hash<String => String>] fields mapping of the field name to field type
       # @param [CreateIndexOptions] options
       #
+      # @return [void]
+      #
       # @raise [ArgumentError]
       # @raise [Error::IndexExists]
-      def create_index(index_name, dataset_name, fields, options = CreateIndexOptions.new) end
+      def create_index(index_name, dataset_name, fields, options = CreateIndexOptions.new)
+        @backend.analytics_index_create(
+          index_name,
+          dataset_name,
+          fields.entries,
+          options.dataverse_name,
+          options.ignore_if_exists,
+          options.timeout
+        )
+      end
 
       # Drops an index
       #
@@ -87,9 +143,19 @@ module Couchbase
       # @param [String] dataset_name name of the dataset
       # @param [DropIndexOptions] options
       #
+      # @return [void]
+      #
       # @raise [ArgumentError]
       # @raise [Error::IndexNotFound]
-      def drop_index(index_name, dataset_name, options = DropIndexOptions.new) end
+      def drop_index(index_name, dataset_name, options = DropIndexOptions.new)
+        @backend.analytics_index_drop(
+          index_name,
+          dataset_name,
+          options.dataverse_name,
+          options.ignore_if_does_not_exist,
+          options.timeout
+        )
+      end
 
       # Gets all indexes
       #
@@ -97,36 +163,63 @@ module Couchbase
       #
       # @return [Array<AnalyticsIndex>]
       def get_all_indexes(options = GetAllIndexesOptions.new)
-        # SELECT d.* FROM Metadata.`Index` d WHERE d.DataverseName <> "Metadata"
+        resp = @backend.analytics_index_get_all(options.timeout)
+        resp.map do |entry|
+          AnalyticsIndex.new do |dataset|
+            dataset.name = entry[:name]
+            dataset.dataverse_name = entry[:dataverse_name]
+            dataset.dataset_name = entry[:dataset_name]
+            dataset.is_primary = entry[:is_primary]
+          end
+        end
       end
 
       # Connects a link
       #
       # @param [ConnectLinkOptions] options
       #
+      # @return [void]
+      #
       # @raise [ArgumentError]
       # @raise [Error::LinkNotFound]
-      def connect_link(options = ConnectLinkOptions.new) end
+      def connect_link(options = ConnectLinkOptions.new)
+        @backend.analytics_link_connect(
+          options.link_name,
+          options.force,
+          options.dataverse_name,
+          options.timeout
+        )
+      end
 
       # Disconnects a link,
       #
       # @param [DisconnectLinkOptions] options
       #
+      # @return [void]
+      #
       # @raise [ArgumentError]
       # @raise [Error::LinkNotFound]
-      def disconnect_link(options = DisconnectLinkOptions.new) end
+      def disconnect_link(options = DisconnectLinkOptions.new)
+        @backend.analytics_link_disconnect(
+          options.link_name,
+          options.dataverse_name,
+          options.timeout
+        )
+      end
 
       # Gets the pending mutations for all datasets.
-      # 
+      #
       # @note If a link is disconnected then it will return no results. If all links are disconnected, then
       # an empty object is returned.
       #
       # @param [GetPendingMutationsOptions] options
       #
-      # @return [Hash<String, Integer>] dictionary, where keys are dataset coordinates encoded as +"dataverse.dataset"+
+      # @return [Hash<String => Integer>] dictionary, where keys are dataset coordinates encoded as +"dataverse.dataset"+
       #   and values are number of mutations for given dataset.
       def get_pending_mutations(options = GetPendingMutationsOptions.new)
-        # GET http://localhost:8095/analytics/node/agg/stats/remaining
+        @backend.analytics_get_pending_mutations(
+          options.timeout
+        )
       end
 
       class CreateDataverseOptions
@@ -136,6 +229,7 @@ module Couchbase
         # @return [Integer] the time in milliseconds allowed for the operation to complete
         attr_accessor :timeout
 
+        # @yieldparam [CreateDataverseOptions]
         def initialize
           @ignore_if_exists = false
           yield self if block_given?
@@ -144,11 +238,12 @@ module Couchbase
 
       class DropDataverseOptions
         # @return [Boolean] ignore if the dataverse does not exists
-        attr_accessor :ignore_if_not_exists
+        attr_accessor :ignore_if_does_not_exist
 
         # @return [Integer] the time in milliseconds allowed for the operation to complete
         attr_accessor :timeout
 
+        # @yieldparam [DropDataverseOptions]
         def initialize
           @ignore_if_exists = false
           yield self if block_given?
@@ -168,6 +263,7 @@ module Couchbase
         # @return [Integer] the time in milliseconds allowed for the operation to complete
         attr_accessor :timeout
 
+        # @yieldparam [CreateDatasetOptions]
         def initialize
           @ignore_if_exists = false
           yield self if block_given?
@@ -176,7 +272,7 @@ module Couchbase
 
       class DropDatasetOptions
         # @return [Boolean] ignore if the dataset does not exists
-        attr_accessor :ignore_if_not_exists
+        attr_accessor :ignore_if_does_not_exist
 
         # @return [String] The name of the dataverse to use (defaults to +nil+)
         attr_accessor :dataverse_name
@@ -184,8 +280,9 @@ module Couchbase
         # @return [Integer] the time in milliseconds allowed for the operation to complete
         attr_accessor :timeout
 
+        # @yieldparam [DropDatasetOptions]
         def initialize
-          @ignore_if_not_exists = false
+          @ignore_if_does_not_exist = false
           yield self if block_given?
         end
       end
@@ -194,8 +291,8 @@ module Couchbase
         # @return [Integer] the time in milliseconds allowed for the operation to complete
         attr_accessor :timeout
 
+        # @yieldparam [GetAllDatasetsOptions]
         def initialize
-          @ignore_if_not_exists = false
           yield self if block_given?
         end
       end
@@ -210,6 +307,7 @@ module Couchbase
         # @return [Integer] the time in milliseconds allowed for the operation to complete
         attr_accessor :timeout
 
+        # @yieldparam [CreateIndexOptions]
         def initialize
           @ignore_if_exists = false
           yield self if block_given?
@@ -218,7 +316,7 @@ module Couchbase
 
       class DropIndexOptions
         # @return [Boolean] ignore if the index does not exists
-        attr_accessor :ignore_if_not_exists
+        attr_accessor :ignore_if_does_not_exist
 
         # @return [String] The name of the dataverse to use (defaults to +nil+)
         attr_accessor :dataverse_name
@@ -226,8 +324,9 @@ module Couchbase
         # @return [Integer] the time in milliseconds allowed for the operation to complete
         attr_accessor :timeout
 
+        # @yieldparam [DropIndexOptions]
         def initialize
-          @ignore_if_not_exists = false
+          @ignore_if_does_not_exist = false
           yield self if block_given?
         end
       end
@@ -236,6 +335,7 @@ module Couchbase
         # @return [Integer] the time in milliseconds allowed for the operation to complete
         attr_accessor :timeout
 
+        # @yieldparam [GetAllIndexesOptions]
         def initialize
           yield self if block_given?
         end
@@ -246,7 +346,7 @@ module Couchbase
         attr_accessor :link_name
 
         # @return [Boolean] Whether to force link creation even if the bucket UUID changed, for example due to the
-        # bucket being deleted and recreated (defaults to +false+)
+        #  bucket being deleted and recreated (defaults to +false+)
         attr_accessor :force
 
         # @return [String] The name of the dataverse to use (defaults to +nil+)
@@ -255,6 +355,7 @@ module Couchbase
         # @return [Integer] the time in milliseconds allowed for the operation to complete
         attr_accessor :timeout
 
+        # @yieldparam [ConnectLinkOptions]
         def initialize
           @link_name = "Local"
           @force = false
@@ -272,6 +373,7 @@ module Couchbase
         # @return [Integer] the time in milliseconds allowed for the operation to complete
         attr_accessor :timeout
 
+        # @yieldparam [DisconnectLinkOptions]
         def initialize
           @link_name = "Local"
           yield self if block_given?
@@ -282,6 +384,7 @@ module Couchbase
         # @return [Integer] the time in milliseconds allowed for the operation to complete
         attr_accessor :timeout
 
+        # @yieldparam [GetPendingMutationsOptions]
         def initialize
           yield self if block_given?
         end
@@ -300,6 +403,11 @@ module Couchbase
 
       # @return [String]
       attr_accessor :bucket_name
+
+      # @yieldparam [AnalyticsDataset]
+      def initialize
+        yield self if block_given?
+      end
     end
 
     class AnalyticsIndex
@@ -314,6 +422,12 @@ module Couchbase
 
       # @return [Boolean]
       attr_accessor :is_primary
+      alias primary? is_primary
+
+      # @yieldparam [AnalyticsIndex]
+      def initialize
+        yield self if block_given?
+      end
     end
   end
-end
+end