mongo 2.1.0.beta → 2.2.0

data/lib/mongo/collection/view/readable.rb

@@ -21,32 +21,15 @@ module Mongo
       # @since 2.0.0
       module Readable
 
-        # Special fields and their getters for the query selector.
+        # The query modifier constant.
         #
-        # @since 2.0.0
-        SPECIAL_FIELDS = {
-          :$query => :selector,
-          :$readPreference => :read_pref_formatted,
-          :$orderby => :sort,
-          :$hint => :hint,
-          :$comment => :comment,
-          :$snapshot => :snapshot,
-          :$maxScan => :max_scan,
-          :$maxTimeMS => :max_time_ms,
-          :$showDiskLoc => :show_disk_loc,
-          :$explain => :explained?
-        }.freeze
-
-        # Options to cursor flags mapping.
+        # @since 2.2.0
+        QUERY = '$query'.freeze
+
+        # The modifiers option constant.
         #
-        # @since 2.1.0
-        CURSOR_FLAGS_MAP = {
-          :allow_partial_results => [ :partial ],
-          :oplog_replay => [ :oplog_replay ],
-          :no_cursor_timeout => [ :no_cursor_timeout ],
-          :tailable => [ :tailable_cursor ],
-          :tailable_await => [ :await_data, :tailable_cursor]
-        }.freeze
+        # @since 2.2.0
+        MODIFIERS = 'modifiers'.freeze
 
         # Execute an aggregation on the collection view.
         #
@@ -65,45 +48,28 @@ module Mongo
           Aggregation.new(self, pipeline, options)
         end
 
-        # Execute a parallel scan on the collection view.
-        # Returns a list of up to cursor_count cursors that can be iterated concurrently.
-        # As long as the collection is not modified during scanning, each document appears once
-        # in one of the cursors' result sets.
-        #
-        # @example Execute a parallel collection scan.
-        #   view.parallel_scan(2)
+        # Allows the query to get partial results if some shards are down.
         #
-        # @param [ Integer ] cursor_count The max number of cursors to return.
+        # @example Allow partial results.
+        #   view.allow_partial_results
         #
-        # @return [ Array<Cursor> ] An array of cursors.
+        # @return [ View ] The new view.
         #
-        # @since 2.1
-        def parallel_scan(cursor_count)
-          server = read.select_server(cluster)
-          Operation::ParallelScan.new(
-            :coll_name => collection.name,
-            :db_name => database.name,
-            :cursor_count => cursor_count
-          ).execute(server.context).cursor_ids.map do |cursor_id|
-            result = Operation::Read::GetMore.new({ :to_return => 0,
-                                                    :cursor_id => cursor_id,
-                                                    :db_name   => database.name,
-                                                    :coll_name => collection.name
-              }).execute(server.context)
-            Cursor.new(self, result, server)
-          end
+        # @since 2.0.0
+        def allow_partial_results
+          configure(:allow_partial_results, true)
         end
 
-        # Allows the query to get partial results if some shards are down.
+        # Tell the query's cursor to stay open and wait for data.
         #
-        # @example Allow partial results.
-        #   view.allow_partial_results
+        # @example Await data on the cursor.
+        #   view.await_data
         #
         # @return [ View ] The new view.
         #
         # @since 2.0.0
-        def allow_partial_results
-          configure_flag(:partial)
+        def await_data
+          configure(:await_data, true)
         end
 
         # The number of documents returned in each batch of results from MongoDB.
@@ -160,12 +126,15 @@ module Mongo
         #
         # @since 2.0.0
         def count(options = {})
-          cmd = { :count => collection.name, :query => selector }
+          cmd = { :count => collection.name, :query => filter }
           cmd[:skip] = options[:skip] if options[:skip]
           cmd[:hint] = options[:hint] if options[:hint]
           cmd[:limit] = options[:limit] if options[:limit]
           cmd[:maxTimeMS] = options[:max_time_ms] if options[:max_time_ms]
-          database.command(cmd, options).n
+          cmd[:readConcern] = collection.read_concern if collection.read_concern
+          read_with_retry do
+            database.command(cmd, options).n.to_i
+          end
         end
 
         # Get a list of distinct values for a specific field.
@@ -186,9 +155,12 @@ module Mongo
         def distinct(field_name, options={})
           cmd = { :distinct => collection.name,
                   :key => field_name.to_s,
-                  :query => selector }
+                  :query => filter }
           cmd[:maxTimeMS] = options[:max_time_ms] if options[:max_time_ms]
-          database.command(cmd, options).first['values']
+          cmd[:readConcern] = collection.read_concern if collection.read_concern
+          read_with_retry do
+            database.command(cmd, options).first['values']
+          end
         end
 
         # The index that MongoDB will be forced to use for the query.
@@ -249,6 +221,34 @@ module Mongo
           configure(:max_scan, value)
         end
 
+        # Set the maximum value to search.
+        #
+        # @example Set the max value.
+        #   view.max_value(_id: 1)
+        #
+        # @param [ Hash ] value The max field and value.
+        #
+        # @return [ Hash, View ] The value or a new +View+.
+        #
+        # @since 2.1.0
+        def max_value(value = nil)
+          configure(:max_value, value)
+        end
+
+        # Set the minimum value to search.
+        #
+        # @example Set the min value.
+        #   view.min_value(_id: 1)
+        #
+        # @param [ Hash ] value The min field and value.
+        #
+        # @return [ Hash, View ] The value or a new +View+.
+        #
+        # @since 2.1.0
+        def min_value(value = nil)
+          configure(:min_value, value)
+        end
+
         # The server normally times out idle cursors after an inactivity period
         # (10 minutes) to prevent excess memory use. Set this option to prevent that.
         #
@@ -259,7 +259,7 @@ module Mongo
         #
         # @since 2.0.0
         def no_cursor_timeout
-          configure_flag(:no_cursor_timeout)
+          configure(:no_cursor_timeout, true)
         end
 
         # The fields to include or exclude from each doc in the result set.
@@ -294,7 +294,22 @@ module Mongo
         # @since 2.0.0
         def read(value = nil)
           return default_read if value.nil?
-          configure(:read, value.is_a?(Hash) ? ServerSelector.get(value) : value)
+          selector = value.is_a?(Hash) ? ServerSelector.get(client.options.merge(value)) : value
+          configure(:read, selector)
+        end
+
+        # Set whether to return only the indexed field or fields.
+        #
+        # @example Set the return key value.
+        #   view.return_key(true)
+        #
+        # @param [ true, false ] value The return key value.
+        #
+        # @return [ true, false, View ] The value or a new +View+.
+        #
+        # @since 2.1.0
+        def return_key(value = nil)
+          configure(:return_key, value)
         end
 
         # Set whether the disk location should be shown for each document.
@@ -311,6 +326,7 @@ module Mongo
         def show_disk_loc(value = nil)
           configure(:show_disk_loc, value)
         end
+        alias :show_record_id :show_disk_loc
 
         # The number of docs to skip before returning results.
         #
@@ -368,7 +384,23 @@ module Mongo
         #
         # @since 2.1.0
         def modifiers(doc = nil)
-          configure(:modifiers, doc)
+          return Builder::Modifiers.map_server_modifiers(options) if doc.nil?
+          new(options.merge(Builder::Modifiers.map_driver_options(doc)))
+        end
+
+        # A cumulative time limit in milliseconds for processing get more operations
+        # on a cursor.
+        #
+        # @example Set the max await time ms value.
+        #   view.max_await_time_ms(500)
+        #
+        # @param [ Integer ] max The max time in milliseconds.
+        #
+        # @return [ Integer, View ] Either the max await time ms value or a new +View+.
+        #
+        # @since 2.1.0
+        def max_await_time_ms(max = nil)
+          configure(:max_await_time_ms, max)
         end
 
         # A cumulative time limit in milliseconds for processing operations on a cursor.
@@ -387,53 +419,35 @@ module Mongo
 
         private
 
-        def default_read(read = nil)
+        def default_read
           options[:read] || read_preference
         end
 
-        def flags
-          @flags ||= CURSOR_FLAGS_MAP.each.reduce([]) do |flags, (key, value)|
-            if options[key] || (options[:cursor_type] && options[:cursor_type] == key)
-              flags.push(*value)
+        def parallel_scan(cursor_count)
+          server = read.select_server(cluster, false)
+          Operation::Commands::ParallelScan.new(
+            :coll_name => collection.name,
+            :db_name => database.name,
+            :cursor_count => cursor_count,
+            :read_concern => collection.read_concern
+          ).execute(server.context).cursor_ids.map do |cursor_id|
+            result = if server.features.find_command_enabled?
+              Operation::Commands::GetMore.new({
+                  :selector => { :getMore => cursor_id, :collection => collection.name },
+                  :db_name  => database.name
+                }).execute(server.context)
+            else
+              Operation::Read::GetMore.new({
+                  :to_return => 0,
+                  :cursor_id => cursor_id,
+                  :db_name   => database.name,
+                  :coll_name => collection.name
+                }).execute(server.context)
             end
-            flags
-          end
-        end
-
-        def has_special_fields?
-          modifiers || sort || hint || comment || max_time_ms || max_scan ||
-              show_disk_loc || snapshot || explained? || cluster.sharded?
-        end
-
-        def query_options
-          { :project => projection, :skip => skip, :limit => to_return, :flags => flags }
-        end
-
-        def query_spec
-          sel = has_special_fields? ? special_selector : selector
-          { :selector  => sel,
-            :read      => read,
-            :options   => query_options,
-            :db_name   => database.name,
-            :coll_name => collection.name }
-        end
-
-        def read_pref_formatted
-          read.to_mongos
-        end
-
-        def special_selector
-          SPECIAL_FIELDS.reduce({}) do |hash, (key, method)|
-            value = send(method) || (options[:modifiers] && options[:modifiers][key])
-            hash[key] = value if value
-            hash
+            Cursor.new(self, result, server)
           end
         end
 
-        def to_return
-          [ limit || batch_size, batch_size || limit ].min
-        end
-
         def validate_doc!(doc)
           raise Error::InvalidDocument.new unless doc.respond_to?(:keys)
         end

data/lib/mongo/collection/view/writable.rb

@@ -31,11 +31,16 @@ module Mongo
         #
         # @since 2.0.0
         def find_one_and_delete
-          cmd = { :findandmodify => collection.name, :query => selector, :remove => true }
+          cmd = { :findandmodify => collection.name, :query => filter, :remove => true }
           cmd[:fields] = projection if projection
           cmd[:sort] = sort if sort
           cmd[:maxTimeMS] = max_time_ms if max_time_ms
-          database.command(cmd).first['value']
+          wc = options[:write_concern] || (collection.write_concern &&
+                                           collection.write_concern.options)
+          cmd[:writeConcern] = wc if wc
+          write_with_retry do
+            database.command(cmd).first['value']
+          end
         end
 
         # Finds a single document and replaces it.
@@ -50,8 +55,11 @@ module Mongo
         # @param [ Hash ] opts The options.
         #
         # @option opts [ Symbol ] :return_document Either :before or :after.
-        # @option opts [ true, false ] :upsert Whether to upsert if the
-        #   document doesn't exist.
+        # @option opts [ true, false ] :upsert Whether to upsert if the document doesn't exist.
+        # @option opts [ true, false ] :bypass_document_validation Whether or
+        #   not to skip document level validation.
+        # @option options [ Hash ] :write_concern The write concern options.
+        #   Defaults to the collection's write concern.
         #
         # @return [ BSON::Document ] The document.
         #
@@ -69,20 +77,31 @@ module Mongo
         # @param [ Hash ] opts The options.
         #
         # @option opts [ Symbol ] :return_document Either :before or :after.
+        # @option opts [ true, false ] :upsert Whether to upsert if the document doesn't exist.
+        # @option opts [ true, false ] :bypass_document_validation Whether or
+        #   not to skip document level validation.
+        # @option options [ Hash ] :write_concern The write concern options.
+        #   Defaults to the collection's write concern.
         #
         # @return [ BSON::Document ] The document.
         #
         # @since 2.0.0
         def find_one_and_update(document, opts = {})
-          cmd = { :findandmodify => collection.name, :query => selector }
+          cmd = { :findandmodify => collection.name, :query => filter }
           cmd[:update] = document
           cmd[:fields] = projection if projection
           cmd[:sort] = sort if sort
           cmd[:new] = !!(opts[:return_document] && opts[:return_document] == :after)
           cmd[:upsert] = opts[:upsert] if opts[:upsert]
           cmd[:maxTimeMS] = max_time_ms if max_time_ms
-          value = database.command(cmd).first['value']
-          value unless value.nil? || value.empty?
+          cmd[:bypassDocumentValidation] = !!opts[:bypass_document_validation]
+          wc = options[:write_concern] || (collection.write_concern &&
+                                           collection.write_concern.options)
+          cmd[:writeConcern] = wc if wc
+          write_with_retry do
+            value = database.command(cmd).first['value']
+            value unless value.nil? || value.empty?
+          end
         end
 
         # Remove documents from the collection.
@@ -166,24 +185,29 @@ module Mongo
         private
 
         def remove(value)
-          Operation::Write::Delete.new(
-            :delete => { q: selector, limit: value },
-            :db_name => collection.database.name,
-            :coll_name => collection.name,
-            :write_concern => collection.write_concern
-          ).execute(next_primary.context)
+          write_with_retry do
+            Operation::Write::Delete.new(
+              :delete => { Operation::Q => filter, Operation::LIMIT => value },
+              :db_name => collection.database.name,
+              :coll_name => collection.name,
+              :write_concern => collection.write_concern
+            ).execute(next_primary.context)
+          end
         end
 
         def update(spec, multi, opts)
-          Operation::Write::Update.new(
-            :update => { q: selector,
-                         u: spec,
-                         multi: multi,
-                         upsert: !!opts[:upsert] },
-            :db_name => collection.database.name,
-            :coll_name => collection.name,
-            :write_concern => collection.write_concern
-          ).execute(next_primary.context)
+          write_with_retry do
+            Operation::Write::Update.new(
+              :update => { Operation::Q => filter,
+                           Operation::U => spec,
+                           Operation::MULTI => multi,
+                           Operation::UPSERT => !!opts[:upsert] },
+              :db_name => collection.database.name,
+              :coll_name => collection.name,
+              :write_concern => collection.write_concern,
+              :bypass_document_validation => !!opts[:bypass_document_validation]
+            ).execute(next_primary.context)
+          end
         end
       end
     end

data/lib/mongo/collection/view.rb

@@ -12,6 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+require 'mongo/collection/view/builder'
 require 'mongo/collection/view/immutable'
 require 'mongo/collection/view/iterable'
 require 'mongo/collection/view/explainable'
@@ -44,13 +45,15 @@ module Mongo
       include Immutable
       include Iterable
       include Readable
+      include Retryable
       include Explainable
       include Writable
 
-      # @return [ View ] The +View+ to query.
+      # @return [ Collection ] The +Collection+ to query.
       attr_reader :collection
-      # @return [ Hash ] The query selector.
-      attr_reader :selector
+
+      # @return [ Hash ] The query filter.
+      attr_reader :filter
 
       # Delegate necessary operations to the collection.
       def_delegators :collection, :client, :cluster, :database, :read_preference, :write_concern
@@ -58,25 +61,27 @@ module Mongo
       # Delegate to the cluster for the next primary.
       def_delegators :cluster, :next_primary
 
+      alias :selector :filter
+
       # Compare two +View+ objects.
       #
       # @example Compare the view with another object.
       #   view == other
       #
-      # @return [ true, false ] Equal if collection, selector, and options of two
+      # @return [ true, false ] Equal if collection, filter, and options of two
       #   +View+ match.
       #
       # @since 2.0.0
       def ==(other)
         return false unless other.is_a?(View)
         collection == other.collection &&
-            selector == other.selector &&
+            filter == other.filter &&
             options == other.options
       end
       alias_method :eql?, :==
 
       # A hash value for the +View+ composed of the collection namespace,
-      # hash of the options and hash of the selector.
+      # hash of the options and hash of the filter.
       #
       # @example Get the hash value.
       #   view.hash
@@ -85,7 +90,7 @@ module Mongo
       #
       # @since 2.0.0
       def hash
-        [ collection.namespace, options.hash, selector.hash ].hash
+        [ collection.namespace, options.hash, filter.hash ].hash
       end
 
       # Creates a new +View+.
@@ -100,7 +105,7 @@ module Mongo
       #   View.new(collection, {:name => 'Emily'}, :read => :secondary_preferred)
       #
       # @param [ Collection ] collection The +Collection+ to query.
-      # @param [ Hash ] selector The query selector.
+      # @param [ Hash ] filter The query filter.
       # @param [ Hash ] options The additional query options.
       #
       # @option options :comment [ String ] Associate a comment with the query.
@@ -124,11 +129,10 @@ module Mongo
       #   results.
       #
       # @since 2.0.0
-      def initialize(collection, selector = {}, options = {})
-        validate_doc!(selector)
+      def initialize(collection, filter = {}, options = {})
+        validate_doc!(filter)
         @collection = collection
-        @selector = selector.dup
-        @options = options.dup
+        parse_parameters!(BSON::Document.new(filter.freeze), BSON::Document.new(options.freeze))
       end
 
       # Get a human-readable string representation of +View+.
@@ -140,8 +144,8 @@ module Mongo
       #
       # @since 2.0.0
       def inspect
-        "#<Mongo::Collection::View:0x#{object_id} namespace='#{collection.namespace}" +
-            " @selector=#{selector.inspect} @options=#{options.inspect}>"
+        "#<Mongo::Collection::View:0x#{object_id} namespace='#{collection.namespace}'" +
+            " @filter=#{filter.to_s} @options=#{options.to_s}>"
       end
 
       private
@@ -149,19 +153,18 @@ module Mongo
       def initialize_copy(other)
         @collection = other.collection
         @options = other.options.dup
-        @selector = other.selector.dup
+        @filter = other.filter.dup
       end
 
-      def initial_query_op
-        Operation::Read::Query.new(query_spec)
+      def parse_parameters!(filter, options)
+        query = filter.delete(QUERY)
+        modifiers = (filter || {}).merge(options.delete(MODIFIERS) || {})
+        @filter = query || filter
+        @options = Builder::Modifiers.map_driver_options(modifiers).merge!(options)
       end
 
       def new(options)
-        View.new(collection, selector, options)
-      end
-
-      def send_initial_query(server)
-        initial_query_op.execute(server.context)
+        View.new(collection, filter, options)
       end
 
       def view; self; end