Provided by: libmango-perl_1.25-1_all 
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>.