mongo 1.12.5 → 2.0.0.beta

data/lib/mongo/operation/batchable.rb

@@ -0,0 +1,103 @@
+# Copyright (C) 2014-2015 MongoDB, 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.
+
+module Mongo
+
+  module Operation
+
+    # This module contains common functionality for splitting an operation
+    # into the specified number of children operations.
+    # An operation including this module must provide a method called
+    # #batch_key. It specifies the key of the spec array element to split.
+    #
+    # @since 2.0.0
+    module Batchable
+
+      # Slices this operation into the specified number of children operations.
+      #
+      # @params [ Integer ] n_batches The number of children operations to split
+      #   this one into.
+      #
+      # @return [ Array ] An array of children operations.
+      #
+      # @since 2.0.0
+      def batch(n_batches)
+        items = spec[batch_key]
+        raise Exception, "Cannot batch" unless items.size >= n_batches
+
+        items_per_batch = items.size / n_batches
+        batches  = items.each_slice(items_per_batch).to_a
+        index_batches = indexes.each_slice(items_per_batch).to_a
+
+        # #each_slice makes groups containing exactly items_per_batch number of items.
+        # You could therefore end up with more groups than n_batches, so put the
+        # remaining items in the last group.
+        if batches.size > n_batches
+          batches[n_batches - 1] << batches.pop(batches.size - n_batches)
+          batches[-1].flatten!
+        end
+
+        if index_batches.size > n_batches
+          index_batches[n_batches - 1] << index_batches.pop(index_batches.size - n_batches)
+          index_batches[-1].flatten!
+        end
+
+        batches.each_with_index.inject([]) do |children, (batch, i)|
+          spec_copy = spec.dup
+          spec_copy[:indexes] = index_batches[i]
+          spec_copy[batch_key] = batch
+          children << self.class.new(spec_copy)
+        end
+      end
+
+      # Merge another operation with this one.
+      # Requires that the collection and database of the two ops are the same.
+      #
+      # @params[ Mongo::Operation ] The other operation.
+      #
+      # @return [ self ] This operation merged with the other one.
+      #
+      # @since 2.0.0
+      def merge!(other)
+        # @todo: use specific exception
+        raise Exception, "Cannot merge" unless self.class == other.class &&
+            coll_name == other.coll_name &&
+            db_name == other.db_name
+        @spec[batch_key] += other.spec[batch_key]
+        @spec[:indexes] = indexes + other.indexes
+        self
+      end
+
+      # Determine if the batch size exceeds a given maximum.
+      #
+      # @params[ Integer ] The max batch size.
+      #
+      # @return [ true, false ] If this operation exceeds the given batch size.
+      #
+      # @since 2.0.0
+      def valid_batch_size?(max)
+        spec[batch_key].size < max
+      end
+
+      # Whether this operation can be split into batches.
+      #
+      # @return [ true, false ] If this operation can be split into batches.
+      #
+      # @since 2.0.0
+      def batchable?
+        spec[batch_key].size > 1
+      end
+    end
+  end
+end

data/lib/mongo/operation/bulk_delete/result.rb

@@ -0,0 +1,197 @@
+# Copyright (C) 2014-2015 MongoDB, 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.
+
+module Mongo
+  module Operation
+    module Write
+      class BulkDelete
+
+        # Defines custom behaviour of results when deleting.
+        #
+        # @since 2.0.0
+        class Result < Operation::Result
+
+          attr_reader :indexes
+
+          # The aggregate number of deleted docs reported in the replies.
+          #
+          # @since 2.0.0
+          REMOVED = 'nRemoved'.freeze
+
+          # Gets the number of documents deleted.
+          #
+          # @example Get the deleted count.
+          #   result.n_removed
+          #
+          # @return [ Integer ] The number of documents deleted.
+          #
+          # @since 2.0.0
+          def n_removed
+            return 0 unless acknowledged?
+            @replies.reduce(0) do |n, reply|
+              n += reply.documents.first[N]
+            end
+          end
+
+          # Set a list of indexes of the operations creating this result.
+          #
+          # @example Set the list of indexes.
+          #   result.set_indexes([1,2,3])
+          #
+          # @return [ self ] The result.
+          #
+          # @since 2.0.0
+          def set_indexes(indexes)
+            @indexes = indexes
+            self
+          end
+
+          # Aggregate the write errors returned from this result.
+          #
+          # @example Aggregate the write errors.
+          #   result.aggregate_write_errors
+          #
+          # @return [ Array ] The aggregate write errors.
+          #
+          # @since 2.0.0
+          def aggregate_write_errors
+            @replies.reduce(nil) do |errors, reply|
+              if write_errors = reply.documents.first['writeErrors']
+                errors ||= []
+                write_errors.each do |write_error|
+                  errors << write_error.merge('index' => indexes[write_error['index']])
+                end
+              end
+              errors
+            end
+          end
+
+          # Aggregate the write concern errors returned from this result.
+          #
+          # @example Aggregate the write concern errors.
+          #   result.aggregate_write_concern_errors
+          #
+          # @return [ Array ] The aggregate write concern errors.
+          #
+          # @since 2.0.0
+          def aggregate_write_concern_errors
+            @replies.reduce(nil) do |errors, reply|
+              if write_concern_errors = reply.documents.first['writeConcernErrors']
+                errors ||= []
+                write_concern_errors.each do |write_concern_error|
+                  errors << write_concern_error.merge('index' =>
+                                                      indexes[write_concern_error['index']])
+                end
+              end
+              errors
+            end
+          end
+        end
+
+        # Defines custom behaviour of results when deleting.
+        # For server versions < 2.5.5 (that don't use write commands).
+        #
+        # @since 2.0.0
+        class LegacyResult < Operation::Result
+
+          attr_reader :indexes
+
+          # Gets the number of documents deleted.
+          #
+          # @example Get the deleted count.
+          #   result.n_removed
+          #
+          # @return [ Integer ] The number of documents deleted.
+          #
+          # @since 2.0.0
+          def n_removed
+            return 0 unless acknowledged?
+            @replies.reduce(0) do |n, reply|
+              n += reply.documents.first[N]
+            end
+          end
+
+          # Set a list of indexes of the operations creating this result.
+          #
+          # @example Set the list of indexes.
+          #   result.set_indexes([1,2,3])
+          #
+          # @return [ self ] The result.
+          #
+          # @since 2.0.0
+          def set_indexes(indexes)
+            @indexes = indexes
+            self
+          end
+
+          # Aggregate the write errors returned from this result.
+          #
+          # @example Aggregate the write errors.
+          #   result.aggregate_write_errors
+          #
+          # @return [ Array ] The aggregate write errors.
+          #
+          # @since 2.0.0
+          def aggregate_write_errors
+            @replies.each_with_index.reduce(nil) do |errors, (reply, i)|
+              if reply_write_errors?(reply)
+                errors ||= []
+                errors << { 'errmsg' => reply.documents.first[Error::ERROR],
+                            'index' => indexes[i],
+                            'code' => reply.documents.first[Error::CODE] }
+              end
+              errors
+            end
+          end
+
+          # Aggregate the write concern errors returned from this result.
+          #
+          # @example Aggregate the write concern errors.
+          #   result.aggregate_write_concern_errors
+          #
+          # @return [ Array ] The aggregate write concern errors.
+          #
+          # @since 2.0.0
+          def aggregate_write_concern_errors
+            @replies.each_with_index.reduce(nil) do |errors, (reply, i)|
+              # @todo: only raise if error is timeout
+              if error = reply_write_errors?(reply)
+                errors ||= []
+                note = reply.documents.first['wnote'] || reply.documents.first['jnote']
+                if note
+                  code = reply.documents.first['code'] || Error::BAD_VALUE
+                  error_string = "#{code}: #{note}"
+                else
+                  code = reply.documents.first['code'] || Error::UNKNOWN_ERROR
+                  error_string = "#{code}: #{error}"
+                end
+                errors << { 'errmsg' => error_string,
+                            'index' => indexes[i],
+                            'code' => code }
+              end
+              errors
+            end
+          end
+
+          private
+
+          def reply_write_errors?(reply)
+            reply.documents.first[Error::ERROR] ||
+              reply.documents.first[Error::ERRMSG]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongo/operation/bulk_insert/result.rb

@@ -0,0 +1,195 @@
+# Copyright (C) 2014-2015 MongoDB, 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.
+
+module Mongo
+  module Operation
+    module Write
+      class BulkInsert
+
+        # Defines custom behaviour of results when inserting.
+        #
+        # @since 2.0.0
+        class Result < Operation::Result
+
+          attr_reader :indexes
+
+          # Gets the number of documents inserted.
+          #
+          # @example Get the number of documents inserted.
+          #   result.n_inserted
+          #
+          # @return [ Integer ] The number of documents inserted.
+          #
+          # @since 2.0.0
+          def n_inserted
+            written_count
+          end
+
+          # Set a list of indexes of the operations creating this result.
+          #
+          # @example Set the list of indexes.
+          #   result.set_indexes([1,2,3])
+          #
+          # @return [ self ] The result.
+          #
+          # @since 2.0.0
+          def set_indexes(indexes)
+            @indexes = indexes
+            self
+          end
+
+          # Aggregate the write errors returned from this result.
+          #
+          # @example Aggregate the write errors.
+          #   result.aggregate_write_errors
+          #
+          # @return [ Array ] The aggregate write errors.
+          #
+          # @since 2.0.0
+          def aggregate_write_errors
+            @replies.reduce(nil) do |errors, reply|
+              if write_errors = reply.documents.first['writeErrors']
+                errors ||= []
+                write_errors.each do |write_error|
+                  errors << write_error.merge('index' => indexes[write_error['index']])
+                end
+              end
+              errors
+            end
+          end
+
+          # Aggregate the write concern errors returned from this result.
+          #
+          # @example Aggregate the write concern errors.
+          #   result.aggregate_write_concern_errors
+          #
+          # @return [ Array ] The aggregate write concern errors.
+          #
+          # @since 2.0.0
+          def aggregate_write_concern_errors
+            @replies.each_with_index.reduce(nil) do |errors, (reply, i)|
+              if write_concern_errors = reply.documents.first['writeConcernError']
+                errors ||= []
+                write_concern_errors.each do |write_concern_error|
+                  errors << write_concern_error.merge('index' =>
+                                                      indexes[write_concern_error['index']])
+                end
+              elsif reply.documents.first['errmsg']
+                errors ||= []
+                errors << { 'errmsg' => reply.documents.first['errmsg'],
+                            'index' => indexes[i],
+                            'code' => reply.documents.first['code'] }
+              end
+              errors
+            end
+          end
+        end
+
+        # Defines custom behaviour of results when inserting.
+        # For server versions < 2.5.5 (that don't use write commands).
+        #
+        # @since 2.0.0
+        class LegacyResult < Operation::Result
+
+          attr_reader :indexes
+
+          # Gets the number of documents inserted.
+          #
+          # @example Get the number of documents inserted.
+          #   result.n_inserted
+          #
+          # @return [ Integer ] The number of documents inserted.
+          #
+          # @since 2.0.0
+          def n_inserted
+            return 0 unless acknowledged?
+            @replies.reduce(0) do |n, reply|
+              n += 1 unless reply_write_errors?(reply)
+              n
+            end
+          end
+
+          # Set a list of indexes of the operations creating this result.
+          #
+          # @example Set the list of indexes.
+          #   result.set_indexes([1,2,3])
+          #
+          # @return [ self ] The result.
+          #
+          # @since 2.0.0
+          def set_indexes(indexes)
+            @indexes = indexes
+            self
+          end
+
+          # Aggregate the write errors returned from this result.
+          #
+          # @example Aggregate the write errors.
+          #   result.aggregate_write_errors
+          #
+          # @return [ Array ] The aggregate write errors.
+          #
+          # @since 2.0.0
+          def aggregate_write_errors
+            @replies.each_with_index.reduce(nil) do |errors, (reply, i)|
+              if reply_write_errors?(reply)
+                errors ||= []
+                errors << { 'errmsg' => reply.documents.first[Error::ERROR],
+                            'index' => indexes[i],
+                            'code' => reply.documents.first[Error::CODE] }
+              end
+              errors
+            end
+          end
+
+          # Aggregate the write concern errors returned from this result.
+          #
+          # @example Aggregate the write concern errors.
+          #   result.aggregate_write_concern_errors
+          #
+          # @return [ Array ] The aggregate write concern errors.
+          #
+          # @since 2.0.0
+          def aggregate_write_concern_errors
+            @replies.each_with_index.reduce(nil) do |errors, (reply, i)|
+              # @todo: only raise if error is timeout
+              if error = reply_write_errors?(reply)
+                errors ||= []
+                note = reply.documents.first['wnote'] || reply.documents.first['jnote']
+                if note
+                  code = reply.documents.first['code'] || "bad value constant"
+                  error_string = "#{code}: #{note}"
+                else
+                  code = reply.documents.first['code'] || "unknown error constant"
+                  error_string = "#{code}: #{error}"
+                end
+                errors << { 'errmsg' => error_string,
+                            'index' => indexes[i],
+                            'code' => code }
+              end
+              errors
+            end
+          end
+
+          private
+
+          def reply_write_errors?(reply)
+            reply.documents.first[Error::ERROR] ||
+              reply.documents.first[Error::ERRMSG]
+          end
+        end
+      end
+    end
+  end
+end