mongo 2.0.6 → 2.1.0.beta

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 391a49fc68da96ed3daf59dae9e7006edd6eb7c4
-  data.tar.gz: c9b0c470d42785c446fa2c2ae21273bd45f487ea
+  metadata.gz: b6616ddb03b3417535c99796a74defa18bb90777
+  data.tar.gz: 300c32fe7122805036f67b387f0bb68648a8b759
 SHA512:
-  metadata.gz: b77002840a210f7bf8c98114529edd2d0a8891dc6518fcd3c3d1337b2648cf2b31b9d3564aab8ab404521232713a452986cfd6202bdaa69c06fde024305befbe
-  data.tar.gz: 146937702a43742e5e678845431b61b071c6b3573084dac4f7cb196f3ec601c97d78a248c39c1066a5fd7860f6195a72837210f6b8bdd84b7b6ed03328063f24
+  metadata.gz: 8046a19889e6f15481690eca65e8696834925bb7c1727a387af1d29e22fc63cb2d2640d5ddebf48e80d641e518dfc5a753d3a79713f655cccbbdba94215da1f3
+  data.tar.gz: 50f48316c5d9b17cb516467609667b5792472dbd0cbd43accc70c62a99ead9bdee595679f9d9b564db865606bbb55d7fc81176dd1669e0abd5c696803bd01132

data/lib/mongo.rb

@@ -15,6 +15,7 @@
 require 'forwardable'
 require 'bson'
 require 'openssl'
+require 'mongo/monitoring'
 require 'mongo/loggable'
 require 'mongo/logger'
 require 'mongo/error'
@@ -27,6 +28,7 @@ require 'mongo/cluster'
 require 'mongo/collection'
 require 'mongo/cursor'
 require 'mongo/database'
+require 'mongo/dbref'
 require 'mongo/grid'
 require 'mongo/index'
 require 'mongo/operation'

data/lib/mongo/bulk_write.rb

@@ -15,6 +15,7 @@
 require 'mongo/bulk_write/bulk_writable'
 require 'mongo/bulk_write/ordered_bulk_write'
 require 'mongo/bulk_write/unordered_bulk_write'
+require 'mongo/bulk_write/result'
 
 module Mongo
   module BulkWrite

data/lib/mongo/bulk_write/bulk_writable.rb

@@ -30,19 +30,60 @@ module Mongo
       include Replacable
       extend Forwardable
 
-      # Delegate various methods to the collection.
-      def_delegators :@collection, :database, :cluster, :next_primary
+      # Constant for number removed.
+      #
+      # @since 2.1.0
+      REMOVED_COUNT = 'n_removed'.freeze
+
+      # Constant for number inserted.
+      #
+      # @since 2.1.0
+      INSERTED_COUNT = 'n_inserted'.freeze
+
+      # Constant for inserted ids.
+      #
+      # @since 2.1.0
+      INSERTED_IDS = 'inserted_ids'.freeze
+
+      # Constant for number matched.
+      #
+      # @since 2.1.0
+      MATCHED_COUNT = 'n_matched'.freeze
+
+      # Constant for number modified.
+      #
+      # @since 2.1.0
+      MODIFIED_COUNT = 'n_modified'.freeze
+
+      # Constant for number upserted.
+      #
+      # @since 2.1.0
+      UPSERTED_COUNT = 'n_upserted'.freeze
+
+      # Constant for upserted ids.
+      #
+      # @since 2.1.0
+      UPSERTED_IDS = 'upserted_ids'.freeze
+
+      # Constant for indexes.
+      #
+      # @since 2.1.0
+      INDEXES = 'indexes'.freeze
 
       # The fields contained in the result document returned from executing the
       # operations.
       #
       # @since 2.0.0.
-      RESULT_FIELDS = [ :n_inserted,
-                        :n_removed,
-                        :n_modified,
-                        :n_upserted,
-                        :n_matched ]
+      RESULT_FIELDS = [
+        INSERTED_COUNT,
+        REMOVED_COUNT,
+        MODIFIED_COUNT,
+        UPSERTED_COUNT,
+        MATCHED_COUNT
+      ].freeze
 
+      # Delegate various methods to the collection.
+      def_delegators :@collection, :database, :cluster, :next_primary
 
       # Initialize a bulk write object.
       #
@@ -76,9 +117,10 @@ module Mongo
       def execute
         server = next_primary
         validate_operations!
+        operation_id = Monitoring.next_operation_id
         merged_ops.each do |op|
           validate_type!(op.keys.first)
-          execute_op(op, server)
+          execute_op(op, server, operation_id)
         end
         finalize
       end
@@ -86,13 +128,13 @@ module Mongo
       private
 
       def valid_doc?(doc)
-        doc.respond_to?(:keys) ||
-          doc.respond_to?(:document)
+        doc.respond_to?(:keys) || doc.respond_to?(:document)
       end
 
       def write_concern
-        @write_concern ||= WriteConcern.get(@options[:write_concern]) ||
-                            @collection.write_concern
+        @write_concern ||= @options[:write_concern] ?
+                             WriteConcern.get(@options[:write_concern]) :
+                               @collection.write_concern
       end
 
       def validate_operations!
@@ -111,29 +153,30 @@ module Mongo
         type = op.keys.first
         ops = []
         while op[type].size > server.max_write_batch_size
-          ops << { type => op[type].shift(server.max_write_batch_size),
-                   :indexes => op[:indexes].shift(server.max_write_batch_size) }
+          ops << {
+            type => op[type].shift(server.max_write_batch_size),
+            INDEXES => op[INDEXES].shift(server.max_write_batch_size)
+          }
         end
         ops << op
       end
 
       def split(op, type)
         n = op[type].size/2
-        [ { type => op[type].shift(n),
-            :indexes => op[:indexes].shift(n) },
-          { type => op[type],
-            :indexes => op[:indexes] }
+        [
+          { type => op[type].shift(n), INDEXES => op[INDEXES].shift(n) },
+          { type => op[type], INDEXES => op[INDEXES] }
         ]
       end
 
-      def execute_op(operation, server)
+      def execute_op(operation, server, operation_id)
         ops = max_write_batches(operation, server)
 
         until ops.empty?
           op = ops.shift
           type = op.keys.first
           begin
-            process(send(type, op, server), op[:indexes])
+            process(send(type, op, server, operation_id), op[INDEXES])
           rescue Error::MaxBSONSize, Error::MaxMessageSize => ex
             raise ex if op[type].size < 2
             ops = split(op, type) + ops
@@ -144,15 +187,16 @@ module Mongo
       def merge_consecutive_ops(ops)
         ops.each_with_index.inject([]) do |merged, (op, i)|
           type = op.keys.first
-          op[:indexes] ||= [ i ]
+          op[INDEXES] ||= [ i ]
           previous = merged.last
           if previous && previous.keys.first == type
-            merged[-1].merge!(type => previous[type] << op[type],
-                             :indexes => previous[:indexes] + op[:indexes])
+            merged[-1].merge!(
+              type => previous[type] << op[type],
+              INDEXES => previous[INDEXES] + op[INDEXES]
+            )
             merged
           else
-            merged << { type => [ op[type] ].flatten,
-                        :indexes => op[:indexes] }
+            merged << { type => [ op[type] ].flatten, INDEXES => op[INDEXES] }
           end
         end
       end
@@ -166,7 +210,7 @@ module Mongo
           merged
         end
         ops_hash.keys.reduce([]) do |ops_list, type|
-          ops_list << { type => ops_hash[type], :indexes => indexes[type] }
+          ops_list << { type => ops_hash[type], INDEXES => indexes[type] }
         end
       end
 
@@ -184,13 +228,25 @@ module Mongo
             ) if result.respond_to?(field)
           end
 
-          results.merge!(
-            write_errors: ((results[:write_errors] || []) << write_errors).flatten
-          ) if write_errors
+          if result.respond_to?(INSERTED_IDS)
+            results.merge!(INSERTED_IDS => result.inserted_ids)
+          end
 
-          results.merge!(write_concern_errors: @write_concern_errors) if @write_concern_errors
+          if result.respond_to?(Operation::Write::BulkUpdate::Result::UPSERTED)
+            results.merge!(UPSERTED_IDS => result.upserted.map{ |doc| doc['_id'] })
+          end
+
+          if write_errors
+            results.merge!(
+              Error::WRITE_ERRORS => ((results[Error::WRITE_ERRORS] || []) << write_errors).flatten
+            )
+          end
+
+          if @write_concern_errors
+            results.merge!(Error::WRITE_CONCERN_ERRORS => @write_concern_errors)
+          end
         end
       end
     end
   end
-end
+end

data/lib/mongo/bulk_write/deletable.rb

@@ -34,23 +34,24 @@ module Mongo
         end
       end
 
-      def delete(ops, type, server)
+      def delete(ops, type, server, operation_id)
         Operation::Write::BulkDelete.new(
           :deletes => deletes(ops, type),
           :db_name => database.name,
           :coll_name => @collection.name,
           :write_concern => write_concern,
-          :ordered => ordered?
+          :ordered => ordered?,
+          :operation_id => operation_id
         ).execute(server.context)
       end
 
-      def delete_one(op, server)
-        delete(op[:delete_one], __method__, server)
+      def delete_one(op, server, operation_id)
+        delete(op[:delete_one], __method__, server, operation_id)
       end
 
-      def delete_many(op, server)
-        delete(op[:delete_many], __method__, server)
+      def delete_many(op, server, operation_id)
+        delete(op[:delete_many], __method__, server, operation_id)
       end
     end
   end
-end
+end

data/lib/mongo/bulk_write/insertable.rb

@@ -33,16 +33,17 @@ module Mongo
         end
       end
 
-      def insert_one(op, server)
+      def insert_one(op, server, operation_id)
         validate_insert_ops!(__method__, op[:insert_one])
         Operation::Write::BulkInsert.new(
           :documents => op[:insert_one].flatten,
           :db_name => database.name,
           :coll_name => @collection.name,
           :write_concern => write_concern,
-          :ordered => ordered?
+          :ordered => ordered?,
+          :operation_id => operation_id
         ).execute(server.context)
       end
     end
   end
-end
+end

data/lib/mongo/bulk_write/ordered_bulk_write.rb

@@ -13,11 +13,12 @@
 # limitations under the License.
 
 module Mongo
-
   module BulkWrite
 
+    # Encapsulates behaviour around an ordered bulk write operation.
+    #
+    # @since 2.0.0
     class OrderedBulkWrite
-
       include BulkWritable
 
       private
@@ -36,13 +37,12 @@ module Mongo
       end
 
       def stop?
-        @results.keys.include?(:write_errors)
+        @results.keys.include?(Error::WRITE_ERRORS)
       end
 
       def finalize
-        raise Error::BulkWriteError.new(@results) if @results[:write_concern_errors]
-        @results
+        Result.new(@results).validate!
       end
     end
   end
-end
+end

data/lib/mongo/bulk_write/replacable.rb

@@ -43,15 +43,16 @@ module Mongo
         end
       end
 
-      def replace_one(op, server)
+      def replace_one(op, server, operation_id)
         Operation::Write::BulkUpdate.new(
           :updates => replace_ops(op[:replace_one], __method__),
           :db_name => database.name,
           :coll_name => @collection.name,
           :write_concern => write_concern,
-          :ordered => ordered?
+          :ordered => ordered?,
+          :operation_id => operation_id
         ).execute(server.context)
       end
     end
   end
-end
+end

data/lib/mongo/bulk_write/result.rb

@@ -0,0 +1,138 @@
+# Copyright (C) 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 BulkWrite
+
+    # Wraps a series of bulk write operations in a result object.
+    #
+    # @since 2.0.6
+    class Result
+
+      # Returns the number of documents deleted.
+      #
+      # @example Get the number of deleted documents.
+      #   result.deleted_count
+      #
+      # @return [ Integer ] The number deleted.
+      #
+      # @since 2.1.0
+      def deleted_count
+        @results[BulkWritable::REMOVED_COUNT]
+      end
+
+      # Create the new result object from the results document.
+      #
+      # @example Create the new result.
+      #   Result.new({ 'n_inserted' => 10 })
+      #
+      # @param [ BSON::Document, Hash ] results The results document.
+      #
+      # @since 2.1.0
+      def initialize(results)
+        @results = results
+      end
+
+      # Returns the number of documents inserted.
+      #
+      # @example Get the number of inserted documents.
+      #   result.inserted_count
+      #
+      # @return [ Integer ] The number inserted.
+      #
+      # @since 2.1.0
+      def inserted_count
+        @results[BulkWritable::INSERTED_COUNT]
+      end
+
+      # Get the inserted document ids, if the operation has inserts.
+      #
+      # @example Get the inserted ids.
+      #   result.inserted_ids
+      #
+      # @return [ Array<BSON::ObjectId> ] The inserted ids.
+      #
+      # @since 2.1.0
+      def inserted_ids
+        @results[BulkWritable::INSERTED_IDS]
+      end
+
+      # Returns the number of documents matched.
+      #
+      # @example Get the number of matched documents.
+      #   result.matched_count
+      #
+      # @return [ Integer ] The number matched.
+      #
+      # @since 2.1.0
+      def matched_count
+        @results[BulkWritable::MATCHED_COUNT]
+      end
+
+      # Returns the number of documents modified.
+      #
+      # @example Get the number of modified documents.
+      #   result.modified_count
+      #
+      # @return [ Integer ] The number modified.
+      #
+      # @since 2.1.0
+      def modified_count
+        @results[BulkWritable::MODIFIED_COUNT]
+      end
+
+      # Returns the number of documents upserted.
+      #
+      # @example Get the number of upserted documents.
+      #   result.upserted_count
+      #
+      # @return [ Integer ] The number upserted.
+      #
+      # @since 2.1.0
+      def upserted_count
+        @results[BulkWritable::UPSERTED_COUNT]
+      end
+
+      # Get the upserted document ids, if the operation has inserts.
+      #
+      # @example Get the upserted ids.
+      #   result.upserted_ids
+      #
+      # @return [ Array<BSON::ObjectId> ] The upserted ids.
+      #
+      # @since 2.1.0
+      def upserted_ids
+        @results[BulkWritable::UPSERTED_IDS]
+      end
+
+      # Validates the bulk write result.
+      #
+      # @example Validate the result.
+      #   result.validate!
+      #
+      # @raise [ Error::BulkWriteError ] If the result contains errors.
+      #
+      # @return [ Result ] The result.
+      #
+      # @since 2.1.0
+      def validate!
+        if @results[Error::WRITE_ERRORS] || @results[Error::WRITE_CONCERN_ERRORS]
+          raise Error::BulkWriteError.new(@results)
+        else
+          self
+        end
+      end
+    end
+  end
+end