mongo 2.0.6 → 2.1.0

data/lib/mongo/bulk_write/bulk_writable.rb

@@ -1,196 +0,0 @@
-# Copyright (C) 2014-2015 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.
-
-require 'mongo/bulk_write/insertable'
-require 'mongo/bulk_write/deletable'
-require 'mongo/bulk_write/updatable'
-require 'mongo/bulk_write/replacable'
-
-module Mongo
-  module BulkWrite
-
-    # Defines shared behaviour between ordered and unordered bulk operations.
-    #
-    # @since 2.0.0
-    module BulkWritable
-      include Insertable
-      include Deletable
-      include Updatable
-      include Replacable
-      extend Forwardable
-
-      # Delegate various methods to the collection.
-      def_delegators :@collection, :database, :cluster, :next_primary
-
-      # The fields contained in the result document returned from executing the
-      # operations.
-      #
-      # @since 2.0.0.
-      RESULT_FIELDS = [ :n_inserted,
-                        :n_removed,
-                        :n_modified,
-                        :n_upserted,
-                        :n_matched ]
-
-
-      # Initialize a bulk write object.
-      #
-      # @example Initialize a bulk write object.
-      #   Mongo::BulkWrite::OrderedBulkWrite.new(collection, operations, options)
-      #   Mongo::BulkWrite::UnorderedBulkWrite.new(collection, operations, options)
-      #
-      # @param [ Mongo::Collection ] collection The collection the operations will
-      #   be executed on.
-      # @param [ Array<Hash> ] operations The operations to be executed.
-      # @param [ Hash ] options The options.
-      #
-      # @option options [ Hash ] :write_concern The write concern to use for this
-      #   bulk write.
-      #
-      # @since 2.0.0
-      def initialize(collection, operations, options)
-        @collection = collection
-        @operations = operations
-        @options = options
-      end
-
-      # Execute the bulk operations.
-      #
-      # @example Execute the operations.
-      #   bulk.execute
-      #
-      # @return [ Hash ] The results from the bulk write.
-      #
-      # @since 2.0.0
-      def execute
-        server = next_primary
-        validate_operations!
-        merged_ops.each do |op|
-          validate_type!(op.keys.first)
-          execute_op(op, server)
-        end
-        finalize
-      end
-
-      private
-
-      def valid_doc?(doc)
-        doc.respond_to?(:keys) ||
-          doc.respond_to?(:document)
-      end
-
-      def write_concern
-        @write_concern ||= WriteConcern.get(@options[:write_concern]) ||
-                            @collection.write_concern
-      end
-
-      def validate_operations!
-        unless @operations && @operations.size > 0
-          raise ArgumentError.new('Operations cannot be empty')
-        end
-      end
-
-      def validate_type!(type)
-        unless respond_to?(type, true)
-          raise Error::InvalidBulkOperationType.new(type)
-        end
-      end
-
-      def max_write_batches(op, server)
-        type = op.keys.first
-        ops = []
-        while op[type].size > server.max_write_batch_size
-          ops << { type => op[type].shift(server.max_write_batch_size),
-                   :indexes => op[:indexes].shift(server.max_write_batch_size) }
-        end
-        ops << op
-      end
-
-      def split(op, type)
-        n = op[type].size/2
-        [ { type => op[type].shift(n),
-            :indexes => op[:indexes].shift(n) },
-          { type => op[type],
-            :indexes => op[:indexes] }
-        ]
-      end
-
-      def execute_op(operation, server)
-        ops = max_write_batches(operation, server)
-
-        until ops.empty?
-          op = ops.shift
-          type = op.keys.first
-          begin
-            process(send(type, op, server), op[:indexes])
-          rescue Error::MaxBSONSize, Error::MaxMessageSize => ex
-            raise ex if op[type].size < 2
-            ops = split(op, type) + ops
-          end
-        end
-      end
-
-      def merge_consecutive_ops(ops)
-        ops.each_with_index.inject([]) do |merged, (op, i)|
-          type = op.keys.first
-          op[:indexes] ||= [ i ]
-          previous = merged.last
-          if previous && previous.keys.first == type
-            merged[-1].merge!(type => previous[type] << op[type],
-                             :indexes => previous[:indexes] + op[:indexes])
-            merged
-          else
-            merged << { type => [ op[type] ].flatten,
-                        :indexes => op[:indexes] }
-          end
-        end
-      end
-
-      def merge_ops_by_type
-        indexes = {}
-        ops_hash = @operations.each_with_index.inject({}) do |merged, (op, i)|
-          type = op.keys.first
-          merged.merge!(op) { |type, v1, v2| ([v1] << v2).flatten }
-          indexes[type] = (indexes[type] || []).push(i)
-          merged
-        end
-        ops_hash.keys.reduce([]) do |ops_list, type|
-          ops_list << { type => ops_hash[type], :indexes => indexes[type] }
-        end
-      end
-
-      def combine_results(result, indexes)
-        @results ||= {}
-        write_errors = result.aggregate_write_errors(indexes)
-
-        # The Bulk API only returns the first write concern error encountered.
-        @write_concern_errors ||= result.aggregate_write_concern_errors(indexes)
-
-        @results.tap do |results|
-          RESULT_FIELDS.each do |field|
-            results.merge!(
-              field => (results[field] || 0) + result.send(field)
-            ) if result.respond_to?(field)
-          end
-
-          results.merge!(
-            write_errors: ((results[:write_errors] || []) << write_errors).flatten
-          ) if write_errors
-
-          results.merge!(write_concern_errors: @write_concern_errors) if @write_concern_errors
-        end
-      end
-    end
-  end
-end

data/lib/mongo/bulk_write/deletable.rb

@@ -1,56 +0,0 @@
-# Copyright (C) 2014-2015 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 BulkWrite
-
-    # Defines behavior for validating and combining delete bulk write operations.
-    #
-    # @since 2.0.0.
-    module Deletable
-
-      private
-
-      def validate_delete_op!(type, d)
-        raise Error::InvalidBulkOperation.new(type, d) unless valid_doc?(d)
-      end
-
-      def deletes(ops, type)
-        limit = (type == :delete_one) ? 1 : 0
-        ops.collect do |d|
-          validate_delete_op!(type, d)
-          { q: d, limit: limit }
-        end
-      end
-
-      def delete(ops, type, server)
-        Operation::Write::BulkDelete.new(
-          :deletes => deletes(ops, type),
-          :db_name => database.name,
-          :coll_name => @collection.name,
-          :write_concern => write_concern,
-          :ordered => ordered?
-        ).execute(server.context)
-      end
-
-      def delete_one(op, server)
-        delete(op[:delete_one], __method__, server)
-      end
-
-      def delete_many(op, server)
-        delete(op[:delete_many], __method__, server)
-      end
-    end
-  end
-end

data/lib/mongo/bulk_write/insertable.rb

@@ -1,48 +0,0 @@
-# Copyright (C) 2014-2015 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 BulkWrite
-
-    # Defines behavior for validating and combining insert bulk write operations.
-    #
-    # @since 2.0.0.
-    module Insertable
-
-      private
-
-      def validate_insert_ops!(type, inserts)
-        if inserts.empty?
-          raise Error::InvalidBulkOperation.new(type, inserts)
-        end
-        inserts.each do |i|
-          unless valid_doc?(i)
-            raise Error::InvalidBulkOperation.new(type, i)
-          end
-        end
-      end
-
-      def insert_one(op, server)
-        validate_insert_ops!(__method__, op[:insert_one])
-        Operation::Write::BulkInsert.new(
-          :documents => op[:insert_one].flatten,
-          :db_name => database.name,
-          :coll_name => @collection.name,
-          :write_concern => write_concern,
-          :ordered => ordered?
-        ).execute(server.context)
-      end
-    end
-  end
-end

data/lib/mongo/bulk_write/replacable.rb

@@ -1,57 +0,0 @@
-# Copyright (C) 2014-2015 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 BulkWrite
-
-    # Defines behavior for validating and combining replace bulk write operations.
-    #
-    # @since 2.0.0.
-    module Replacable
-
-      private
-
-      def replacement_doc?(doc)
-        doc.respond_to?(:keys) && doc.keys.all?{|key| key !~ /^\$/}
-      end
-
-      def validate_replace_op!(r, type)
-        unless r[:find] && r[:replacement] && replacement_doc?(r[:replacement])
-          raise Error::InvalidBulkOperation.new(type, r)
-        end
-      end
-
-      def replace_ops(ops, type)
-        ops.collect do |r|
-          validate_replace_op!(r, type)
-          { q: r[:find],
-            u: r[:replacement],
-            multi: false,
-            upsert: r.fetch(:upsert, false)
-          }
-        end
-      end
-
-      def replace_one(op, server)
-        Operation::Write::BulkUpdate.new(
-          :updates => replace_ops(op[:replace_one], __method__),
-          :db_name => database.name,
-          :coll_name => @collection.name,
-          :write_concern => write_concern,
-          :ordered => ordered?
-        ).execute(server.context)
-      end
-    end
-  end
-end

data/lib/mongo/bulk_write/updatable.rb

@@ -1,68 +0,0 @@
-# Copyright (C) 2014-2015 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 BulkWrite
-
-    # Defines behavior for validating and combining update bulk write operations.
-    #
-    # @since 2.0.0.
-    module Updatable
-
-      private
-
-      def update_doc?(doc)
-        !doc.empty? &&
-          doc.respond_to?(:keys) &&
-          doc.keys.first.to_s =~ /^\$/
-      end
-
-      def validate_update_op!(type, u)
-        unless u[:find] && u[:update] && update_doc?(u[:update])
-          raise Error::InvalidBulkOperation.new(type, u)
-        end
-      end
-
-      def updates(ops, type)
-        multi = type == :update_many
-        ops.collect do |u|
-          validate_update_op!(type, u)
-          { q: u[:find],
-            u: u[:update],
-            multi: multi,
-            upsert: u.fetch(:upsert, false)
-          }
-        end
-      end
-
-      def update(ops, type, server)
-        Operation::Write::BulkUpdate.new(
-          :updates => updates(ops, type),
-          :db_name => database.name,
-          :coll_name => @collection.name,
-          :write_concern => write_concern,
-          :ordered => ordered?
-        ).execute(server.context)
-      end
-
-      def update_one(op, server)
-        update(op[:update_one], __method__, server)
-      end
-
-      def update_many(op, server)
-        update(op[:update_many], __method__, server)
-      end
-    end
-  end
-end

data/lib/mongo/grid/fs.rb

@@ -1,149 +0,0 @@
-# Copyright (C) 2014-2015 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 Grid
-
-    # Represents a view of the GridFS in the database.
-    #
-    # @since 2.0.0
-    class FS
-      extend Forwardable
-
-      # The default root prefix.
-      #
-      # @since 2.0.0
-      DEFAULT_ROOT = 'fs'.freeze
-
-      # The specification for the chunks index.
-      #
-      # @since 2.0.0
-      INDEX_SPEC = { :files_id => 1, :n => 1 }.freeze
-
-      # @return [ Collection ] chunks_collection The chunks collection.
-      attr_reader :chunks_collection
-
-      # @return [ Database ] database The database.
-      attr_reader :database
-
-      # @return [ Collection ] files_collection The files collection.
-      attr_reader :files_collection
-
-      # Get write concern from database.
-      def_delegators :database, :write_concern
-
-      # Find a file in the GridFS.
-      #
-      # @example Find a file by it's id.
-      #   fs.find_one(_id: id)
-      #
-      # @example Find a file by it's filename.
-      #   fs.find_one(filename: 'test.txt')
-      #
-      # @param [ Hash ] selector The selector.
-      #
-      # @return [ Grid::File ] The file.
-      #
-      # @since 2.0.0
-      def find_one(selector = nil)
-        metadata = files_collection.find(selector).first
-        return nil unless metadata
-        chunks = chunks_collection.find(:files_id => metadata[:_id]).sort(:n => 1)
-        Grid::File.new(chunks.to_a, metadata)
-      end
-
-      # Insert a single file into the GridFS.
-      #
-      # @example Insert a single file.
-      #   fs.insert_one(file)
-      #
-      # @param [ Grid::File ] file The file to insert.
-      #
-      # @return [ Result ] The result of the insert.
-      #
-      # @since 2.0.0
-      def insert_one(file)
-        files_collection.insert_one(file.metadata)
-        inserts = file.chunks.reduce([]) do |ops, chunk|
-          ops << { :insert_one => chunk }
-        end
-        result = chunks_collection.bulk_write(inserts, ordered: true)
-        validate_md5!(file) if write_concern.get_last_error
-        file.id
-      end
-
-      # Create the GridFS.
-      #
-      # @example Create the GridFS.
-      #   Grid::FS.new(database)
-      #
-      # @param [ Database ] database The database the files reside in.
-      # @param [ Hash ] options The GridFS options.
-      #
-      # @option options [ String ] :fs_name The prefix for the files and chunks
-      #   collections.
-      #
-      # @since 2.0.0
-      def initialize(database, options = {})
-        @database = database
-        @options = options
-        @chunks_collection = database[chunks_name]
-        @files_collection = database[files_name]
-        chunks_collection.indexes.create_one(INDEX_SPEC, :unique => true)
-      end
-
-      # Get the prefix for the GridFS
-      #
-      # @example Get the prefix.
-      #   fs.prefix
-      #
-      # @return [ String ] The GridFS prefix.
-      #
-      # @since 2.0.0
-      def prefix
-        @options[:fs_name] || DEFAULT_ROOT
-      end
-
-      # Remove a single file from the GridFS.
-      #
-      # @example Remove a file from the GridFS.
-      #   fs.delete_one(file)
-      #
-      # @param [ Grid::File ] file The file to remove.
-      #
-      # @return [ Result ] The result of the remove.
-      #
-      # @since 2.0.0
-      def delete_one(file)
-        files_collection.find(:_id => file.id).delete_one
-        chunks_collection.find(:files_id => file.id).delete_many
-      end
-
-      private
-
-      def chunks_name
-        "#{prefix}.#{Grid::File::Chunk::COLLECTION}"
-      end
-
-      def files_name
-        "#{prefix}.#{Grid::File::Metadata::COLLECTION}"
-      end
-
-      def validate_md5!(file)
-        md5 = database.command(:filemd5 => file.id, :root => prefix).documents[0][:md5]
-        raise Error::InvalidFile.new(file.md5, md5) unless file.md5 == md5
-      end
-    end
-  end
-end

data/lib/mongo/operation/list_collections/result.rb

@@ -1,114 +0,0 @@
-# Copyright (C) 2014-2015 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
-    module Read
-      class ListCollections
-
-        # Defines custom behaviour of results when using the
-        # listCollections command.
-        #
-        # @since 2.0.0
-        class Result < Operation::Result
-
-          # The field name for the cursor document in a listCollections result.
-          #
-          # @since 2.0.0
-          CURSOR = 'cursor'.freeze
-
-          # The cursor id field in the cursor document.
-          #
-          # @since 2.0.0
-          CURSOR_ID = 'id'.freeze
-
-          # The namespace field in the cursor document.
-          #
-          # @since 2.0.0
-          NAMESPACE = 'ns'.freeze
-
-          # The field name for the first batch of a cursor.
-          #
-          # @since 2.0.0
-          FIRST_BATCH = 'firstBatch'.freeze
-
-          # Get the cursor id for the result.
-          #
-          # @example Get the cursor id.
-          #   result.cursor_id
-          #
-          # @note Even though the wire protocol has a cursor_id field for all
-          #   messages of type reply, it is always zero when using the
-          #   listCollections command and must be retrieved from the cursor
-          #   document itself.
-          #
-          # @return [ Integer ] The cursor id.
-          #
-          # @since 2.0.0
-          def cursor_id
-            cursor_document ? cursor_document[CURSOR_ID] : super
-          end
-
-          # Get the namespace for the cursor.
-          #
-          # @example Get the namespace.
-          #   result.namespace
-          #
-          # @return [ String ] The namespace.
-          #
-          # @since 2.0.0
-          def namespace
-            cursor_document ? cursor_document[NAMESPACE] : super
-          end
-
-          # Get the documents for the listCollections result. It is the 'firstBatch'
-          #   field in the 'cursor' field of the first document returned.
-          #
-          # @example Get the documents.
-          #   result.documents
-          #
-          # @return [ Array<BSON::Document> ] The documents.
-          #
-          # @since 2.0.0
-          def documents
-            cursor_document[FIRST_BATCH]
-          end
-
-          # Validate the result. In the case where an unauthorized client tries
-          # to run the command we need to generate the proper error.
-          #
-          # @example Validate the result.
-          #   result.validate!
-          #
-          # @return [ Result ] Self if successful.
-          #
-          # @since 2.0.0
-          def validate!
-            !successful? ? raise(Error::OperationFailure.new(parser.message)) : self
-          end
-
-          private
-
-          def cursor_document
-            @cursor_document ||= first_document[CURSOR]
-          end
-
-          def first_document
-            @first_document ||= reply.documents[0]
-          end
-        end
-      end
-    end
-  end
-end