mongo 1.12.5 → 2.0.0.beta

data/VERSION

@@ -1 +0,0 @@
-1.12.5

data/lib/mongo/bulk_write_collection_view.rb

@@ -1,387 +0,0 @@
-# Copyright (C) 2009-2013 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
-
-  # A bulk write view to a collection of documents in a database.
-  class BulkWriteCollectionView
-    include Mongo::WriteConcern
-
-    DEFAULT_OP_ARGS = {:q => nil}
-    MULTIPLE_ERRORS_MSG = "batch item errors occurred"
-    EMPTY_BATCH_MSG = "batch is empty"
-
-    attr_reader :collection, :options, :ops, :op_args
-
-    # Initialize a bulk-write-view object to a collection with default query selector {}.
-    #
-    # A bulk write operation is initialized from a collection object.
-    # For example, for an ordered bulk write view:
-    #
-    #   bulk = collection.initialize_ordered_bulk_op
-    #
-    # or for an unordered bulk write view:
-    #
-    #   bulk = collection.initialize_unordered_bulk_op
-    #
-    # The bulk write view collects individual write operations together so that they can be
-    # executed as a batch for significant performance gains.
-    # The ordered bulk operation will execute each operation serially in order.
-    # Execution will stop at the first occurrence of an error for an ordered bulk operation.
-    # The unordered bulk operation will be executed and may take advantage of parallelism.
-    # There are no guarantees for the order of execution of the operations on the server.
-    # Execution will continue even if there are errors for an unordered bulk operation.
-    #
-    # A bulk operation is programmed as a sequence of individual operations.
-    # An individual operation is composed of a method chain of modifiers or setters terminated by a write method.
-    # A modify method sets a value on the current object.
-    # A set methods returns a duplicate of the current object with a value set.
-    # A terminator write method appends a write operation to the bulk batch collected in the view.
-    #
-    # The API supports mixing of write operation types in a bulk operation.
-    # However, server support affects the implementation and performance of bulk operations.
-    #
-    # MongoDB version 2.6 servers currently support only bulk commands of the same type.
-    # With an ordered bulk operation,
-    # contiguous individual ops of the same type can be batched into the same db request,
-    # and the next op of a different type must be sent separately in the next request.
-    # Performance will improve if you can arrange your ops to reduce the number of db requests.
-    # With an unordered bulk operation,
-    # individual ops can be grouped by type and sent in at most three requests,
-    # one each per insert, update, or delete.
-    #
-    # MongoDB pre-version 2.6 servers do not support bulk write commands.
-    # The bulk operation must be sent one request per individual op.
-    # This also applies to inserts in order to have accurate counts and error reporting.
-    #
-    #   Important note on pre-2.6 performance:
-    #     Performance is very poor compared to version 2.6.
-    #     We recommend bulk operation with pre-2.6 only for compatibility or
-    #     for development in preparation for version 2.6.
-    #     For better performance with pre-version 2.6, use bulk insertion with Collection#insert.
-    #
-    # @param [Collection] collection the parent collection object
-    #
-    # @option opts [Boolean] :ordered (true) Set bulk execution for ordered or unordered
-    #
-    # @return [BulkWriteCollectionView]
-    def initialize(collection, options = {})
-      @collection = collection
-      @options = options
-      @ops = []
-      @op_args = DEFAULT_OP_ARGS.dup
-    end
-
-    def inspect
-      vars = [:@options, :@ops, :@op_args]
-      vars_inspect = vars.collect{|var| "#{var}=#{instance_variable_get(var).inspect}"}
-      "#<Mongo::BulkWriteCollectionView:0x#{self.object_id} " <<
-      "@collection=#<Mongo::Collection:0x#{@collection.object_id}>, #{vars_inspect.join(', ')}>"
-    end
-
-    # Modify the query selector for subsequent bulk write operations.
-    # The default query selector on creation of the bulk write view is {}.
-    # For operations that require a query selector, find() must be set
-    # per operation, or set once for all operations on the bulk object.
-    # For example, these operations:
-    #
-    #   bulk.find({"a" => 2}).update({"$inc" => {"x" => 2}})
-    #   bulk.find({"a" => 2}).update({"$set" => {"b" => 3}})
-    #
-    # may be rewritten as:
-    #
-    #   bulk = find({"a" => 2})
-    #   bulk.update({"$inc" => {"x" => 2}})
-    #   bulk.update({"$set" => {"b" => 3}})
-    #
-    # Note that modifying the query selector in this way will not affect
-    # operations that do not use a query selector, like insert().
-    #
-    # @param [Hash] q the query selector
-    #
-    # @return [BulkWriteCollectionView]
-    def find(q)
-      op_args_set(:q, q)
-    end
-
-    # Modify the upsert option argument for subsequent bulk write operations.
-    #
-    # @param [Boolean] value (true) the upsert option value
-    #
-    # @return [BulkWriteCollectionView]
-    def upsert!(value = true)
-      op_args_set(:upsert, value)
-    end
-
-    # Set the upsert option argument for subsequent bulk write operations.
-    #
-    # @param [Boolean] value (true) the upsert option value
-    #
-    # @return [BulkWriteCollectionView] a duplicated object
-    def upsert(value = true)
-      dup.upsert!(value)
-    end
-
-    # Update one document matching the selector.
-    #
-    #   bulk.find({"a" => 1}).update_one({"$inc" => {"x" => 1}})
-    #
-    # Use the upsert! or upsert method to specify an upsert. For example:
-    #
-    #   bulk.find({"a" => 1}).upsert.updateOne({"$inc" => {"x" => 1}})
-    #
-    # @param [Hash] u the update document
-    #
-    # @return [BulkWriteCollectionView]
-    def update_one(u)
-      raise MongoArgumentError, "document must start with an operator" unless update_doc?(u)
-      op_push([:update, @op_args.merge(:u => u, :multi => false)])
-    end
-
-    # Update all documents matching the selector. For example:
-    #
-    #   bulk.find({"a" => 2}).update({"$inc" => {"x" => 2}})
-    #
-    # Use the upsert! or upsert method to specify an upsert.  For example:
-    #
-    #   bulk.find({"a" => 2}).upsert.update({"$inc" => {"x" => 2}})
-    #
-    # @param [Hash] u the update document
-    #
-    # @return [BulkWriteCollectionView]
-    def update(u)
-      raise MongoArgumentError, "document must start with an operator" unless update_doc?(u)
-      op_push([:update, @op_args.merge(:u => u, :multi => true)])
-    end
-
-    # Replace entire document (update with whole doc replace). For example:
-    #
-    #   bulk.find({"a" => 3}).replace_one({"x" => 3})
-    #
-    # @param [Hash] u the replacement document
-    #
-    # @return [BulkWriteCollectionView]
-    def replace_one(u)
-      raise MongoArgumentError, "document must not contain any operators" unless replace_doc?(u)
-      op_push([:update, @op_args.merge(:u => u, :multi => false)])
-    end
-
-    # Remove a single document matching the selector. For example:
-    #
-    #   bulk.find({"a" => 4}).remove_one;
-    #
-    # @return [BulkWriteCollectionView]
-    def remove_one
-      op_push([:delete, @op_args.merge(:limit => 1)])
-    end
-
-    # Remove all documents matching the selector. For example:
-    #
-    #   bulk.find({"a" => 5}).remove;
-    #
-    # @return [BulkWriteCollectionView]
-    def remove
-      op_push([:delete, @op_args.merge(:limit => 0)])
-    end
-
-    # Insert a document. For example:
-    #
-    #   bulk.insert({"x" => 4})
-    #
-    # @return [BulkWriteCollectionView]
-    def insert(document)
-      # TODO - check keys
-      op_push([:insert, {:d => document}])
-    end
-
-    # Execute the bulk operation, with an optional write concern overwriting the default w:1.
-    # For example:
-    #
-    #   write_concern = {:w => 1, :j => 1}
-    #   bulk.execute({write_concern})
-    #
-    # On return from execute, the bulk operation is cleared,
-    # but the selector and upsert settings are preserved.
-    #
-    # @return [BulkWriteCollectionView]
-    def execute(opts = {})
-      raise MongoArgumentError, EMPTY_BATCH_MSG if @ops.empty?
-      write_concern = get_write_concern(opts, @collection)
-      @ops.each_with_index{|op, index| op.last.merge!(:ord => index)} # infuse ordinal here to avoid issues with upsert
-      if @collection.db.connection.use_write_command?(write_concern)
-        errors, write_concern_errors, exchanges = @collection.command_writer.bulk_execute(@ops, @options, opts)
-      else
-        errors, write_concern_errors, exchanges = @collection.operation_writer.bulk_execute(@ops, @options, opts)
-      end
-      @ops = []
-      return true if errors.empty? && (exchanges.empty? || exchanges.first[:response] == true) # w 0 without GLE
-      result = merge_result(errors + write_concern_errors, exchanges)
-      raise BulkWriteError.new(MULTIPLE_ERRORS_MSG, Mongo::ErrorCode::MULTIPLE_ERRORS_OCCURRED, result) if !errors.empty? || !write_concern_errors.empty?
-      result
-    end
-
-    private
-
-    def hash_except(h, *keys)
-      keys.each { |key| h.delete(key) }
-      h
-    end
-
-    def hash_select(h, *keys)
-      Hash[*keys.zip(h.values_at(*keys)).flatten]
-    end
-
-    def tally(h, key, n)
-      h[key] = h.fetch(key, 0) + n
-    end
-
-    def nil_tally(h, key, n)
-      if !h.has_key?(key)
-        h[key] = n
-      elsif h[key]
-        h[key] = n ? h[key] + n : n
-      end
-    end
-
-    def append(h, key, obj)
-      h[key] = h.fetch(key, []) << obj
-    end
-
-    def concat(h, key, a)
-      h[key] = h.fetch(key, []) + a
-    end
-
-    def merge_index(h, exchange)
-      h.merge("index" => exchange[:batch][h.fetch("index", 0)][:ord])
-    end
-
-    def merge_indexes(a, exchange)
-      a.collect{|h| merge_index(h, exchange)}
-    end
-
-    def merge_result(errors, exchanges)
-      ok = 0
-      result = {"ok" => 0, "n" => 0}
-      unless errors.empty?
-        unless (writeErrors = errors.select { |error| error.class != Mongo::OperationFailure && error.class != WriteConcernError }).empty? # assignment
-          concat(result, "writeErrors",
-                 writeErrors.collect { |error|
-                   {"index" => error.result[:ord], "code" => error.error_code, "errmsg" => error.result[:error].message}
-                 })
-        end
-        result.merge!("code" => Mongo::ErrorCode::MULTIPLE_ERRORS_OCCURRED, "errmsg" => MULTIPLE_ERRORS_MSG)
-      end
-      exchanges.each do |exchange|
-        response = exchange[:response]
-        next unless response
-        ok += response["ok"].to_i
-        n = response["n"] || 0
-        op_type = exchange[:op_type]
-        if op_type == :insert
-          n = 1 if response.key?("err") && (response["err"].nil? || response["err"] == "norepl" || response["err"] == "timeout") # OP_INSERT override n = 0 bug, n = exchange[:batch].size always 1
-          tally(result, "nInserted", n)
-        elsif op_type == :update
-          n_upserted = 0
-          if (upserted = response.fetch("upserted", nil)) # assignment
-            upserted = [{"_id" => upserted}] if upserted.class != Array # OP_UPDATE non-array
-            n_upserted = upserted.size
-            concat(result, "upserted", merge_indexes(upserted, exchange))
-          elsif (response["updatedExisting"] == false && n == 1)
-            # workaround for DRIVERS-151 (non-ObjectID _id fields in pre-2.6 servers)
-            op = exchange[:batch][0]
-            missing_id = op[:u].fetch(:_id, op[:q][:_id]) # _id in update document takes precedence
-            upserted = [ { "_id" => missing_id, "index" => 0 } ]
-            n_upserted = n
-            concat(result, "upserted", merge_indexes(upserted, exchange))
-          end
-          tally(result, "nUpserted", n_upserted) if n_upserted > 0
-          tally(result, "nMatched", n - n_upserted)
-          nil_tally(result, "nModified", response["nModified"])
-        elsif op_type == :delete
-          tally(result, "nRemoved", n)
-        end
-        result["n"] += n
-        write_concern_error = nil
-        errmsg = response["errmsg"] || response["err"] # top level
-        if (writeErrors = response["writeErrors"] || response["errDetails"]) # assignment
-          concat(result, "writeErrors", merge_indexes(writeErrors, exchange))
-        elsif response["err"] == "timeout" # errmsg == "timed out waiting for slaves" # OP_*
-          write_concern_error = {"errmsg" => errmsg, "code" => Mongo::ErrorCode::WRITE_CONCERN_FAILED,
-                               "errInfo" => {"wtimeout" => response["wtimeout"]}} # OP_* does not have "code"
-        elsif errmsg == "norepl" # OP_*
-          write_concern_error = {"errmsg" => errmsg, "code" => Mongo::ErrorCode::WRITE_CONCERN_FAILED} # OP_* does not have "code"
-        elsif errmsg # OP_INSERT, OP_UPDATE have "err"
-          append(result, "writeErrors", merge_index({"errmsg" => errmsg, "code" => response["code"]}, exchange))
-        end
-        if response["writeConcernError"]
-          write_concern_error = response["writeConcernError"]
-        elsif (wnote = response["wnote"]) # assignment - OP_*
-          write_concern_error = {"errmsg" => wnote, "code" => Mongo::ErrorCode::WRITE_CONCERN_FAILED} # OP_* does not have "code"
-        elsif (jnote = response["jnote"]) # assignment - OP_*
-          write_concern_error = {"errmsg" => jnote, "code" => Mongo::ErrorCode::BAD_VALUE} # OP_* does not have "code"
-        end
-        append(result, "writeConcernError", merge_index(write_concern_error, exchange)) if write_concern_error
-      end
-      result.delete("nModified") if result.has_key?("nModified") && !result["nModified"]
-      result.merge!("ok" => [ok + result["n"], 1].min)
-    end
-
-    def initialize_copy(other)
-      other.instance_variable_set(:@options, other.options.dup)
-    end
-
-    def op_args_set(op, value)
-      @op_args[op] = value
-      self
-    end
-
-    def op_push(op)
-      raise MongoArgumentError, "non-nil query must be set via find" if op.first != :insert && !op.last[:q]
-      @ops << op
-      self
-    end
-
-    def update_doc?(doc)
-      !doc.empty? && doc.keys.first.to_s =~ /^\$/
-    end
-
-    def replace_doc?(doc)
-      doc.keys.all?{|key| key !~ /^\$/}
-    end
-
-  end
-
-  class Collection
-
-    # Initialize an ordered bulk write view for this collection
-    # Execution will stop at the first occurrence of an error for an ordered bulk operation.
-    #
-    # @return [BulkWriteCollectionView]
-    def initialize_ordered_bulk_op
-      BulkWriteCollectionView.new(self, :ordered => true)
-    end
-
-    # Initialize an unordered bulk write view for this collection
-    # The unordered bulk operation will be executed and may take advantage of parallelism.
-    # There are no guarantees for the order of execution of the operations on the server.
-    # Execution will continue even if there are errors for an unordered bulk operation.
-    #
-    # @return [BulkWriteCollectionView]
-    def initialize_unordered_bulk_op
-      BulkWriteCollectionView.new(self, :ordered => false)
-    end
-
-  end
-
-end

data/lib/mongo/collection_writer.rb

@@ -1,364 +0,0 @@
-# Copyright (C) 2009-2013 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
-
-  class CollectionWriter
-    include Mongo::Logging
-    include Mongo::WriteConcern
-
-    OPCODE = {
-      :insert => Mongo::Constants::OP_INSERT,
-      :update => Mongo::Constants::OP_UPDATE,
-      :delete => Mongo::Constants::OP_DELETE
-    }
-    WRITE_COMMAND_ARG_KEY = {
-      :insert => :documents,
-      :update => :updates,
-      :delete => :deletes
-    }
-
-    def initialize(collection)
-      @collection = collection
-      @name = @collection.name
-      @db = @collection.db
-      @connection = @db.connection
-      @logger     = @connection.logger
-      @max_write_batch_size = Mongo::MongoClient::DEFAULT_MAX_WRITE_BATCH_SIZE
-    end
-
-    # common implementation only for new batch write commands (insert, update, delete) and old batch insert
-    def batch_write_incremental(op_type, documents, check_keys=true, opts={})
-      raise Mongo::OperationFailure, "Request contains no documents" if documents.empty?
-      write_concern = get_write_concern(opts, @collection)
-      max_message_size, max_append_size, max_serialize_size = batch_write_max_sizes(write_concern)
-      ordered = opts[:ordered]
-      continue_on_error = !!opts[:continue_on_error] || ordered == false
-      collect_on_error = !!opts[:collect_on_error] || ordered == false
-      error_docs = [] # docs with serialization errors
-      errors = []
-      write_concern_errors = []
-      exchanges = []
-      serialized_doc = nil
-      message = BSON::ByteBuffer.new("", max_message_size)
-      @max_write_batch_size = @collection.db.connection.max_write_batch_size
-      docs = documents.dup
-      catch(:error) do
-        until docs.empty? || (!errors.empty? && !collect_on_error && !continue_on_error) # process documents a batch at a time
-          batch_docs = []
-          batch_message_initialize(message, op_type, continue_on_error, write_concern)
-          while !docs.empty? && batch_docs.size < @max_write_batch_size
-            begin
-              doc = docs.first
-              doc = doc[:d] if op_type == :insert && !ordered.nil? #check_keys for :update outside of serialize
-              serialized_doc ||= BSON::BSON_CODER.serialize(doc, check_keys, true, max_serialize_size)
-            rescue BSON::InvalidDocument, BSON::InvalidKeyName, BSON::InvalidStringEncoding => ex
-              bulk_message = "Bulk write error - #{ex.message} - examine result for complete information"
-              ex = BulkWriteError.new(bulk_message, Mongo::ErrorCode::INVALID_BSON,
-                                      {:op_type => op_type, :serialize => doc, :ord => docs.first[:ord], :error => ex}) unless ordered.nil?
-              error_docs << docs.shift
-              errors << ex
-              next if collect_on_error
-              throw(:error) if batch_docs.empty?
-              break # defer exit and send batch
-            end
-            break if message.size + serialized_doc.size > max_append_size
-            batch_docs << docs.shift
-            batch_message_append(message, serialized_doc, write_concern)
-            serialized_doc = nil
-          end
-          begin
-            response = batch_message_send(message, op_type, batch_docs, write_concern, continue_on_error) if batch_docs.size > 0
-            exchanges << {:op_type => op_type, :batch => batch_docs, :opts => opts, :response => response}
-          rescue Mongo::WriteConcernError => ex
-            write_concern_errors << ex
-            exchanges << {:op_type => op_type, :batch => batch_docs, :opts => opts, :response => ex.result}
-          rescue Mongo::OperationFailure => ex
-            errors << ex
-            exchanges << {:op_type => op_type, :batch => batch_docs, :opts => opts, :response => ex.result}
-            throw(:error) unless continue_on_error
-          end
-        end
-      end
-      [error_docs, errors, write_concern_errors, exchanges]
-    end
-
-    def batch_write_partition(op_type, documents, check_keys, opts)
-      raise Mongo::OperationFailure, "Request contains no documents" if documents.empty?
-      write_concern = get_write_concern(opts, @collection)
-      ordered = opts[:ordered]
-      continue_on_error = !!opts[:continue_on_error] || ordered == false # continue_on_error default false
-      collect_on_error = !!opts[:collect_on_error] # collect_on_error default false
-      error_docs = [] # docs with serialization errors
-      errors = []
-      write_concern_errors = []
-      exchanges = []
-      @max_write_batch_size = @collection.db.connection.max_write_batch_size
-      @write_batch_size = [documents.size, @max_write_batch_size].min
-      docs = documents.dup
-      until docs.empty?
-        batch = docs.take(@write_batch_size)
-        begin
-          batch_to_send = batch #(op_type == :insert && !ordered.nil?) ? batch.collect{|doc|doc[:d]} : batch
-          if @collection.db.connection.use_write_command?(write_concern) # TODO - polymorphic send_write including legacy insert
-            response = send_bulk_write_command(op_type, batch_to_send, check_keys, opts)
-          else
-            response = send_write_operation(op_type, nil, batch_to_send, check_keys, opts, write_concern)
-          end
-          exchanges << {:op_type => op_type, :batch => batch, :opts => opts, :response => response}
-          docs = docs.drop(batch.size)
-          @write_batch_size = [(@write_batch_size*1097) >> 10, @write_batch_size+1].max unless docs.empty? # 2**(1/10) multiplicative increase
-          @write_batch_size = @max_write_batch_size if @write_batch_size > @max_write_batch_size
-        rescue BSON::InvalidDocument, BSON::InvalidKeyName, BSON::InvalidStringEncoding => ex
-          if @write_batch_size > 1 # decrease batch size
-            @write_batch_size = (@write_batch_size+1) >> 1 # 2**(-1) multiplicative decrease
-            next
-          end
-          # error on a single document
-          bulk_message = "Bulk write error - #{ex.message} - examine result for complete information"
-          ex = BulkWriteError.new(bulk_message, Mongo::ErrorCode::INVALID_BSON,
-                                  {:op_type => op_type, :batch => batch, :ord => batch.first[:ord], :opts => opts, :error => ex}) unless ordered.nil?
-          error_docs << docs.shift
-          next if collect_on_error
-          errors << ex
-          break unless continue_on_error
-        rescue Mongo::WriteConcernError => ex
-          write_concern_errors << ex
-          exchanges << {:op_type => op_type, :batch => batch_docs, :opts => opts, :response => ex.result}
-          docs = docs.drop(batch.size)
-        rescue Mongo::OperationFailure => ex
-          errors << ex
-          exchanges << {:op_type => op_type, :batch => batch, :opts => opts, :response => ex.result}
-          docs = docs.drop(batch.size)
-          break if !continue_on_error && !collect_on_error
-        end
-      end
-      [error_docs, errors, write_concern_errors, exchanges]
-    end
-
-    alias :batch_write :batch_write_incremental
-
-    def send_bulk_write_command(op_type, documents, check_keys, opts, collection_name=@name)
-      if op_type == :insert
-        documents = documents.collect{|doc| doc[:d]} if opts.key?(:ordered)
-        documents.each do |doc|
-          # TODO - @pk_factory.create_pk(doc)
-          if check_keys
-            doc.each_key do |key|
-              key = key.to_s
-              raise BSON::InvalidKeyName.new("key #{key} must not start with '$'") if key[0] == ?$
-              raise BSON::InvalidKeyName.new("key #{key} must not contain '.'") if key.include? ?.
-            end
-          end
-        end
-      #elsif op_type == :update # TODO - check keys
-      #elsif op_type == :delete
-      #else
-      #  raise ArgumentError, "Write operation type must be :insert, :update or :delete"
-      end
-      request = BSON::OrderedHash[op_type, collection_name].merge!(
-          Mongo::CollectionWriter::WRITE_COMMAND_ARG_KEY[op_type] => documents,
-          :writeConcern => get_write_concern(opts, @collection),
-          :ordered => opts[:ordered] || !opts[:continue_on_error]
-      )
-      @db.command(request)
-    end
-
-    private
-
-    def sort_by_first_sym(pairs)
-      pairs = pairs.collect{|first, rest| [first.to_s, rest]} #stringify_first
-      pairs = pairs.sort{|x,y| x.first <=> y.first }
-      pairs.collect{|first, rest| [first.to_sym, rest]} #symbolize_first
-    end
-
-    def ordered_group_by_first(pairs)
-      pairs.inject([[], nil]) do |memo, pair|
-        result, previous_value = memo
-        current_value = pair.first
-        result << [current_value, []] if previous_value != current_value
-        result.last.last << pair.last
-        [result, current_value]
-      end.first
-    end
-
-  end
-
-  class CollectionOperationWriter < CollectionWriter
-    def initialize(collection)
-      super(collection)
-    end
-
-    def send_write_operation(op_type, selector, doc_or_docs, check_keys, opts, write_concern, collection_name=@name)
-      message = BSON::ByteBuffer.new("", @connection.max_message_size)
-      message.put_int((op_type == :insert && !!opts[:continue_on_error]) ? 1 : 0)
-      BSON::BSON_RUBY.serialize_cstr(message, "#{@db.name}.#{collection_name}")
-      if op_type == :update
-        update_options  = 0
-        update_options += 1 if opts[:upsert]
-        update_options += 2 if opts[:multi]
-        message.put_int(update_options)
-      elsif op_type == :delete
-        delete_options = 0
-        delete_options += 1 if opts[:limit] && opts[:limit] != 0
-        message.put_int(delete_options)
-      end
-      message.put_binary(BSON::BSON_CODER.serialize(selector, false, true, @connection.max_bson_size).to_s) if selector
-      [doc_or_docs].flatten(1).compact.each do |document|
-        message.put_binary(BSON::BSON_CODER.serialize(document, check_keys, true, @connection.max_bson_size).to_s)
-        if message.size > @connection.max_message_size
-          raise BSON::InvalidDocument, "Message is too large. This message is limited to #{@connection.max_message_size} bytes."
-        end
-      end
-      instrument(op_type, :database => @db.name, :collection => collection_name, :selector => selector, :documents => doc_or_docs) do
-        op_code = OPCODE[op_type]
-        if Mongo::WriteConcern.gle?(write_concern)
-          @connection.send_message_with_gle(op_code, message, @db.name, nil, write_concern)
-        else
-          @connection.send_message(op_code, message)
-        end
-      end
-    end
-
-    def bulk_execute(ops, options, opts = {})
-      write_concern = get_write_concern(opts, @collection)
-      errors = []
-      write_concern_errors = []
-      exchanges = []
-      ops.each do |op_type, doc|
-        doc = {:d => @collection.pk_factory.create_pk(doc[:d]), :ord => doc[:ord]} if op_type == :insert
-        doc_opts = doc.merge(opts)
-        d = doc_opts.delete(:d)
-        q = doc_opts.delete(:q)
-        u = doc_opts.delete(:u)
-        begin  # use single and NOT batch inserts since there no index for an error
-          response = @collection.operation_writer.send_write_operation(op_type, q, d || u, check_keys = false, doc_opts, write_concern)
-          exchanges << {:op_type => op_type, :batch => [doc], :opts => opts, :response => response}
-        rescue BSON::InvalidDocument, BSON::InvalidKeyName, BSON::InvalidStringEncoding => ex
-          bulk_message = "Bulk write error - #{ex.message} - examine result for complete information"
-          ex = BulkWriteError.new(bulk_message, Mongo::ErrorCode::INVALID_BSON,
-                                  {:op_type => op_type, :serialize => doc, :ord => doc[:ord], :error => ex})
-          errors << ex
-          break if options[:ordered]
-        rescue Mongo::WriteConcernError => ex
-          write_concern_errors << ex
-          exchanges << {:op_type => op_type, :batch => [doc], :opts => opts, :response => ex.result}
-        rescue Mongo::OperationFailure => ex
-          errors << ex
-          exchanges << {:op_type => op_type, :batch => [doc], :opts => opts, :response => ex.result}
-          break if options[:ordered] && ex.result["err"] != "norepl"
-        end
-      end
-      [errors, write_concern_errors, exchanges]
-    end
-
-    private
-
-    def batch_message_initialize(message, op_type, continue_on_error, write_concern)
-      message.clear!.clear
-      message.put_int(continue_on_error ? 1 : 0)
-      BSON::BSON_RUBY.serialize_cstr(message, "#{@db.name}.#{@name}")
-    end
-
-    def batch_message_append(message, serialized_doc, write_concern)
-      message.put_binary(serialized_doc.to_s)
-    end
-
-    def batch_message_send(message, op_type, batch_docs, write_concern, continue_on_error)
-      instrument(:insert, :database => @db.name, :collection => @name, :documents => batch_docs) do
-        if Mongo::WriteConcern.gle?(write_concern)
-          @connection.send_message_with_gle(Mongo::Constants::OP_INSERT, message, @db.name, nil, write_concern)
-        else
-          @connection.send_message(Mongo::Constants::OP_INSERT, message)
-        end
-      end
-    end
-
-    def batch_write_max_sizes(write_concern)
-      [@connection.max_message_size, @connection.max_message_size, @connection.max_bson_size]
-    end
-
-  end
-
-  class CollectionCommandWriter < CollectionWriter
-    def initialize(collection)
-      super(collection)
-    end
-
-    def send_write_command(op_type, selector, doc_or_docs, check_keys, opts, write_concern, collection_name=@name)
-      if op_type == :insert
-        argument = [doc_or_docs].flatten(1).compact
-      elsif op_type == :update
-        argument = [{:q => selector, :u => doc_or_docs, :multi => !!opts[:multi]}]
-        argument.first.merge!(:upsert => opts[:upsert]) if opts[:upsert]
-      elsif op_type == :delete
-        argument = [{:q => selector, :limit => (opts[:limit] || 0)}]
-      else
-        raise ArgumentError, "Write operation type must be :insert, :update or :delete"
-      end
-      request = BSON::OrderedHash[op_type, collection_name, WRITE_COMMAND_ARG_KEY[op_type], argument]
-      request.merge!(:writeConcern => write_concern, :ordered => !opts[:continue_on_error])
-      request.merge!(opts)
-      instrument(op_type, :database => @db.name, :collection => collection_name, :selector => selector, :documents => doc_or_docs) do
-        @db.command(request)
-      end
-    end
-
-    def bulk_execute(ops, options, opts = {})
-      errors = []
-      write_concern_errors = []
-      exchanges = []
-      ops = (options[:ordered] == false) ? sort_by_first_sym(ops) : ops # sort by write-type
-      ordered_group_by_first(ops).each do |op_type, documents|
-        documents.collect! {|doc| {:d => @collection.pk_factory.create_pk(doc[:d]), :ord => doc[:ord]} } if op_type == :insert
-        error_docs, batch_errors, batch_write_concern_errors, batch_exchanges =
-            batch_write(op_type, documents, check_keys = false, opts.merge(:ordered => options[:ordered]))
-        errors += batch_errors
-        write_concern_errors += batch_write_concern_errors
-        exchanges += batch_exchanges
-        break if options[:ordered] && !batch_errors.empty?
-      end
-      [errors, write_concern_errors, exchanges]
-    end
-
-    private
-
-    def batch_message_initialize(message, op_type, continue_on_error, write_concern)
-      message.clear!.clear
-      @bson_empty ||= BSON::BSON_CODER.serialize({})
-      message.put_binary(@bson_empty.to_s)
-      message.unfinish!.array!(WRITE_COMMAND_ARG_KEY[op_type])
-    end
-
-    def batch_message_append(message, serialized_doc, write_concern)
-      message.push_doc!(serialized_doc)
-    end
-
-    def batch_message_send(message, op_type, batch_docs, write_concern, continue_on_error)
-      message.finish!
-      request = BSON::OrderedHash[op_type, @name, :bson, message]
-      request.merge!(:writeConcern => write_concern, :ordered => !continue_on_error)
-      instrument(:insert, :database => @db.name, :collection => @name, :documents => batch_docs) do
-        @db.command(request)
-      end
-    end
-
-    def batch_write_max_sizes(write_concern)
-      [MongoClient::COMMAND_HEADROOM, MongoClient::APPEND_HEADROOM, MongoClient::SERIALIZE_HEADROOM].collect{|h| @connection.max_bson_size + h}
-    end
-
-  end
-
-end
-