mongo 1.3.1 → 1.4.0

data/README.md

@@ -7,11 +7,13 @@ This documentation includes other articles of interest, include:
 1. [A tutorial](http://api.mongodb.org/ruby/current/file.TUTORIAL.html).
 2. [Replica Sets in Ruby](http://api.mongodb.org/ruby/current/file.REPLICA_SETS.html).
 3. [Write Concern in Ruby](http://api.mongodb.org/ruby/current/file.WRITE_CONCERN.html).
-4. [GridFS in Ruby](http://api.mongodb.org/ruby/current/file.GridFS.html).
-5. [Frequently Asked Questions](http://api.mongodb.org/ruby/current/file.FAQ.html).
-6. [History](http://api.mongodb.org/ruby/current/file.HISTORY.html).
-6. [Release plan](http://api.mongodb.org/ruby/current/file.RELEASES.html).
-7. [Credits](http://api.mongodb.org/ruby/current/file.CREDITS.html).
+4. [Tailable Cursors in Ruby](http://api.mongodb.org/ruby/current/file.TAILABLE_CURSORS.html).
+5. [Read Preference in Ruby](http://api.mongodb.org/ruby/current/file.READ_PREFERENCE.html).
+6. [GridFS in Ruby](http://api.mongodb.org/ruby/current/file.GridFS.html).
+7. [Frequently Asked Questions](http://api.mongodb.org/ruby/current/file.FAQ.html).
+8. [History](http://api.mongodb.org/ruby/current/file.HISTORY.html).
+9. [Release plan](http://api.mongodb.org/ruby/current/file.RELEASES.html).
+10. [Credits](http://api.mongodb.org/ruby/current/file.CREDITS.html).
 
 Here's a quick code sample. Again, see the [MongoDB Ruby Tutorial](http://api.mongodb.org/ruby/current/file.TUTORIAL.html)
 for much more:
@@ -109,9 +111,10 @@ for details, and see examples/gridfs.rb for code that uses many of the Grid
 features (metadata, content type, seek, tell, etc).
 
 Examples:
+
       # Write a file on disk to the Grid
       file = File.open('image.jpg')
-      grid = Grid.new(db)
+      grid = Mongo::Grid.new(db)
       id   = grid.put(file)
 
       # Retrieve the file

data/Rakefile

@@ -22,12 +22,11 @@ namespace :build do
     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')
+    mongo_jar = File.join(jar_dir, 'mongo-2.6.5.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("javac -Xlint:deprecation -Xlint:unchecked -classpath #{jruby_jar}:#{mongo_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
@@ -142,7 +141,7 @@ 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"
+  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/READ_PREFERENCE.md,docs/HISTORY.md,docs/CREDITS.md,docs/RELEASES.md,docs/CREDITS.md,docs/TAILABLE_CURSORS.md"
 end
 
 namespace :bamboo do

data/docs/HISTORY.md

@@ -1,5 +1,23 @@
 # MongoDB Ruby Driver History
 
+### 1.4.0
+2011-9-19
+
+* Attempt to automatically refresh internal replica set state using ReplSetConnection#refresh.
+* Two automated refresh modes: :async and :sync. Automated refresh can also be disabled.
+* Choose secondary for reads based on ping time.
+* Read preference API: specify whether queries should go to primary or secondary on a per-query basis.
+* Pass :require_primary => false to ReplSetConnection to connect without requiring a primary node.
+* Enable exhaust-mode queries with OP_QUERY_EXHAUST.
+* Collection#count takes a query selector.
+* Support continue_on_error flag for bulk inserts (use :continue_on_error => true)
+* Add Cursor#add_option. Deprecate Cursor#query_opts and replace with Cursor#options.
+* Initial SSL support (connect with :ssl => true)
+* Update to latest Java driver for JRuby.
+* Check max BSON size on a per-connection basis.
+* Fixed two platform-specific BSON serialization issues.
+* Lots of bug fixes and code cleanup.
+
 ### 1.3.1
 2011-5-10
 
@@ -43,8 +61,8 @@
 
 * Fix the exception message shown when there's an IOError (Mauro Pompilio)
 * Another update to map-reduce docs for v1.8. Note that if you use the new
-  output option {:out => {:inline => true}}, then you must also specify
-  :raw => true.
+  output option `{:out => {:inline => true}}`, then you must also specify
+  `:raw => true`.
 
 ### 1.2.3
 2011-2-22

data/docs/READ_PREFERENCE.md

@@ -0,0 +1,39 @@
+# Read Preference in Ruby
+
+## Setting the read preference
+
+You can using the `:read` option to specify a query's read preference. There are for now two possible options:
+
+    @collection.find({:doc => 'foo'}, :read => :primary)
+    @collection.find({:doc => 'foo'}, :read => :secondary)
+
+In the first case, the query will be directed to the primary node in a replica set. In the second, the query will be sent
+to a secondary node. The driver will attempt to choose a secondary node that's nearby, as determined by ping time. If more
+than one secondary node is closeby (e.g, responds to pings within 10ms), then a random node within this subset will be chosen.
+
+## Read preference inheritance
+
+The Ruby driver allows you to set read preference on each of four levels: the connection, database, collection, and cursor (or read operation).
+Objects will inherit the default read preference from their parents. Thus, if you set a read preference of `{:read => :secondary}` when creating
+a new connection, then all databases and collections created from that connection will inherit the same setting. See this code example:
+
+    @con = Mongo::ReplSetConnection.new([['localhost', 27017], ['localhost', 27018]], :read => :secondary)
+    @db  = @con['test']
+    @collection = @db['foo']
+    @collection.find({:name => 'foo'})
+
+    @collection.find({:name => 'bar'}, :read => :primary)
+
+Here, the first call to Collection#find will use the inherited read preference, `{:read => :secondary}`. But the second call
+to Collection#find overrides this setting by setting the preference to `:primary`.
+
+You can examine the read preference on any object by calling its `read_preference` method:
+
+    @con.read_preference
+    @db.read_preference
+    @collection.read_preference
+
+## Future work
+
+In the v2.0 release of the driver, you'll also be able to specify a read preference consisting of a set of tags. This way,
+you'll be able to direct reads to a replica set member. You can follow this issue's progress here: (https://jira.mongodb.org/browse/RUBY-326).

data/docs/RELEASES.md

@@ -13,7 +13,7 @@ following release rules:
 
 2. Minor versions (Y in x.Y.z) will be released if new, backward-compatible functionality is introduced to the public API.
 
-3. Major versions (X in X.y.z) will be incremented if any backward-incompatibl changes are introduced to the public API.
+3. Major versions (X in X.y.z) will be incremented if any backward-incompatible changes are introduced to the public API.
 
 This policy will clearly indicate to users when an upgrade may affect their code. As a side effect, version numbers will climb more quickly than before.
 

data/docs/REPLICA_SETS.md

@@ -15,10 +15,10 @@ cache the replica set topology as reported by the given seed node and use that i
 
 ### Read slaves
 
-If you want to read from a seconday node, you can pass :read_secondary => true to ReplSetConnection#new.
+If you want to read from a secondary node, you can pass :read => :secondary to ReplSetConnection#new.
 
     @connection = ReplSetConnection.new(['n1.mydb.net', 27017], ['n2.mydb.net', 27017], ['n3.mydb.net', 27017],
-                  :read_secondary => true)
+                  :read => :secondary)
 
 A random secondary will be chosen to be read from. In a typical multi-process Ruby application, you'll have a good distribution of reads across secondary nodes.
 
@@ -32,6 +32,27 @@ If the client decides to retry, it's not guaranteed that another member of the r
 
 The driver will essentially cycle through all known seed addresses until a node identifies itself as master.
 
+### Refresh mode
+
+You can now specify a refresh mode and refresh interval for a replica set connection. This will help to ensure that
+changes to a replica set's configuration are quickly reflected on the driver side. Refresh mode is
+enabled in synchronous mode by default. Here's how to specify this explicitly:
+
+    @connection = ReplSetConnection.new(['n1.mydb.net', 27017], :refresh_mode => :sync)
+
+If you want to refresh to happen via a background thread, use the `:async` mode:
+
+    @connection = ReplSetConnection.new(['n1.mydb.net', 27017], :refresh_mode => :async)
+
+If you want to change the default refresh interval of 90 seconds, you can do so like this:
+
+    @connection = ReplSetConnection.new(['n1.mydb.net', 27017], :refresh_mode => :async,
+        :refresh_interval => 60)
+
+You can also disable refresh mode altogether:
+
+    @connection = ReplSetConnection.new(['n1.mydb.net', 27017], :refresh_mode => false)
+
 ### Recovery
 
 Driver users may wish to wrap their database calls with failure recovery code. Here's one possibility, which will attempt to connection

data/docs/TAILABLE_CURSORS.md

@@ -0,0 +1,51 @@
+# Tailable cursors in Ruby
+
+Tailable cursors are cursors that remain open even after they've returned
+a final result. This way, if more documents are added to a collection (i.e.,
+to the cursor's result set), then you can continue to call `Cursor#next` to
+retrieve those results. Here's a complete test case that demonstrates the use
+of tailable cursors.
+
+Note that tailable cursors are for capped collections only.
+
+      require 'mongo'
+      require 'test/unit'
+
+      class TestTailable < Test::Unit::TestCase
+        include Mongo
+
+        def test_tailable
+
+          # Create a connection and capped collection.
+          @con = Connection.new
+          @db  = @con['test']
+          @db.drop_collection('log')
+          @capped = @db.create_collection('log', :capped => true, :size => 1024)
+
+          # Insert 10 documents.
+          10.times do |n|
+            @capped.insert({:n => n})
+          end
+
+          # Create a tailable cursor that iterates the collection in natural order
+          @tail = Cursor.new(@capped, :tailable => true, :order => [['$natural', 1]])
+
+          # Call Cursor#next 10 times. Each call returns a document.
+          10.times do
+            assert @tail.next
+          end
+
+          # But the 11th time, the cursor returns nothing.
+          assert_nil @tail.next
+
+          # Add a document to the capped collection.
+          @capped.insert({:n => 100})
+
+          # Now call Cursor#next again. This will return the just-inserted result.
+          assert @tail.next
+
+          # Close the cursor.
+          @tail.close
+        end
+
+      end

data/docs/TUTORIAL.md

@@ -15,7 +15,7 @@ Next, install the mongo rubygem:
 
 The required `bson` gem will be installed automatically.
 
-For optimum performance, install the bson_ext gem:
+For optimum performance, install the bson\_ext gem:
 
     gem install bson_ext
 
@@ -98,7 +98,7 @@ Once you have the collection object, you can insert documents into the collectio
 Notice that the above has an "inner" document embedded within it.  To do this, we can use a Hash or the driver's OrderedHash (which preserves key order) to create the document (including the inner document), and then just simply insert it into the collection using the `insert()` method.
 
     doc = {"name" => "MongoDB", "type" => "database", "count" => 1,
-           "info" => {"x" => 203, "y" => '102'`
+           "info" => {"x" => 203, "y" => '102'}}
     coll.insert(doc)
 
 #### Updating a Document
@@ -110,7 +110,7 @@ We can update the previous document using the `update` method. There are a coupl
 
 Or we can use an atomic operator to change a single value:
 
-    coll.update({"_id" => doc["_id"]}, {"$set" => {"name" => "MongoDB Ruby"`)
+    coll.update({"_id" => doc["_id"]}, {"$set" => {"name" => "MongoDB Ruby"}})
 
 Read [more about updating documents|Updating].
 
@@ -126,7 +126,7 @@ and you should see:
     {"_id"=>#<BSON::ObjectID:0x118576c ...>, "name"=>"MongoDB",
      "info"=>{"x"=>203, "y"=>102}, "type"=>"database", "count"=>1}
 
-Note the `\_id` element has been added automatically by MongoDB to your document.
+Note the `_id` element has been added automatically by MongoDB to your document.
 
 #### Adding Multiple Documents
 

data/docs/WRITE_CONCERN.md

@@ -7,9 +7,12 @@ Write concern is set using the `:safe` option. There are several possible option
     @collection.save({:doc => 'foo'}, :safe => true)
     @collection.save({:doc => 'foo'}, :safe => {:w => 2})
     @collection.save({:doc => 'foo'}, :safe => {:w => 2, :wtimeout => 200})
-    @collection.save({:doc => 'foo'}, :safe => {:w => 2, :wtimeout => 200, :fsync => true})
+    @collection.save({:doc => 'foo'}, :safe => {:w => 2, :wtimeout => 200, :j => true})
 
-The first, `true`, simply indicates that we should request a response from the server to ensure that to errors have occurred. The second, `{:w => 2}`forces the server to wait until at least two servers have recorded the write. The third does the same but will time out if the replication can't be completed in 200 milliseconds. The fourth forces an fsync on each server being written to (note: this option is rarely necessary and will have a dramaticly negative effect on performance).
+The first, `true`, simply indicates that we should request a response from the server to ensure that to errors have occurred. The second, `{:w => 2}`, forces the server to wait until at least two servers have recorded the write. The third does the same but will time out if the replication can't be completed in 200 milliseconds.
+Setting a value for `wtimeout` is encouraed.
+
+Finally, the fourth example forces the journal to sync to disk if journaling is enabled.
 
 ## Write concern inheritance
 

data/lib/mongo.rb

@@ -18,9 +18,7 @@
 
 $:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 
-module Mongo
-  VERSION = "1.3.1"
-end
+require 'mongo/version'
 
 module Mongo
   ASCENDING  =  1
@@ -58,8 +56,12 @@ require 'bson'
 require 'mongo/util/conversions'
 require 'mongo/util/support'
 require 'mongo/util/core_ext'
+require 'mongo/util/logging'
+require 'mongo/util/node'
 require 'mongo/util/pool'
+require 'mongo/util/pool_manager'
 require 'mongo/util/server_version'
+require 'mongo/util/ssl_socket'
 require 'mongo/util/uri_parser'
 
 require 'mongo/collection'
@@ -76,22 +78,5 @@ if RUBY_PLATFORM =~ /java/
 end
 require 'mongo/gridfs/grid_file_system'
 
-# Use SystemTimer on Ruby 1.8
-if !defined?(RUBY_ENGINE) || (RUBY_ENGINE == 'ruby' && RUBY_VERSION < '1.9.0')
-  begin
-    require 'system_timer'
-    if SystemTimer.method(:timeout).arity.abs != 2
-      raise LoadError
-    end
-    Mongo::TimeoutHandler = SystemTimer
-  rescue LoadError
-    warn "Could not load SystemTimer >= v1.2.0. Falling back to timeout.rb. " +
-         "SystemTimer is STRONGLY recommended for timeouts in Ruby 1.8.7. " +
-         "See http://ph7spot.com/blog/system-timer-1-2-release for details."
-    require 'timeout'
-    Mongo::TimeoutHandler = Timeout
-  end
-else
-  require 'timeout'
-  Mongo::TimeoutHandler = Timeout
-end
+require 'timeout'
+Mongo::TimeoutHandler = Timeout

data/lib/mongo/collection.rb

@@ -19,6 +19,7 @@ module Mongo
 
   # A named collection of documents in a database.
   class Collection
+    include Mongo::Logging
 
     attr_reader :db, :name, :pk_factory, :hint, :safe
 
@@ -34,6 +35,11 @@ module Mongo
     #   for insert, update, and remove method called on this Collection instance. If no
     #   value is provided, the default value set on this instance's DB will be used. This
     #   default can be overridden for any invocation of insert, update, or remove.
+    # @option options [:primary, :secondary] :read The default read preference for queries
+    #   initiates from this connection object. If +:secondary+ is chosen, reads will be sent
+    #   to one of the closest available secondary nodes. If a secondary node cannot be located, the
+    #   read will be sent to the primary. If this option is left unspecified, the value of the read
+    #   preference for this collection's associated Mongo::DB object will be used.
     #
     # @raise [InvalidNSName]
     #   if collection name is empty, contains '$', or starts or ends with '.'
@@ -47,7 +53,8 @@ module Mongo
     def initialize(name, db, opts={})
       if db.is_a?(String) && name.is_a?(Mongo::DB)
         warn "Warning: the order of parameters to initialize a collection have changed. " +
-             "Please specify the collection name first, followed by the db."
+             "Please specify the collection name first, followed by the db. This will be made permanent" +
+             "in v2.0."
         db, name = name, db
       end
 
@@ -83,11 +90,27 @@ module Mongo
       @cache = Hash.new(0)
       unless pk_factory
         @safe = opts.fetch(:safe, @db.safe)
+        if value = opts[:read]
+          Mongo::Support.validate_read_preference(value)
+        else
+          value = @db.read_preference
+        end
+        @read_preference = value.is_a?(Hash) ? value.dup : value
       end
       @pk_factory = pk_factory || opts[:pk] || BSON::ObjectId
       @hint = nil
     end
 
+    # Indicate whether this is a capped collection.
+    #
+    # @raise [Mongo::OperationFailure]
+    #   if the collection doesn't exist.
+    #
+    # @return [Boolean]
+    def capped?
+      @db.command({:collstats => @name})['capped'] == 1
+    end
+
     # Return a sub-collection of this collection by name. If 'users' is a collection, then
     # 'users.comments' is a sub-collection of users.
     #
@@ -144,6 +167,11 @@ module Mongo
     #   you can cut down on network traffic and decoding time. If using a Hash, keys should be field
     #   names and values should be either 1 or 0, depending on whether you want to include or exclude
     #   the given field.
+    # @option opts [:primary, :secondary] :read The default read preference for queries
+    #   initiates from this connection object. If +:secondary+ is chosen, reads will be sent
+    #   to one of the closest available secondary nodes. If a secondary node cannot be located, the
+    #   read will be sent to the primary. If this option is left unspecified, the value of the read
+    #   preference for this Collection object will be used.
     # @option opts [Integer] :skip number of documents to skip from the beginning of the result set
     # @option opts [Integer] :limit maximum number of documents to return
     # @option opts [Array]   :sort an array of [key, direction] pairs to sort by. Direction should
@@ -186,7 +214,11 @@ module Mongo
       snapshot   = opts.delete(:snapshot)
       batch_size = opts.delete(:batch_size)
       timeout    = (opts.delete(:timeout) == false) ? false : true
+      max_scan   = opts.delete(:max_scan)
+      return_key = opts.delete(:return_key)
       transformer = opts.delete(:transformer)
+      show_disk_loc = opts.delete(:max_scan)
+      read          = opts.delete(:read) || @read_preference
 
       if timeout == false && !block_given?
         raise ArgumentError, "Collection#find must be invoked with a block when timeout is disabled."
@@ -201,16 +233,20 @@ module Mongo
       raise RuntimeError, "Unknown options [#{opts.inspect}]" unless opts.empty?
 
       cursor = Cursor.new(self, {
-        :selector    => selector, 
-        :fields      => fields, 
-        :skip        => skip, 
+        :selector    => selector,
+        :fields      => fields,
+        :skip        => skip,
         :limit       => limit,
-        :order       => sort, 
-        :hint        => hint, 
-        :snapshot    => snapshot, 
-        :timeout     => timeout, 
+        :order       => sort,
+        :hint        => hint,
+        :snapshot    => snapshot,
+        :timeout     => timeout,
         :batch_size  => batch_size,
         :transformer => transformer,
+        :max_scan    => max_scan,
+        :show_disk_loc => show_disk_loc,
+        :return_key    => return_key,
+        :read          => read
       })
 
       if block_given?
@@ -267,8 +303,6 @@ module Mongo
     #   for DB#error.
     #
     # @raise [OperationFailure] when :safe mode fails.
-    #
-    # @see DB#remove for options that can be passed to :safe.
     def save(doc, opts={})
       if doc.has_key?(:_id) || doc.has_key?('_id')
         id = doc[:_id] || doc['_id']
@@ -295,14 +329,17 @@ module Mongo
     #   its database object, or the current connection. See the options on
     #   for DB#get_last_error.
     #
-    # @see DB#remove for options that can be passed to :safe.
+    # @option opts [Boolean] :continue_on_error (+false+) If true, then
+    #   continue a bulk insert even if one of the documents inserted
+    #   triggers a database assertion (as in a duplicate insert, for instance).
+    #   MongoDB v2.0+.
     #
     # @core insert insert-instance_method
     def insert(doc_or_docs, opts={})
       doc_or_docs = [doc_or_docs] unless doc_or_docs.is_a?(Array)
       doc_or_docs.collect! { |doc| @pk_factory.create_pk(doc) }
       safe = opts.fetch(:safe, @safe)
-      result = insert_documents(doc_or_docs, @name, true, safe)
+      result = insert_documents(doc_or_docs, @name, true, safe, opts)
       result.size > 1 ? result : result.first
     end
     alias_method :<<, :insert
@@ -332,8 +369,6 @@ module Mongo
     # @raise [Mongo::OperationFailure] an exception will be raised iff safe mode is enabled
     #   and the operation fails.
     #
-    # @see DB#remove for options that can be passed to :safe.
-    #
     # @core remove remove-instance_method
     def remove(selector={}, opts={})
       # Initial byte is 0.
@@ -341,9 +376,9 @@ module Mongo
       message = BSON::ByteBuffer.new("\0\0\0\0")
       BSON::BSON_RUBY.serialize_cstr(message, "#{@db.name}.#{@name}")
       message.put_int(0)
-      message.put_binary(BSON::BSON_CODER.serialize(selector, false, true).to_s)
+      message.put_binary(BSON::BSON_CODER.serialize(selector, false, true, @connection.max_bson_size).to_s)
 
-      @connection.instrument(:remove, :database => @db.name, :collection => @name, :selector => selector) do
+      instrument(:remove, :database => @db.name, :collection => @name, :selector => selector) do
         if safe
           @connection.send_message_with_safe_check(Mongo::Constants::OP_DELETE, message, @db.name, nil, safe)
         else
@@ -388,9 +423,9 @@ module Mongo
       update_options += 2 if opts[:multi]
       message.put_int(update_options)
       message.put_binary(BSON::BSON_CODER.serialize(selector, false, true).to_s)
-      message.put_binary(BSON::BSON_CODER.serialize(document, false, true).to_s)
+      message.put_binary(BSON::BSON_CODER.serialize(document, false, true, @connection.max_bson_size).to_s)
 
-      @connection.instrument(:update, :database => @db.name, :collection => @name, :selector => selector, :document => document) do
+      instrument(:update, :database => @db.name, :collection => @name, :selector => selector, :document => document) do
         if safe
           @connection.send_message_with_safe_check(Mongo::Constants::OP_UPDATE, message, @db.name, nil, safe)
         else
@@ -470,6 +505,7 @@ module Mongo
     # @return [String] the name of the index.
     def ensure_index(spec, opts={})
       now = Time.now.utc.to_i
+      opts[:dropDups] = opts[:drop_dups] if opts[:drop_dups]
       field_spec = parse_index_spec(spec)
 
       name = opts[:name] || generate_index_name(field_spec)
@@ -490,6 +526,9 @@ module Mongo
     #
     # @core indexes
     def drop_index(name)
+      if name.is_a?(Array)
+        return drop_index(index_name(name))
+      end
       @cache[name.to_s] = nil
       @db.drop_index(@name, name)
     end
@@ -552,12 +591,12 @@ module Mongo
     # @option opts [Boolean ] :verbose (false) if true, provides statistics on job execution time.
     # @option opts [Boolean] :raw (false) if true, return the raw result object from the map_reduce command, and not
     #   the instantiated collection that's returned by default. Note if a collection name isn't returned in the
-    #   map-reduce output (as, for example, when using :out => {:inline => 1}), then you must specify this option
+    #   map-reduce output (as, for example, when using :out => { :inline => 1 }), then you must specify this option
     #   or an ArgumentError will be raised.
     #
     # @return [Collection, Hash] a Mongo::Collection object or a Hash with the map-reduce command's results.
     #
-    # @raise ArgumentError if you specify {:out => {:inline => true}} but don't specify :raw => true.
+    # @raise ArgumentError if you specify { :out => { :inline => true }} but don't specify :raw => true.
     #
     # @see http://www.mongodb.org/display/DOCS/MapReduce Offical MongoDB map/reduce documentation.
     #
@@ -565,13 +604,16 @@ module Mongo
     def map_reduce(map, reduce, opts={})
       map    = BSON::Code.new(map) unless map.is_a?(BSON::Code)
       reduce = BSON::Code.new(reduce) unless reduce.is_a?(BSON::Code)
-      raw    = opts[:raw]
+      raw    = opts.delete(:raw)
 
       hash = BSON::OrderedHash.new
       hash['mapreduce'] = self.name
       hash['map'] = map
       hash['reduce'] = reduce
       hash.merge! opts
+      if hash[:sort]
+        hash[:sort] = Mongo::Support.format_order_clause(hash[:sort])
+      end
 
       result = @db.command(hash)
       unless Mongo::Support.ok?(result)
@@ -609,7 +651,7 @@ module Mongo
       if opts.is_a?(Hash)
         return new_group(opts)
       else
-        warn "Collection#group no longer take a list of parameters. This usage is deprecated." +
+        warn "Collection#group no longer take a list of parameters. This usage is deprecated and will be remove in v2.0." +
              "Check out the new API at http://api.mongodb.org/ruby/current/Mongo/Collection.html#group-instance_method"
       end
 
@@ -656,6 +698,13 @@ module Mongo
       end
     end
 
+    # The value of the read preference. This will be
+    # either +:primary+, +:secondary+, or an object
+    # representing the tags to be read from.
+    def read_preference
+      @read_preference
+    end
+
     private
 
     def new_group(opts={})
@@ -792,9 +841,15 @@ module Mongo
 
     # Get the number of documents in this collection.
     #
+    # @option opts [Hash] :query ({}) A query selector for filtering the documents counted.
+    # @option opts [Integer] :skip (nil) The number of documents to skip.
+    # @option opts [Integer] :limit (nil) The number of documents to limit.
+    #
     # @return [Integer]
-    def count
-      find().count()
+    def count(opts={})
+      find(opts[:query],
+           :skip => opts[:skip],
+           :limit => opts[:limit]).count(true)
     end
 
     alias :size :count
@@ -818,6 +873,14 @@ module Mongo
 
     private
 
+    def index_name(spec)
+      field_spec = parse_index_spec(spec)
+      index_information.each do |index|
+        return index[0] if index[1]['key'] == field_spec
+      end
+      nil
+    end
+
     def parse_index_spec(spec)
       field_spec = BSON::OrderedHash.new
       if spec.is_a?(String) || spec.is_a?(Symbol)
@@ -864,16 +927,20 @@ module Mongo
     # Sends a Mongo::Constants::OP_INSERT message to the database.
     # Takes an array of +documents+, an optional +collection_name+, and a
     # +check_keys+ setting.
-    def insert_documents(documents, collection_name=@name, check_keys=true, safe=false)
-      # Initial byte is 0.
-      message = BSON::ByteBuffer.new("\0\0\0\0")
+    def insert_documents(documents, collection_name=@name, check_keys=true, safe=false, flags={})
+      if flags[:continue_on_error]
+        message = BSON::ByteBuffer.new
+        message.put_int(1)
+      else
+        message = BSON::ByteBuffer.new("\0\0\0\0")
+      end
       BSON::BSON_RUBY.serialize_cstr(message, "#{@db.name}.#{collection_name}")
       documents.each do |doc|
-        message.put_binary(BSON::BSON_CODER.serialize(doc, check_keys, true).to_s)
+        message.put_binary(BSON::BSON_CODER.serialize(doc, check_keys, true, @connection.max_bson_size).to_s)
       end
       raise InvalidOperation, "Exceded maximum insert size of 16,000,000 bytes" if message.size > 16_000_000
 
-      @connection.instrument(:insert, :database => @db.name, :collection => collection_name, :documents => documents) do
+      instrument(:insert, :database => @db.name, :collection => collection_name, :documents => documents) do
         if safe
           @connection.send_message_with_safe_check(Mongo::Constants::OP_INSERT, message, @db.name, nil, safe)
         else