mongo 1.3.0 → 1.12.5

data/Rakefile

@@ -1,215 +1,31 @@
-# -*- mode: ruby; -*-
-require 'rubygems'
-require 'rubygems/specification'
-require 'fileutils'
-require 'rake'
-require 'rake/testtask'
-require 'rake/gempackagetask'
-require 'rbconfig'
-include Config
-ENV['TEST_MODE'] = 'TRUE'
-
-task :java do
-  Rake::Task['build:java'].invoke
-  Rake::Task['test:ruby'].invoke
-end
-
-namespace :build do
-  desc "Build the java extensions."
-  task :java do
-    puts "Building Java extensions..."
-    java_dir  = File.join(File.dirname(__FILE__), 'ext', 'java')
-    jar_dir   = File.join(java_dir, 'jar')
-
-    jruby_jar = File.join(jar_dir, 'jruby.jar')
-    mongo_jar = File.join(jar_dir, 'mongo-2.4.jar')
-    bson_jar = File.join(jar_dir, 'bson-2.2.jar')
-
-    src_base   = File.join(java_dir, 'src')
-
-    system("javac -Xlint:unchecked -classpath #{jruby_jar}:#{mongo_jar}:#{bson_jar} #{File.join(src_base, 'org', 'jbson', '*.java')}")
-    system("cd #{src_base} && jar cf #{File.join(jar_dir, 'jbson.jar')} #{File.join('.', 'org', 'jbson', '*.class')}")
-  end
-end
-
-desc "Test the MongoDB Ruby driver."
-task :test do
-  puts "\nTo test the driver with the C-extensions:\nrake test:c\n\n"
-  puts "To test the pure ruby driver: \nrake test:ruby\n\n"
-end
-
-namespace :test do
-
-  desc "Test the driver with the C extension enabled."
-  task :c do
-    ENV['C_EXT'] = 'TRUE'
-    if ENV['TEST']
-      Rake::Task['test:functional'].invoke
-    else
-      Rake::Task['test:unit'].invoke
-      Rake::Task['test:functional'].invoke
-      Rake::Task['test:bson'].invoke
-      Rake::Task['test:pooled_threading'].invoke
-      Rake::Task['test:drop_databases'].invoke
-    end
-    ENV['C_EXT'] = nil
-  end
-
-  desc "Test the driver using pure ruby (no C extension)"
-  task :ruby do
-    ENV['C_EXT'] = nil
-    if ENV['TEST']
-      Rake::Task['test:functional'].invoke
-    else
-      Rake::Task['test:unit'].invoke
-      Rake::Task['test:functional'].invoke
-      Rake::Task['test:bson'].invoke
-      Rake::Task['test:pooled_threading'].invoke
-      Rake::Task['test:drop_databases'].invoke
-    end
-  end
-
-  desc "Run the replica set test suite"
-  Rake::TestTask.new(:rs) do |t|
-    t.test_files = FileList['test/replica_sets/*_test.rb']
-    t.verbose    = true
-    t.ruby_opts << '-w'
-  end
-
-  Rake::TestTask.new(:unit) do |t|
-    t.test_files = FileList['test/unit/*_test.rb']
-    t.verbose    = true
-    t.ruby_opts << '-w'
-  end
-
-  Rake::TestTask.new(:functional) do |t|
-    t.test_files = FileList['test/*_test.rb']
-    t.verbose    = true
-    t.ruby_opts << '-w'
-  end
-
-  Rake::TestTask.new(:pooled_threading) do |t|
-    t.test_files = FileList['test/threading/*_test.rb']
-    t.verbose    = true
-    t.ruby_opts << '-w'
-  end
-
-  Rake::TestTask.new(:auto_reconnect) do |t|
-    t.test_files = FileList['test/auxillary/autoreconnect_test.rb']
-    t.verbose    = true
-    t.ruby_opts << '-w'
-  end
-
-  Rake::TestTask.new(:authentication) do |t|
-    t.test_files = FileList['test/auxillary/authentication_test.rb']
-    t.verbose    = true
-    t.ruby_opts << '-w'
-  end
-
-  Rake::TestTask.new(:new_features) do |t|
-    t.test_files = FileList['test/auxillary/1.4_features.rb']
-    t.verbose    = true
-    t.ruby_opts << '-w'
-  end
+# 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.
 
-  Rake::TestTask.new(:bson) do |t|
-    t.test_files = FileList['test/bson/*_test.rb']
-    t.verbose    = true
-    t.ruby_opts << '-w'
-  end
-
-  task :drop_databases do |t|
-    puts "Dropping test databases..."
-    require './lib/mongo'
-    con = Mongo::Connection.new(ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost',
-      ENV['MONGO_RUBY_DRIVER_PORT'] || Mongo::Connection::DEFAULT_PORT)
-    con.database_names.each do |name|
-      con.drop_database(name) if name =~ /^ruby-test/
-    end
-  end
-end
-
-desc "Generate RDOC documentation"
-task :rdoc do
-  version = eval(File.read("mongo.gemspec")).version
-  out = File.join('html', version.to_s)
-  FileUtils.rm_rf('html')
-  system "rdoc --main README.md --op #{out} --inline-source --quiet README.md `find lib -name '*.rb'`"
-end
-
-desc "Generate YARD documentation"
-task :ydoc do
-  require File.join(File.dirname(__FILE__), 'lib', 'mongo')
-  out = File.join('ydoc', Mongo::VERSION)
-  FileUtils.rm_rf('ydoc')
-  system "yardoc lib/**/*.rb lib/mongo/**/*.rb lib/bson/**/*.rb -e yard/yard_ext.rb -p yard/templates -o #{out} --title MongoRuby-#{Mongo::VERSION} --files docs/TUTORIAL.md,docs/GridFS.md,docs/FAQ.md,docs/REPLICA_SETS.md,docs/WRITE_CONCERN.md,docs/HISTORY.md,docs/CREDITS.md,docs/RELEASES.md"
-end
-
-namespace :bamboo do
-  task :ci_reporter do
-    begin
-      require 'ci/reporter/rake/test_unit'
-    rescue LoadError
-      warn "Warning: Unable to load ci_reporter gem."
-    end
-  end
-
-  namespace :test do
-    task :ruby => [:ci_reporter, "ci:setup:testunit"] do
-      Rake::Task['test:ruby'].invoke
-    end
-
-    task :c => [:ci_reporter, "ci:setup:testunit"] do
-      Rake::Task['gem:install_extensions'].invoke
-      Rake::Task['test:c'].invoke
-    end
-  end
-end
-
-namespace :gem do
-
-  desc "Install the gem locally"
-  task :install do
-    `gem build bson.gemspec`
-    `gem install --no-rdoc --no-ri bson-*.gem`
-
-    `gem build mongo.gemspec`
-    `gem install --no-rdoc --no-ri mongo-*.gem`
-
-    `rm mongo-*.gem`
-    `rm bson-*.gem`
-  end
-
-  desc "Install the optional c extensions"
-  task :install_extensions do
-    `gem uninstall bson_ext`
-    `gem build bson_ext.gemspec`
-    `gem install --no-rdoc --no-ri bson_ext-*.gem`
-    `rm bson_ext-*.gem`
-  end
-
-  desc "Build all gems"
-  task :build_all do
-    `gem build mongo.gemspec`
-    `gem build bson.gemspec`
-    `gem build bson.java.gemspec`
-    `gem build bson_ext.gemspec`
-  end
+require 'rubygems'
 
+begin
+  require 'bundler'
+rescue LoadError
+  raise '[FAIL] Bundler not found! Install it with `gem install bundler && bundle`.'
 end
 
-namespace :ci do
-  namespace :test do
-    task :c do
-      Rake::Task['gem:install'].invoke
-      Rake::Task['gem:install_extensions'].invoke
-      Rake::Task['test:c'].invoke
-    end
-  end
+rake_tasks = Dir.glob(File.join('tasks', '**', '*.rake')).sort
+if ENV.keys.any? { |k| k.end_with?('_CI') }
+  Bundler.require(:default, :testing)
+  rake_tasks.reject! { |r| r =~ /deploy/ }
+else
+  Bundler.require(:default, :testing, :deploy, :development)
 end
 
-task :default => :list
-
-task :list do
-  system 'rake -T'
-end
+rake_tasks.each { |rake| load File.expand_path(rake) }

data/VERSION

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

data/bin/mongo_console

@@ -1,21 +1,43 @@
 #!/usr/bin/env ruby
+
+# 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.
+
 org_argv = ARGV.dup
 ARGV.clear
 
-require 'irb'
-
 $LOAD_PATH[0,0] = File.join(File.dirname(__FILE__), '..', 'lib')
-require 'mongo'
 
+require 'mongo'
 include Mongo
 
 host = org_argv[0] || ENV['MONGO_RUBY_DRIVER_HOST'] || 'localhost'
-port = org_argv[1] || ENV['MONGO_RUBY_DRIVER_PORT'] || Connection::DEFAULT_PORT
+port = org_argv[1] || ENV['MONGO_RUBY_DRIVER_PORT'] || MongoClient::DEFAULT_PORT
 dbnm = org_argv[2] || ENV['MONGO_RUBY_DRIVER_DB']   || 'ruby-mongo-console'
 
-puts "Connecting to #{host}:#{port} (CONN) on with database #{dbnm} (DB)"
-CONN = Connection.new(host, port)
-DB = CONN.db(dbnm)
+puts "Connecting to #{host}:#{port} (CLIENT) on with database #{dbnm} (DB)"
+CLIENT = MongoClient.new(host, port)
+DB = CLIENT.db(dbnm)
+
+# try pry if available, fall back to irb
+begin
+  require 'pry'
+  CONSOLE_CLASS = Pry
+rescue LoadError
+  require 'irb'
+  CONSOLE_CLASS = IRB
+end
 
-puts "Starting IRB session..."
-IRB.start(__FILE__)
+puts "Starting #{CONSOLE_CLASS.name} session..."
+CONSOLE_CLASS.start(__FILE__)

data/lib/mongo/bulk_write_collection_view.rb

@@ -0,0 +1,387 @@
+# 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