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 $docs = $collection->aggregate(
    [{'$group' => {_id => undef, total => {'$sum' => '$foo'}}}]);

Aggregate collection with aggregation framework. 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, $docs) = @_;
    ...
  });
  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.

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'});

Get Mango::Cursor object for query.

find_and_modify

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

Update document atomically. You can also append a callback to perform operation non-blocking.

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

find_one

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

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;

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;

map_reduce

  my $foo  = $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 this 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;

remove

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

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

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

These options are currently available:

single: Remove only one document.

save

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

Save document to collection. 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 $num = $collection->update({foo => 'bar'}, {foo => 'baz'});
  my $num = $collection->update({foo => 'bar'}, {foo => 'baz'}, {multi => 1});

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

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