Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
Mango::Collection(3)  User Contributed Perl Documentation Mango::Collection(3)

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>.

perl v5.32.0			  2018-03-17		  Mango::Collection(3)

NAME | SYNOPSIS | DESCRIPTION | ATTRIBUTES | METHODS | SEE ALSO

Want to link to this manual page? Use this URL:
<https://www.freebsd.org/cgi/man.cgi?query=Mango::Collection&sektion=3&manpath=FreeBSD+12.2-RELEASE+and+Ports>

home | help