GSP
Quick Navigator

Search Site

Unix VPS
A - Starter
B - Basic
C - Preferred
D - Commercial
MPS - Dedicated
Previous VPSs
* Sign Up! *

Support
Contact Us
Online Help
Handbooks
Domain Status
Man Pages

FAQ
Virtual Servers
Pricing
Billing
Technical

Network
Facilities
Connectivity
Topology Map

Miscellaneous
Server Agreement
Year 2038
Credits
 

USA Flag

 

 

Man Pages


Manual Reference Pages  -  MANGO::COLLECTION (3)

.ds Aq ’

NAME

Mango::Collection - MongoDB collection

CONTENTS

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>.
Search for    or go to Top of page |  Section 3 |  Main Index


perl v5.20.3 MANGO::COLLECTION (3) 2016-01-01

Powered by GSP Visit the GSP FreeBSD Man Page Interface.
Output converted with manServer 1.07.