mongo 2.15.0 → 2.16.0.alpha1

data/lib/mongo/operation/delete/command.rb

@@ -31,13 +31,16 @@ module Mongo
         include WriteConcernSupported
         include ExecutableNoValidate
         include PolymorphicResult
+        include Validatable
 
         private
 
         def selector(connection)
-          { delete: coll_name,
-            deletes: send(IDENTIFIER),
-            ordered: ordered? }
+          {
+            delete: coll_name,
+            deletes: validate_updates(connection, send(IDENTIFIER)),
+            ordered: ordered?,
+          }
         end
 
         def message(connection)

data/lib/mongo/operation/delete/legacy.rb

@@ -28,14 +28,21 @@ module Mongo
         include Specifiable
         include Executable
         include PolymorphicResult
+        include Validatable
 
         private
 
-        def selector
-          send(IDENTIFIER).first
+        def selector(connection)
+          # This returns the first delete.
+          # The driver only puts one delete into the list normally, so this
+          # doesn't discard operations.
+          send(IDENTIFIER).first.tap do |selector|
+            validate_find_options(connection, selector)
+          end
         end
 
         def message(connection)
+          selector = selector(connection)
           opts = (selector[Operation::LIMIT] || 0) <= 0 ? {} : { :flags => [ :single_remove ] }
           Protocol::Delete.new(db_name, coll_name, selector[Operation::Q], opts)
         end

data/lib/mongo/operation/delete/op_msg.rb

@@ -29,13 +29,20 @@ module Mongo
         include ExecutableNoValidate
         include ExecutableTransactionLabel
         include PolymorphicResult
+        include Validatable
 
         private
 
         def selector(connection)
           { delete: coll_name,
             Protocol::Msg::DATABASE_IDENTIFIER => db_name,
-            ordered: ordered? }
+            ordered: ordered?,
+          }.tap do |selector|
+            if hint = spec[:hint]
+              validate_hint_on_update(connection, selector)
+              selector[:hint] = hint
+            end
+          end
         end
 
         def message(connection)

data/lib/mongo/operation/distinct/command.rb

@@ -32,6 +32,12 @@ module Mongo
 
         private
 
+        def selector(connection)
+          selector = spec[:selector]
+          selector = apply_collation(selector, connection, spec[:collation])
+          selector
+        end
+
         def message(connection)
           Protocol::Query.new(db_name, Database::COMMAND, command(connection), options(connection))
         end

data/lib/mongo/operation/distinct/op_msg.rb

@@ -27,6 +27,13 @@ module Mongo
       class OpMsg < OpMsgBase
         include CausalConsistencySupported
         include ExecutableTransactionLabel
+
+        private
+
+        def selector(connection)
+          # Collation is always supported on 3.6+ servers that would use OP_MSG.
+          spec[:selector].merge(collation: spec[:collation]).compact
+        end
       end
     end
   end

data/lib/mongo/operation/explain/command.rb

@@ -34,7 +34,19 @@ module Mongo
         private
 
         def selector(connection)
-          super.merge(spec[:explain])
+          # The mappings are BSON::Documents and as such store keys as
+          # strings, the spec here has symbol keys.
+          spec = BSON::Document.new(self.spec)
+
+          if spec[:collation] && !connection.features.collation_enabled?
+            raise Error::UnsupportedCollation
+          end
+
+          {
+            explain: {
+              find: coll_name,
+            }.update(Find::Builder::Command.selector(spec, connection)),
+          }.update(spec[:explain] || {})
         end
 
         def message(connection)

data/lib/mongo/operation/explain/legacy.rb

@@ -32,12 +32,19 @@ module Mongo
 
         private
 
-        def selector(connection)
-          super.merge(spec[:explain])
-        end
-
         def message(connection)
-          Protocol::Query.new(db_name, coll_name, command(connection), options(connection))
+          if spec[:collation] && !connection.features.collation_enabled?
+            raise Error::UnsupportedCollation
+          end
+
+          Protocol::Query.new(
+            db_name,
+            coll_name,
+            Find::Builder::Legacy.selector(spec, connection),
+            options(connection).update(
+              Find::Builder::Legacy.query_options(spec, connection),
+            ),
+          )
         end
       end
     end

data/lib/mongo/operation/explain/op_msg.rb

@@ -32,7 +32,15 @@ module Mongo
         private
 
         def selector(connection)
-          super.merge(spec[:explain])
+          # The mappings are BSON::Documents and as such store keys as
+          # strings, the spec here has symbol keys.
+          spec = BSON::Document.new(self.spec)
+          {
+            explain: {
+              find: coll_name,
+            }.update(Find::Builder::Command.selector(spec, connection)),
+            Protocol::Msg::DATABASE_IDENTIFIER => db_name,
+          }.update(spec[:explain] || {})
         end
       end
     end

data/lib/mongo/operation/find/builder/command.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+# Copyright (C) 2015-2020 MongoDB Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Mongo
+  module Operation
+    class Find
+      module Builder
+
+        # Builds a find command specification from options.
+        #
+        # @api private
+        module Command
+
+          # The mappings from ruby options to the find command.
+          OPTION_MAPPINGS = BSON::Document.new(
+            allow_disk_use: 'allowDiskUse',
+            allow_partial_results: 'allowPartialResults',
+            await_data: 'awaitData',
+            batch_size: 'batchSize',
+            collation: 'collation',
+            comment: 'comment',
+            filter: 'filter',
+            hint: 'hint',
+            limit: 'limit',
+            max_scan: 'maxScan',
+            max_time_ms: 'maxTimeMS',
+            max_value: 'max',
+            min_value: 'min',
+            no_cursor_timeout: 'noCursorTimeout',
+            oplog_replay: 'oplogReplay',
+            projection: 'projection',
+            read_concern: 'readConcern',
+            return_key: 'returnKey',
+            show_disk_loc: 'showRecordId',
+            single_batch: 'singleBatch',
+            skip: 'skip',
+            snapshot: 'snapshot',
+            sort: 'sort',
+            tailable: 'tailable',
+            tailable_cursor: 'tailable',
+          ).freeze
+
+          module_function def selector(spec, connection)
+            if spec[:collation] && !connection.features.collation_enabled?
+              raise Error::UnsupportedCollation
+            end
+
+            BSON::Document.new.tap do |selector|
+              OPTION_MAPPINGS.each do |k, server_k|
+                unless (value = spec[k]).nil?
+                  selector[server_k] = value
+                end
+              end
+
+              if rc = selector[:readConcern]
+                selector[:readConcern] = Options::Mapper.transform_values_to_strings(rc)
+              end
+
+              convert_limit_and_batch_size!(selector)
+            end
+          end
+
+          private
+
+          # Converts negative limit and batchSize parameters in the
+          # find command to positive ones. Removes the parameters if their
+          # values are zero.
+          #
+          # This is only used for find commmand, not for OP_QUERY path.
+          #
+          # The +command+ parameter is mutated by this method.
+          module_function def convert_limit_and_batch_size!(command)
+            if command[:limit] && command[:limit] < 0 &&
+              command[:batchSize] && command[:batchSize] < 0
+            then
+              command[:limit] = command[:limit].abs
+              command[:batchSize] = command[:limit].abs
+              command[:singleBatch] = true
+            else
+              [:limit, :batchSize].each do |opt|
+                if command[opt]
+                  if command[opt] < 0
+                    command[opt] = command[opt].abs
+                    command[:singleBatch] = true
+                  elsif command[opt] == 0
+                    command.delete(opt)
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongo/{collection/view → operation/find}/builder/flags.rb

@@ -16,19 +16,17 @@
 # limitations under the License.
 
 module Mongo
-  class Collection
-    class View
+  module Operation
+    class Find
       module Builder
 
-        # Provides behavior for mapping flags.
+        # Provides behavior for converting Ruby options to wire protocol flags
+        # when sending find and related commands (e.g. explain).
         #
-        # @since 2.2.0
+        # @api private
         module Flags
-          extend self
 
           # Options to cursor flags mapping.
-          #
-          # @since 2.2.0
           MAPPINGS = {
             :allow_partial_results => [ :partial ],
             :oplog_replay => [ :oplog_replay ],
@@ -36,20 +34,18 @@ module Mongo
             :tailable => [ :tailable_cursor ],
             :tailable_await => [ :await_data, :tailable_cursor],
             :await_data => [ :await_data ],
-            :exhaust => [ :exhaust ]
+            :exhaust => [ :exhaust ],
           }.freeze
 
-          # Maps an array of flags from the provided options.
+          # Converts Ruby find options to an array of flags.
           #
-          # @example Map the flags.
-          #   Flags.map_flags(options)
+          # Any keys in the input hash that are not options that map to flags
+          # are ignored.
           #
           # @param [ Hash, BSON::Document ] options The options.
           #
           # @return [ Array<Symbol> ] The flags.
-          #
-          # @since 2.2.0
-          def map_flags(options)
+          module_function def map_flags(options)
             MAPPINGS.each.reduce(options[:flags] || []) do |flags, (key, value)|
               cursor_type = options[:cursor_type]
               if options[key] || (cursor_type && cursor_type == key)

data/lib/mongo/operation/find/builder/legacy.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+# encoding: utf-8
+
+# Copyright (C) 2015-2020 MongoDB Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Mongo
+  module Operation
+    class Find
+      module Builder
+
+        # Builds a legacy OP_QUERY specification from options.
+        #
+        # @api private
+        module Legacy
+
+          # Mappings from driver options to legacy server values.
+          #
+          # @since 2.2.0
+          DRIVER_MAPPINGS = {
+            comment: '$comment',
+            explain: '$explain',
+            hint: '$hint',
+            max_scan: '$maxScan',
+            max_time_ms: '$maxTimeMS',
+            max_value: '$max',
+            min_value: '$min',
+            show_disk_loc: '$showDiskLoc',
+            snapshot: '$snapshot',
+            sort: '$orderby',
+            return_key: '$returnKey',
+          }.freeze
+
+          module_function def selector(spec, connection)
+            if Lint.enabled?
+              if spec.keys.any? { |k| String === k }
+                raise Error::LintError, "The spec must contain symbol keys only"
+              end
+            end
+
+            # Server versions that do not have the find command feature
+            # (versions older than 3.2) do not support the allow_disk_use option
+            # but perform no validation and will not raise an error if it is
+            # specified. If the allow_disk_use option is specified, raise an error
+            # to alert the user.
+            unless spec[:allow_disk_use].nil?
+              raise Error::UnsupportedOption.allow_disk_use_error
+            end
+
+            if spec[:collation] && !connection.features.collation_enabled?
+              raise Error::UnsupportedCollation
+            end
+
+            modifiers = {}
+            DRIVER_MAPPINGS.each do |k, server_k|
+              unless (value = spec[k]).nil?
+                modifiers[server_k] = value
+              end
+            end
+
+            selector = spec[:filter] || BSON::Document.new
+            # Write nil into rp if not talking to mongos, rather than false
+            rp = if connection.description.mongos?
+              read_pref_formatted(spec)
+            end
+            if modifiers.any? || rp
+              selector = {'$query' => selector}.update(modifiers)
+
+              if rp
+                selector['$readPreference'] = rp
+              end
+            end
+
+            selector
+          end
+
+          module_function def query_options(spec, connection)
+            query_options = {
+              project: spec[:projection],
+              skip: spec[:skip],
+              limit: spec[:limit],
+              # batch_size is converted to batchSize by Mongo::Protocol::Query.
+              batch_size: spec[:batch_size],
+            }
+
+            unless (flags = Builder::Flags.map_flags(spec)).empty?
+              query_options[:flags] = ((query_options[:flags] || []) + flags).uniq
+            end
+
+            query_options
+          end
+
+          private
+
+          module_function def read_pref_formatted(spec)
+            if spec[:read_preference]
+              raise ArgumentError, "Spec cannot include :read_preference here, use :read"
+            end
+
+            if read = spec[:read]
+              read_pref = ServerSelector.get(read).to_mongos
+              Mongo::Lint.validate_camel_case_read_preference(read_pref)
+              read_pref
+            else
+              nil
+            end
+          end
+        end
+      end
+    end
+  end
+end