mongo 1.12.5 → 2.0.0

data/lib/mongo/operation/write/bulk/bulk_insert.rb

@@ -0,0 +1,129 @@
+# 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.
+
+require 'mongo/operation/write/bulk/bulk_insert/result'
+
+module Mongo
+  module Operation
+    module Write
+
+      # A MongoDB bulk insert operation.
+      # This class should only be used by the Bulk API.
+      #
+      # @note If a server with version >= 2.5.5 is being used, a write command
+      #   operation will be created and sent instead.
+      #
+      # @example Create the new insert operation.
+      #   Write::BulkInsert.new({
+      #     :documents => [{ :foo => 1 }],
+      #     :db_name => 'test',
+      #     :coll_name => 'test_coll',
+      #     :write_concern => write_concern,
+      #     :ordered => false
+      #   })
+      #
+      # @param [ Hash ] spec The specifications for the insert.
+      #
+      # @option spec :documents [ Array ] The documents to insert.
+      # @option spec :db_name [ String ] The name of the database.
+      # @option spec :coll_name [ String ] The name of the collection.
+      # @option spec :write_concern [ Mongo::WriteConcern ] The write concern.
+      # @option spec :ordered [ true, false ] Whether the operations should be
+      #   executed in order.
+      # @option spec :options [ Hash ] Options for the command, if it ends up being a
+      #   write command.
+      #
+      # @since 2.0.0
+      class BulkInsert
+        include Specifiable
+
+        # Execute the bulk insert operation.
+        #
+        # @example Execute the operation.
+        #   operation.execute(context)
+        #
+        # @param [ Mongo::Server::Context ] context The context for this operation.
+        #
+        # @return [ Result ] The operation result.
+        #
+        # @since 2.0.0
+        def execute(context)
+          if context.features.write_command_enabled?
+            execute_write_command(context)
+          else
+            execute_message(context)
+          end
+        end
+
+        private
+
+        def execute_write_command(context)
+          Result.new(Command::Insert.new(spec).execute(context))
+        end
+
+        def execute_message(context)
+          replies = []
+          messages.map do |m|
+            context.with_connection do |connection|
+              result = LegacyResult.new(connection.dispatch([ m, gle ].compact))
+              replies << result.reply
+              if stop_sending?(result)
+                return LegacyResult.new(replies)
+              end
+            end
+          end
+          LegacyResult.new(replies.compact.empty? ? nil : replies)
+        end
+
+        def stop_sending?(result)
+          ordered? && !result.successful?
+        end
+
+        # @todo put this somewhere else
+        def ordered?
+          @spec.fetch(:ordered, true)
+        end
+
+        def initialize_copy(original)
+          @spec = original.spec.dup
+          @spec[DOCUMENTS] = original.spec[DOCUMENTS].clone
+        end
+
+        def gle
+          gle_message = ( ordered? && write_concern.get_last_error.nil? ) ?
+                           Mongo::WriteConcern.get(:w => 1).get_last_error :
+                           write_concern.get_last_error
+          if gle_message
+            Protocol::Query.new(
+              db_name,
+              Database::COMMAND,
+              gle_message,
+              options.merge(limit: -1)
+            )
+          end
+        end
+
+        def messages
+          if ordered? || gle
+            documents.collect do |doc|
+              Protocol::Insert.new(db_name, coll_name, [ doc ], options)
+            end
+          else
+            [ Protocol::Insert.new(db_name, coll_name, documents, { :flags => [:continue_on_error] }) ]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongo/operation/write/bulk/bulk_mergable.rb

@@ -0,0 +1,67 @@
+# 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
+
+      module BulkMergable
+
+        # Aggregate the write errors returned from this result.
+        #
+        # @example Aggregate the write errors.
+        #   result.aggregate_write_errors([0, 1, 2, 3])
+        #
+        # @param [ Array ] indexes The indexes of each operation as they
+        #   were listed in the Bulk API.
+        #
+        # @return [ Array ] The aggregate write errors.
+        #
+        # @since 2.0.0
+        def aggregate_write_errors(indexes)
+          @replies.reduce(nil) do |errors, reply|
+            if reply.documents.first['writeErrors']
+              write_errors = reply.documents.first['writeErrors'].collect do |we|
+                we.merge!('index' => indexes[we['index']])
+              end
+              (errors || []) << write_errors if write_errors
+            end
+          end
+        end
+
+        # Aggregate the write concern errors returned from this result.
+        #
+        # @example Aggregate the write concern errors.
+        #   result.aggregate_write_concern_errors([0, 1, 2, 3])
+        #
+        # @param [ Array ] indexes The indexes of each operation as they
+        #   were listed in the Bulk API.
+        #
+        # @return [ Array ] The aggregate write concern errors.
+        #
+        # @since 2.0.0
+        def aggregate_write_concern_errors(indexes)
+          @replies.each_with_index.reduce(nil) do |errors, (reply, i)|
+            if write_concern_errors = reply.documents.first['writeConcernErrors']
+              (errors || []) << write_concern_errors.reduce(nil) do |errs, wce|
+                  wce.merge!('index' => indexes[wce['index']])
+                  (errs || []) << write_concern_error
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongo/operation/write/bulk/bulk_update/result.rb

@@ -0,0 +1,162 @@
+# 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.
+
+require 'mongo/operation/write/bulk/bulk_mergable'
+require 'mongo/operation/write/bulk/legacy_bulk_mergable'
+
+module Mongo
+  module Operation
+    module Write
+      class BulkUpdate
+
+        # Defines custom behaviour of results when updating.
+        #
+        # @since 2.0.0
+        class Result < Operation::Result
+          include BulkMergable
+
+          # The number of modified docs field in the result.
+          #
+          # @since 2.0.0
+          MODIFIED = 'nModified'.freeze
+
+          # The upserted docs field in the result.
+          #
+          # @since 2.0.0
+          UPSERTED = 'upserted'.freeze
+
+          # Gets the number of documents upserted.
+          #
+          # @example Get the upserted count.
+          #   result.n_upserted
+          #
+          # @return [ Integer ] The number of documents upserted.
+          #
+          # @since 2.0.0
+          def n_upserted
+            return 0 unless acknowledged?
+            @replies.reduce(0) do |n, reply|
+              if upsert?(reply)
+                n += 1
+              else
+                n += 0
+              end
+            end
+          end
+
+          # Gets the number of documents matched.
+          #
+          # @example Get the matched count.
+          #   result.n_matched
+          #
+          # @return [ Integer ] The number of documents matched.
+          #
+          # @since 2.0.0
+          def n_matched
+            return 0 unless acknowledged?
+            @replies.reduce(0) do |n, reply|
+              if upsert?(reply)
+                n += 0
+              else
+                n += reply.documents.first[N]
+              end
+            end
+          end
+
+          # Gets the number of documents modified.
+          #
+          # @example Get the modified count.
+          #   result.n_modified
+          #
+          # @return [ Integer ] The number of documents modified.
+          #
+          # @since 2.0.0
+          def n_modified
+            return 0 unless acknowledged?
+            @replies.reduce(0) do |n, reply|
+              n += reply.documents.first[MODIFIED] || 0
+            end
+          end
+
+          private
+
+          def upsert?(reply)
+            reply.documents.first[UPSERTED]
+          end
+        end
+
+        # Defines custom behaviour of results when updating.
+        # For server versions < 2.5.5 (that don't use write commands).
+        #
+        # @since 2.0.0
+        class LegacyResult < Operation::Result
+          include LegacyBulkMergable
+
+          # The updated existing field in the result.
+          #
+          # @since 2.0.0
+          UPDATED_EXISTING = 'updatedExisting'.freeze
+
+          # Gets the number of documents upserted.
+          #
+          # @example Get the upserted count.
+          #   result.n_upserted
+          #
+          # @return [ Integer ] The number of documents upserted.
+          #
+          # @since 2.0.0
+          def n_upserted
+            return 0 unless acknowledged?
+            @replies.reduce(0) do |n, reply|
+              if upsert?(reply)
+                n += reply.documents.first[N]
+              else
+                n
+              end
+            end
+          end
+
+          # Gets the number of documents matched.
+          #
+          # @example Get the matched count.
+          #   result.n_matched
+          #
+          # @return [ Integer ] The number of documents matched.
+          #
+          # @since 2.0.0
+          def n_matched
+            return 0 unless acknowledged?
+            @replies.reduce(0) do |n, reply|
+              if upsert?(reply)
+                n
+              else
+                n += reply.documents.first[N]
+              end
+            end
+          end
+
+          private
+
+          def upsert?(reply)
+            !updated_existing?(reply) && reply.documents.first[N] == 1
+          end
+
+          def updated_existing?(reply)
+            reply.documents.first[UPDATED_EXISTING]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongo/operation/write/bulk/bulk_update.rb

@@ -0,0 +1,153 @@
+# 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.
+
+require 'mongo/operation/write/bulk/bulk_update/result'
+
+module Mongo
+  module Operation
+    module Write
+
+      # A MongoDB bulk update operation.
+      #
+      # @note If the server version is >= 2.5.5, a write command operation
+      #   will be created and sent instead.
+      #
+      # @example Create the update operation.
+      #   Write::BulkUpdate.new({
+      #     :updates => [
+      #       {
+      #         :q => { :foo => 1 },
+      #         :u => { :$set => { :bar => 1 }},
+      #         :multi  => true,
+      #         :upsert => false
+      #       }
+      #     ],
+      #     :db_name => 'test',
+      #     :coll_name => 'test_coll',
+      #     :write_concern => write_concern,
+      #     :ordered => false
+      #   })
+      #
+      # @param [ Hash ] spec The specifications for the update.
+      #
+      # @option spec :updates [ Array ] The update documents.
+      # @option spec :db_name [ String ] The name of the database on which
+      #   the query should be run.
+      # @option spec :coll_name [ String ] The name of the collection on which
+      #   the query should be run.
+      # @option spec :write_concern [ Mongo::WriteConcern ] The write concern.
+      # @option spec :ordered [ true, false ] Whether the operations should be
+      #   executed in order.
+      # @option spec :options [ Hash ] Options for the command, if it ends up being a
+      #   write command.
+      #
+      # @since 2.0.0
+      class BulkUpdate
+        include Executable
+        include Specifiable
+
+        # Execute the update operation.
+        #
+        # @example Execute the operation.
+        #   operation.execute(context)
+        #
+        # @param [ Mongo::Server::Context ] context The context for this operation.
+        #
+        # @return [ Result ] The operation result.
+        #
+        # @since 2.0.0
+        def execute(context)
+          if context.features.write_command_enabled?
+            execute_write_command(context)
+          else
+            execute_message(context)
+          end
+        end
+
+        # Set the write concern on this operation.
+        #
+        # @example Set a write concern.
+        #   new_op = operation.write_concern(:w => 2)
+        #
+        # @param [ Hash ] wc The write concern.
+        #
+        # @since 2.0.0
+        def write_concern(wc = nil)
+          if wc
+            self.class.new(spec.merge(write_concern: WriteConcern.get(wc)))
+          else
+            spec[WRITE_CONCERN]
+          end
+        end
+
+        private
+
+        def execute_write_command(context)
+          Result.new(Command::Update.new(spec).execute(context))
+        end
+
+        def execute_message(context)
+          replies = messages.map do |m|
+            context.with_connection do |connection|
+              result = LegacyResult.new(connection.dispatch([ m, gle ].compact))
+              if stop_sending?(result)
+                return result
+              else
+                result.reply
+              end
+            end
+          end
+          LegacyResult.new(replies.compact.empty? ? nil : replies)
+        end
+
+        def stop_sending?(result)
+          ordered? && !result.successful?
+        end
+
+        # @todo put this somewhere else
+        def ordered?
+          @spec.fetch(:ordered, true)
+        end
+
+        def gle
+          gle_message = ( ordered? && write_concern.get_last_error.nil? ) ?
+                           Mongo::WriteConcern.get(:w => 1).get_last_error :
+                           write_concern.get_last_error
+          if gle_message
+            Protocol::Query.new(
+              db_name,
+              Database::COMMAND,
+              gle_message,
+              options.merge(limit: -1)
+            )
+          end
+        end
+
+        def initialize_copy(original)
+          @spec = original.spec.dup
+          @spec[UPDATES] = original.spec[UPDATES].dup
+        end
+
+        def messages
+          updates.collect do |u|
+            opts = { :flags => [] }
+            opts[:flags] << :multi_update if !!u[:multi]
+            opts[:flags] << :upsert if !!u[:upsert]
+            Protocol::Update.new(db_name, coll_name, u[:q], u[:u], opts)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongo/operation/write/bulk/legacy_bulk_mergable.rb

@@ -0,0 +1,83 @@
+# 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
+
+      module LegacyBulkMergable
+
+        # Aggregate the write errors returned from this result.
+        #
+        # @example Aggregate the write errors.
+        #   result.aggregate_write_errors([0, 1, 2, 3])
+        #
+        # @param [ Array ] indexes The indexes of each operation as they
+        #   were listed in the Bulk API.
+        #
+        # @return [ Array ] The aggregate write errors.
+        #
+        # @since 2.0.0
+        def aggregate_write_errors(indexes)
+          @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([0, 1, 2, 3])
+        #
+        # @param [ Array ] indexes The indexes of each operation as they
+        #   were listed in the Bulk API.
+        #
+        # @return [ Array ] The aggregate write concern errors.
+        #
+        # @since 2.0.0
+        def aggregate_write_concern_errors(indexes)
+          @replies.each_with_index.reduce(nil) do |errors, (reply, i)|
+            if error = reply_write_errors?(reply)
+              errors ||= []
+              if note = reply.documents.first['wnote'] || reply.documents.first['jnote']
+                code = reply.documents.first['code'] || Error::BAD_VALUE
+                error_string = "#{code}: #{note}"
+              elsif error == 'timeout'
+                code = reply.documents.first['code'] || Error::UNKNOWN_ERROR
+                error_string = "#{code}: #{error}"
+              end
+              errors << { 'errmsg' => error_string,
+                          'index' => indexes[i],
+                          'code' => code } if error_string
+            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

data/lib/mongo/operation/write/bulk.rb

@@ -0,0 +1,17 @@
+# 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.
+
+require 'mongo/operation/write/bulk/bulk_delete'
+require 'mongo/operation/write/bulk/bulk_insert'
+require 'mongo/operation/write/bulk/bulk_update'

data/lib/mongo/operation/write/command/create_index.rb

@@ -0,0 +1,50 @@
+# 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
+      module Command
+
+        # A MongoDB ensure index write command operation.
+        #
+        # @example Create an ensure index command operation.
+        #   Write::Command::CreateIndex.new({
+        #     :indexes => [{ :key => { :foo => 1 }, :name => 'foo_1', :unique => true }],
+        #     :db_name => 'test',
+        #     :coll_name => 'test_coll'
+        #   })
+        #
+        # @since 2.0.0
+        class CreateIndex
+          include Specifiable
+          include Executable
+          include Writable
+
+          private
+
+          # The query selector for this ensure index command operation.
+          #
+          # @return [ Hash ] The selector describing this insert operation.
+          #
+          # @since 2.0.0
+          def selector
+            { :createIndexes => coll_name, :indexes => indexes }
+          end
+        end
+      end
+    end
+  end
+end
+