Provided by: libmango-perl_1.30-2_all bug

NAME

       Mango::Collection - MongoDB collection

SYNOPSIS

         use Mango::Collection;

         my $collection = Mango::Collection->new(db => $db);
         my $cursor     = $collection->find({foo => 'bar'});

DESCRIPTION

       Mango::Collection is a container for MongoDB collections used by Mango::Database.

ATTRIBUTES

       Mango::Collection implements the following attributes.

   db
         my $db      = $collection->db;
         $collection = $collection->db(Mango::Database->new);

       Mango::Database object this collection belongs to.

   name
         my $name    = $collection->name;
         $collection = $collection->name('bar');

       Name of this collection.

METHODS

       Mango::Collection inherits all methods from Mojo::Base and implements the following new
       ones.

   aggregate
         my $cursor = $collection->aggregate(
           [{'$group' => {_id => undef, total => {'$sum' => '$foo'}}}]);
         my $collection = $collection->aggregate(
           [{'$match' => {'$gt' => 23}}, {'$out' => 'some_collection'}]);
         my $doc = $collection->aggregate(
           [{'$match' => {'$gt' => 23}}], {explain => bson_true});

       Aggregate collection with aggregation framework, additional options will be passed along
       to the server verbatim. You can also append a callback to perform operation non-blocking.

         my $pipeline = [{'$group' => {_id => undef, total => {'$sum' => '$foo'}}}];
         $collection->aggregate($pipeline => sub {
           my ($collection, $err, $cursor) = @_;
           ...
         });
         Mojo::IOLoop->start unless Mojo::IOLoop->is_running;

   build_index_name
         my $name = $collection->build_index_name(bson_doc(foo => 1, bar => -1));
         my $name = $collection->build_index_name({foo => 1});

       Build name for index specification, the order of keys matters for compound indexes.

   bulk
         my $bulk = $collection->bulk;

       Build Mango::Bulk object.

         my $bulk = $collection->bulk;
         $bulk->insert({foo => $_}) for 1 .. 10;
         $bulk->find({foo => 4})->update_one({'$set' => {bar => 'baz'}});
         $bulk->find({foo => 7})->remove_one;
         my $results = $bulk->execute;

   create
         $collection->create;
         $collection->create({capped => bson_true, max => 5, size => 10000});

       Create collection. You can also append a callback to perform operation non-blocking.

         $collection->create({capped => bson_true, max => 5, size => 10000} => sub {
           my ($collection, $err) = @_;
           ...
         });
         Mojo::IOLoop->start unless Mojo::IOLoop->is_running;

   drop
         $collection->drop;

       Drop collection. You can also append a callback to perform operation non-blocking.

         $collection->drop(sub {
           my ($collection, $err) = @_;
           ...
         });
         Mojo::IOLoop->start unless Mojo::IOLoop->is_running;

   drop_index
         $collection->drop_index('foo');

       Drop index. You can also append a callback to perform operation non-blocking.

         $collection->drop_index(foo => sub {
           my ($collection, $err) = @_;
           ...
         });
         Mojo::IOLoop->start unless Mojo::IOLoop->is_running;

   ensure_index
         $collection->ensure_index(bson_doc(foo => 1, bar => -1));
         $collection->ensure_index({foo => 1});
         $collection->ensure_index({foo => 1}, {unique => bson_true});

       Make sure an index exists, the order of keys matters for compound indexes, additional
       options will be passed along to the server verbatim. You can also append a callback to
       perform operation non-blocking.

         $collection->ensure_index(({foo => 1}, {unique => bson_true}) => sub {
           my ($collection, $err) = @_;
           ...
         });
         Mojo::IOLoop->start unless Mojo::IOLoop->is_running;

   find
         my $cursor = $collection->find;
         my $cursor = $collection->find({foo => 'bar'});
         my $cursor = $collection->find({foo => 'bar'}, {foo => 1});

       Build Mango::Cursor::Query object for query.

         # Exclude "_id" field from results
         my $docs = $collection->find({foo => 'bar'}, {_id => 0})->all;

   find_and_modify
         my $doc = $collection->find_and_modify(
           {query => {foo => 'bar'}, update => {'$set' => {foo => 'baz'}}});

       Fetch and update or remove a document atomically. You can also append a callback to
       perform operation non-blocking.

         my $opts = {query => {foo => 'bar'}, update => {'$set' => {foo => 'baz'}}};
         $collection->find_and_modify($opts => sub {
           my ($collection, $err, $doc) = @_;
           ...
         });
         Mojo::IOLoop->start unless Mojo::IOLoop->is_running;

       By default this method returns the unmodified version of the document. To change this
       behaviour, add the option "new => 1".

   find_one
         my $doc = $collection->find_one({foo => 'bar'});
         my $doc = $collection->find_one({foo => 'bar'}, {foo => 1});
         my $doc = $collection->find_one($oid, {foo => 1});

       Find one document. You can also append a callback to perform operation non-blocking.

         $collection->find_one({foo => 'bar'} => sub {
           my ($collection, $err, $doc) = @_;
           ...
         });
         Mojo::IOLoop->start unless Mojo::IOLoop->is_running;

   full_name
         my $name = $collection->full_name;

       Full name of this collection.

   index_information
         my $info = $collection->index_information;
         # return only the 5 first indexes
         my $info = $collection->index_information(cursor => { batchSize => 5 });

       Get index information for collection. You can also append a callback to perform operation
       non-blocking.

         $collection->index_information(sub {
           my ($collection, $err, $info) = @_;
           ...
         });
         Mojo::IOLoop->start unless Mojo::IOLoop->is_running;

   insert
         my $oid  = $collection->insert({foo => 'bar'});
         my $oids = $collection->insert([{foo => 'bar'}, {baz => 'yada'}]);

       Insert one or more documents into collection. You can also append a callback to perform
       operation non-blocking.

         $collection->insert({foo => 'bar'} => sub {
           my ($collection, $err, $oid) = @_;
           ...
         });
         Mojo::IOLoop->start unless Mojo::IOLoop->is_running;

       Note that "insert" has to ensure each document has an "_id" before sending them to
       MongoDB. To avoid modifying your data, it makes a copy of the documents. This can be a bit
       slow if you are sending big objects like pictures. To avoid that, consider using "save"
       instead.

   map_reduce
         my $collection = $collection->map_reduce($map, $reduce, {out => 'foo'});
         my $docs = $collection->map_reduce($map, $reduce, {out => {inline => 1}});
         my $docs = $collection->map_reduce(
           bson_code($map), bson_code($reduce), {out => {inline => 1}});

       Perform map/reduce operation on collection, additional options will be passed along to the
       server verbatim. You can also append a callback to perform operation non-blocking.

         $collection->map_reduce(($map, $reduce, {out => {inline => 1}}) => sub {
             my ($collection, $err, $docs) = @_;
             ...
           }
         );
         Mojo::IOLoop->start unless Mojo::IOLoop->is_running;

   options
         my $doc = $collection->options;

       Get options for collection. You can also append a callback to perform operation non-
       blocking.

         $collection->options(sub {
           my ($collection, $err, $doc) = @_;
           ...
         });
         Mojo::IOLoop->start unless Mojo::IOLoop->is_running;

   remove
         my $result = $collection->remove;
         my $result = $collection->remove($oid);
         my $result = $collection->remove({foo => 'bar'});
         my $result = $collection->remove({foo => 'bar'}, {single => 1});

       Remove documents from collection. You can also append a callback to perform operation non-
       blocking. Returns a WriteResult document.

         $collection->remove(({foo => 'bar'}, {single => 1}) => sub {
           my ($collection, $err, $doc) = @_;
           ...
         });
         Mojo::IOLoop->start unless Mojo::IOLoop->is_running;

       These options are currently available:

       single
           single => 1

         Remove only one document.

   rename
         my $new_collection = $collection->rename('NewName');

       Rename a collection, keeping all of its original contents and options. Returns a new
       Mango::Collection object pointing to the renamed collection. You can also append a
       callback to perform operation non-blocking.

         $collection->rename('NewName' => sub {
           my ($collection, $err, $oid) = @_;
           ...
         });
         Mojo::IOLoop->start unless Mojo::IOLoop->is_running;

   save
         my $oid = $collection->save({foo => 'bar'});

       Save document to collection. The document MUST have an "_id". You can also append a
       callback to perform operation non-blocking.

         $collection->save({foo => 'bar'} => sub {
           my ($collection, $err, $oid) = @_;
           ...
         });
         Mojo::IOLoop->start unless Mojo::IOLoop->is_running;

   stats
         my $stats = $collection->stats;

       Get collection statistics. You can also append a callback to perform operation non-
       blocking.

         $collection->stats(sub {
           my ($collection, $err, $stats) = @_;
           ...
         });
         Mojo::IOLoop->start unless Mojo::IOLoop->is_running;

   update
         my $result = $collection->update($oid, {foo => 'baz'});
         my $result = $collection->update({foo => 'bar'}, {foo => 'baz'});
         my $result = $collection->update({foo => 'bar'}, {foo => 'baz'}, {multi => 1});

       Update document in collection. You can also append a callback to perform operation non-
       blocking. Returns a WriteResult document.

         $collection->update(({foo => 'bar'}, {foo => 'baz'}, {multi => 1}) => sub {
           my ($collection, $err, $doc) = @_;
           ...
         });
         Mojo::IOLoop->start unless Mojo::IOLoop->is_running;

       These options are currently available:

       multi
           multi => 1

         Update more than one document.

       upsert
           upsert => 1

         Insert document if none could be updated.

SEE ALSO

       Mango, Mojolicious::Guides, <http://mojolicio.us>.