trusty (3) MongoDBx::Class::Tutorial.3pm.gz
NAME
MongoDBx::Class::Tutorial - Tutorial for using MongoDBx::Class
VERSION
version 1.02
INTRODUCTION
MongoDBx::Class is a flexible object relational mapper (ORM) for MongoDB databases. Before reading this
tutorial, please read "DESCRIPTION" in MongoDBx::Class.
CREATING DOCUMENT CLASSES
The first step towards using MongoDBx::Class is creating document classes. Let's say your application is
called MyApp, and that it reviews novels by popular authors. Every novel has a title (its name), the full
name of its author, its release year, a synopsis, the date the novel was added to the database, a list of
tags categorizing the novel, a list of related novels, and zero or more reviews.
MongoDBx::Class provides you with a flexible foundation for building classes that represent our proposed
database schema and the relationships (or "joins") between these classes. This foundation is provided by
three modules:
• MongoDBx::Class::Moose - intended to be used by document classes in place of Moose. It provides
Moose, and all needed relationship types, in the form of Moose attributes.
• MongoDBx::Class::Document - a Moose role intended to be consumed by document classes. When documents
are expanded from the database, this role is applied to them and thus provides them some common
attributes and methods.
• MongoDBx::Class::EmbeddedDocument - a Moose role intended to be consumed by embedded document
classes. When embedded documents are found inside other documents and expanded, this role is applied
to them and thus provides them some common attributes and methods.
Before actually creating document classes, we need to design our schema. The most common question to
tackle when designing a schema is when and how to use references, and when to simply embed documents.
Refer to http://www.mongodb.org/display/DOCS/Schema+Design#SchemaDesign-Embedvs.Reference
<http://www.mongodb.org/display/DOCS/Schema+Design#SchemaDesign-Embedvs.Reference> for some information
about schema design in MongoDB.
Our database schema will be like this:
• Every novel will be represented by a document in the 'novels' collection.
• An author's name will be stored in the novel's document as an embedded document that has first and
last names, and possibly a middle name.
• The synopsis of the novel will be stored as a standalone document in the 'synopsis' collection, and
will simply reference the novel with a 'novel' attribute.
• The date and time the novel was added to the database will be stored as a W3C formatted string which
will automatically be converted to a DateTime object (see MongoDBx::Class::ParsedAttribute::DateTime
or read further for the rationale).
• The list of tags will be stored in the novel document as an array of embedded documents.
• The list of related novels will be stored in the novel document as an array of database references to
other novels.
• The reviews for every novel are stored as standalone documents in the 'reviews' collection, and will
simply reference the novel with a 'novel' attribute.
Let's look at a possible JSON representation of a novel - "The Valley of Fear" by Sir Arthur Conan Doyle:
# in the 'novels' collection
{
"_id": ObjectId("4cbca90d576fad5916790100"),
"title": "The Valley of Fear",
"year": 1914,
"author": {
"first_name": "Arthur",
"middle_name": "Conan",
"last_name": "Doyle"
},
"added": "2010-01-11T22:12:44+02:00",
"tags": [
{ "category": "mystery", "subcategory": "thriller" },
{ "category": "mystery", "subcategory": "detective" },
{ "category": "crime", "subcategory": "fiction" }
],
"related_novels": [
{ "$ref": "novels", "$id": ObjectId("4cbca90d3a41e35916720100") },
{ "$ref": "novels", "$id": ObjectId("4cbca90d44d8c959167a0100") },
{ "$ref": "novels", "$id": ObjectId("4cbca90d486bbf59166f0100") }
]
}
# in the 'synopsis' collection
{
"_id": ObjectId("4cbca90d699e9a5916670100"),
"novel": { "$ref": "novels", "$id": ObjectId("4cbca90d576fad5916790100") },
"text": "The Valley of Fear is the final Sherlock Holmes novel by Sir Arthur Conan Doyle. The story was first published in the Strand Magazine between September 1914 and May 1915. The first book edition was published in New York on 27 February 1915."
}
# in the 'reviews' collection
{
"_id": ObjectId("4cbca90dfbb2945916740100"),
"novel": { "$ref": "novels", "$id": ObjectId("4cbca90d576fad5916790100") },
"reviewer": "Some Guy",
"text": "I really liked it!",
"score": 5
},
{
"_id": ObjectId("4cbca90e0ad57b5916f50100"),
"novel": { "$ref": "novels", "$id": ObjectId("4cbca90d576fad5916790100") },
"reviewer": "Some Other Guy",
"text": "It was okay.",
"score": 3
},
{
"_id": ObjectId("4cbca90e0b9c175916c60100"),
"novel": { "$ref": "novels", "$id": ObjectId("4cbca90d576fad5916790100") },
"reviewer": "Totally Different Guy",
"text": "Man, that just sucked!",
"score": 1
}
We now need to translate this structure to MongoDBx::Class document classes. As mentioned before,
document classes are Moose classes, but instead of using Moose, they use MongoDBx::Class::Moose. We'll
start with the document class representing novels:
package MyApp::Schema::Novel;
use MongoDBx::Class::Moose;
use namespace::autoclean;
with 'MongoDBx::Class::Document';
has 'title' => (is => 'ro', isa => 'Str', required => 1, writer => 'set_title');
holds_one 'author' => (is => 'ro', isa => 'MyApp::Schema::PersonName', required => 1, writer => 'set_author');
has 'year' => (is => 'ro', isa => 'Int', predicate => 'has_year', writer => 'set_year');
has 'added' => (is => 'ro', isa => 'DateTime', traits => ['Parsed'], required => 1);
has 'review_count' => (is => 'rw', isa => 'Int', traits => ['Transient'], builder => '_build_review_count');
holds_many 'tags' => (is => 'ro', isa => 'MyApp::Schema::Tag', predicate => 'has_tags');
joins_one 'synopsis' => (is => 'ro', isa => 'Synopsis', coll => 'synopsis', ref => 'novel');
has_many 'related_novels' => (is => 'ro', isa => 'Novel', predicate => 'has_related_novels', writer => 'set_related_novels', clearer => 'clear_related_novels');
joins_many 'reviews' => (is => 'ro', isa => 'Review', coll => 'reviews', ref => 'novel');
sub _build_review_count { shift->reviews->count }
sub print_related_novels {
my $self = shift;
foreach my $other_novel ($self->related_novels) {
print $other_novel->title, ', ',
$other_novel->year, ', ',
$other_novel->author->name, "\n";
}
}
around 'reviews' => sub {
my ($orig, $self) = (shift, shift);
my $cursor = $self->$orig;
return $cursor->sort([ year => -1, title => 1, 'author.last_name' => 1 ]);
};
__PACKAGE__->meta->make_immutable;
Aside from standard Moose usage, we've used some of MongoDBx::Class' built-in relationship types. Head
over to MongoDBx::Class::Moose for a list of provided relationship types and how they translate to
database entries.
In this example, we've used the "holds_one" relationship to denote that a Novel document entirely holds
one embedded PersonName sub-document. We've used "holds_many" to have Novel documents entirely hold Tag
documents. We've also used "joins_one" to easily find a novel's synopsis, located in the synopsis
collection. "joins_many" was used to easily find all Review documents located in the reviews collection.
Finally, we've used "has_many" for the list of references to related novels.
You will notice that when using the "holds_one" and "holds_many" relationship types, we've given the full
package names to the "isa" option (such as MyApp::Schema::PersonName), while in other relationship types,
we've given the class names only (such as 'Synopsis'). This inconsistency is only temporary, and will
change in future versions, so keep your finger on the pulse.
Of particular interest is the 'added' attribute, for which we've added the
<Parsed|MongoDBx::Class::AttributeTraits::Parsed> attribute trait (automatically provided with
MongoDBx::Class). When adding this trait to an attribute, MongoDBx::Class looks for a module implementing
the MongoDBx::Class::ParsedAttribute role named like the 'isa' option of the attribute. In our example,
MongoDBx::Class will look for MongoDBx::Class::ParsedAttribute::DateTime. However, if you're creating
your own ParsedAttribute classes, you need to also pass the 'parser' option. For example:
has 'added' => (is => 'ro', isa => 'DateTime', traits => ['Parsed'], parser => 'MyApp::ParsedAttribute::MyCoolDateTimeParser', required => 1);
The 'Parsed' trait means that the parser is responsible for expanding this attribute from the database
when loading a document, and for collapsing the attribute when saving to the database. This is similar to
DBIx::Class' InflateColumn family of classes from the SQL world. You might ask yourself why we're using a
special DateTime parser here, even though MongoDB natively supports DateTime objects. The following
paragraph is taken from MongoDBx::Class::ParsedAttribute::DateTime's documentation):
While the Perl L<MongoDB> driver already supports L<DateTime> objects
natively, due to a bug with MongoDB, you can't save dates earlier than
the UNIX epoch. This module overcomes this limitation by simply saving
dates as strings and automatically turning them into DateTime objects
(and vica-versa). The DateTime strings are formatted by the L<DateTime::Format::W3CDTF>
module, which parses dates in the format recommended by the W3C. This is
good for web apps, and also makes it easier to edit dates from the
MongoDB shell. But most importantly, it also allows sorting by date.
Also note the 'review_count' attribute, which has the 'Transient' trait. This trait means the attribute
is not to be saved in the database, even though it is one of the document's attributes. This is useful
for calculated attributes, or any supporting attributes you add to a document class whose state should
not be saved. You should note that if for some reason a document in the database does have an attribute
marked as transient in the document's class (for example if you added it to the document manually), the
value of this attribute will also be ignored when the document is read from the database.
As you can see, the "joins_many" relationship creates a one-to-many relationship between one document to
one or more other documents which can be considered "child documents". In this example, there is a one-
to-many relationship between a 'novel' document and one or more 'review' documents. A "joins_many"
relationship is implemented with a cursor. For example, calling the "reviews()" method on a "Novel"
object will generally return a MongoDBx::Class::Cursor object for a "find()" query that searches for
documents in the 'reviews' collection, whose 'novel' attribute references the "Novel" document. In the
"Novel" class above, you will notice the "reviews()" method is also modified with Moose's "around" method
modifier. This example illustrates the fact that "joins_many" is implemented with a cursor. Suppose you
know you will always want to call "reviews()" and get the child documents sorted by date (or other
fields). The above modification simply sorts the cursor before returning it to the caller. Of course,
this is merely an example of the things you can do with the "joins_many" relationship.
Continuing on, lets create our two embedded document classes. We'll start with PersonName:
package MyApp::Schema::PersonName;
use MongoDBx::Class::Moose;
use namespace::autoclean;
with 'MongoDBx::Class::EmbeddedDocument';
has 'first_name' => (is => 'ro', isa => 'Str', required => 1, writer => 'set_first_name');
has 'middle_name' => (is => 'ro', isa => 'Str', predicate => 'has_middle_name', writer => 'set_middle_name');
has 'last_name' => (is => 'ro', isa => 'Str', required => 1, writer => 'set_last_name');
sub name {
my $self = shift;
my $name = $self->first_name;
$name .= ' '.$self->middle_name if $self->has_middle_name;
$name .= ' '.$self->last_name;
return $name;
}
__PACKAGE__->meta->make_immutable;
This is a very simple class, with no relationships. We use the "name()" method to easily print a person's
full name.
On to the Tag document class:
package MyApp::Schema::Tag;
use MongoDBx::Class::Moose;
use namespace::autoclean;
with 'MongoDBx::Class::EmbeddedDocument';
has 'category' => (is => 'ro', isa => 'Str', required => 1);
has 'subcategory' => (is => 'ro', isa => 'Str', required => 1);
__PACKAGE__->meta->make_immutable;
Again, this is a very simple example. Embedded documents will often be as simple as that.
We have two document classes left. The first is the Synopsis class:
package MyApp::Schema::Synopsis;
use MongoDBx::Class::Moose;
use namespace::autoclean;
with 'MongoDBx::Class::Document';
belongs_to 'novel' => (is => 'ro', isa => 'Novel', required => 1);
has 'text' => (is => 'ro', isa => 'Str', writer => 'set_text', required => 1);
__PACKAGE__->meta->make_immutable;
Here, we've used "belongs_to" to signify a Synopsis document belongs to a Novel document. Every Synopsis
document has a 'novel' attribute which references the parent Novel document.
Only the Review class is left:
package MyApp::Schema::Review;
use MongoDBx::Class::Moose;
use namespace::autoclean;
with 'MongoDBx::Class::Document';
belongs_to 'novel' => (is => 'ro', isa => 'Novel', required => 1);
has 'reviewer' => (is => 'ro', isa => 'Str', required => 1);
has 'text' => (is => 'ro', isa => 'Str', required => 1);
has 'score' => (is => 'ro', isa => 'Int', predicate => 'has_score');
__PACKAGE__->meta->make_immutable;
That wraps up our document classes. Before we continue, it is important to note that MongoDBx::Class'
ability to identify the class of a document is currently reliant on the existance of a '_class' attribute
in every document in the database (as described in "CAVEATS AND THINGS TO CONSIDER" in MongoDBx::Class).
So, looking at the JSON representations from before, we need to modify the representations like so:
# in the 'novels' collection
{
"_id": ObjectId("4cbca90d576fad5916790100"),
"_class": "Novel",
"title": "The Valley of Fear",
"year": 1914,
"author": {
"first_name": "Arthur",
"middle_name": "Conan",
"last_name": "Doyle"
},
"added": "2010-01-11T22:12:44+02:00",
"tags": [
{ "category": "mystery", "subcategory": "thriller" },
{ "category": "mystery", "subcategory": "detective" },
{ "category": "crime", "subcategory": "fiction" }
],
"related_novels": [
{ "$ref": "novels", "$id": ObjectId("4cbca90d3a41e35916720100") },
{ "$ref": "novels", "$id": ObjectId("4cbca90d44d8c959167a0100") },
{ "$ref": "novels", "$id": ObjectId("4cbca90d486bbf59166f0100") }
]
}
# in the 'synopsis' collection
{
"_id": ObjectId("4cbca90d699e9a5916670100"),
"_class": "Synopsis",
"novel": { "$ref": "novels", "$id": ObjectId("4cbca90d576fad5916790100") },
"text": "The Valley of Fear is the final Sherlock Holmes novel by Sir Arthur Conan Doyle. The story was first published in the Strand Magazine between September 1914 and May 1915. The first book edition was published in New York on 27 February 1915."
}
# in the 'reviews' collection
{
"_id": ObjectId("4cbca90dfbb2945916740100"),
"_class": "Review",
"novel": { "$ref": "novels", "$id": ObjectId("4cbca90d576fad5916790100") },
"reviewer": "Some Guy",
"text": "I really liked it!",
"score": 5
},
{
"_id": ObjectId("4cbca90e0ad57b5916f50100"),
"_class": "Review",
"novel": { "$ref": "novels", "$id": ObjectId("4cbca90d576fad5916790100") },
"reviewer": "Some Other Guy",
"text": "It was okay.",
"score": 3
},
{
"_id": ObjectId("4cbca90e0b9c175916c60100"),
"_class": "Review",
"novel": { "$ref": "novels", "$id": ObjectId("4cbca90d576fad5916790100") },
"reviewer": "Totally Different Guy",
"text": "Man, that just sucked!",
"score": 1
}
You will notice that it is not required to add the '_class' attribute to embedded documents, only to
standalone documents. The reason for the '_class' requirement is the fact that MongoDBx::Class doesn't
enforce one collection for every document class. Every collection can have documents of one or more
classes, and documents of the same class can be stored in one or more collections, even databases.
LOADING MongoDBx::Class AND CONNECTING TO A MongoDB SERVER
The next step is loading the schema we've just created, and connecting to a MongoDB server:
my $dbx = MongoDBx::Class->new(namespace => 'MyApp::Schema');
We need to pass the namespace of our schema to MongoDBx::Class. It will attempt to automatically load
every document class under that namespace, and will return a MongoDBx::Class object back.
We then initiate a connection to a server:
my $conn = $dbx->connect();
We don't pass anything to the "connect()" method, so it attempts to connect to a MongoDB server running
on 'localhost', on the default 27017 port. We can connect to a specific server like so:
my $conn = $dbx->connect(host => $host, port => $port);
The connect method accepts any of the options that the "new()" method in MongoDB::Connection accepts,
plus the new 'safe' boolean attribute. Passing a true value for this attribute causes MongoDBx::Class to
automatically enable the 'pass' option to all insert/update/delete operations performed on the database,
so we don't need to pass "{ safe => 1 }" to the "insert()", "update()" methods, etc. The safe option is
actually required in order to autoamtically expand/collapse documents, so you'd probably want to enable
it, but it is kept disabled by default for compatibility with the original MongoDB module.
The "connect()" method returns a MongoDBx::Class::Connection object.
NOTE: versions prior to 0.7 stored the returned connection object as the 'conn' attribute of the $dbx
variable. This behavior has been dropped in version 0.7 in order to be consistent with MongoDB and
allowing multiple connections.
Now that we have our connection object, we can get a database object:
$conn->get_database('whatever'); # also simply $conn->whatever
INSERTING DOCUMENTS
Now the we've loaded our schema and connected to a server, we can start using MongoDBx::Class. Basically,
our usage will not differ greatly from direct MongoDB usage, as MonogDBx::Class simply extends MongoDB.
The biggest difference between directly using MongoDB and using MongoDBx::Class, is the automatic
expanding and collapsing of documents. Documents are automatically expanded when inserting documents only
if the "safe" option is on, as mentioned in the previous section.
Let's create a novel document:
my $db = $conn->get_database('myapp');
my $novels_coll = $db->get_collection('novels');
my $novel = $novels_coll->insert({
_class => 'Novel',
title => 'The Valley of Fear',
year => 1914,
author => {
first_name => 'Arthur',
middle_name => 'Conan',
last_name => 'Doyle',
},
added => DateTime->now(time_zone => 'Asia/Jerusalem'),
tags => [
{ category => 'mystery', subcategory => 'thriller' },
{ category => 'mystery', subcategory => 'detective' },
{ category => 'crime', subcategory => 'fiction' },
],
});
Notice that when inserting the novel document, we've directly inserted the PersonName embedded document
and the Tags embedded documents as hash-refs.
This insert, which was safe (since the 'safe' attribute of our connection object had a true value),
returns the novel document after expansion:
$novel->author->name; # prints 'Arthur Conan Doyle'
If the insert was unsafe, we'd just get the MongoDB::OID of the document back. But note that you can't
get the OID object and immediately attempt to load the document with it, as you can't predict the order
in which MongoDB will perform asynchronous operations.
Lets insert our synopsis now:
my $synopsis = $db->synopsis->insert({
_class => 'Synopsis',
novel => $novel,
text => "The Valley of Fear is the final Sherlock Holmes novel by Sir Arthur Conan Doyle. The story was first published in the Strand Magazine between September 1914 and May 1915. The first book edition was published in New York on 27 February 1915.",
});
Notice how we've passed the $novel object directly as the 'novel' attribute. When inserting,
MongoDBx::Class will automatically save it as a DBRef object for us.
Now for our reviews:
my @reviews = $conn->get_collection('reviews')->batch_insert([
{
_class => 'Review',
novel => $novel,
reviewer => 'Some Guy',
text => 'I really liked it!',
score => 5,
},
{
_class => 'Review',
novel => $novel,
reviewer => 'Some Other Guy',
text => 'It was okay.',
score => 3,
},
{
_class => 'Review',
novel => $novel,
reviewer => 'Totally Different Guy',
text => 'Man, that just sucked!',
score => 1,
}
]);
my ($total_score, $avg_score) = (0, 0);
foreach (@reviews) {
$total_score += $_->score || 0;
}
$avg_score = $total_score / scalar(@reviews);
print $avg_score; # prints 3
If we now run "$novel->reviews()", we'd get a MongoDBx::Class::Cursor back. And since we've created a
method modification in the Novel class on this method, this cursor will also be sorted.
foreach ($novel->reviews) {
# $_ is now a MyApp::Schema::Review object
print $_->score;
}
SEARCHING DOCUMENTS
MongoDBx::Class adds automatic expansion to document searching, plus some convenient shortcuts. Say we've
received the ID of a novel document as input, and we want to load it. With MongoDB, we'd probably do:
$db->novels->find_one({ _id => MongoDB::OID->new(value => $oid) })
With MongoDBx::Class, we can just do:
$db->novels->find_one($oid);
And $oid can either be the string ID, or a MongoDB::OID object.
If the document is found, and has the '_class' attribute, then it will be automatically expanded.
my $novel = $db->novels->find_one($oid)
|| die "Oh my god I can't find this, kill me, kill me now";
print $novel->author->name; # again, prints 'Arthur Conan Doyle'
Let's search for reviews written by a certain reviewer:
my $cursor = $db->reviews->find({ reviewer => 'Some Guy' })->sort({ score => -1 }); # the `find` method also has two synonyms: `query` and `search`
This gives a MongoDBx::Class::Cursor back:
print $cursor->count; # prints 1
while (my $review = $cursor->next) {
print $review->novel->title, "\n";
}
Sorting documents is easier. We can sort by a list of ordered attributes like so:
$cursor->sort([ attr1 => 1, attr2 => 1, attr3 => -1 ]);
UPDATING DOCUMENTS
Updating documents is much easier with MongoDBx::Class. There are two ways to update documents in
MongoDBx::Class:
• The older, MongoDB way of using the "update()" method in MongoDBx::Class::Collection. This is now
mostly used to update multiple documents at once.
• The new, MongoDBx::Class way of using the "update()" method provided to document classes by
MongoDBx::Class::Document. This is used to update a specific document.
Let's take a look at the first way. Suppose we want to cheat and update all reviews for "The Valley of
Fear" with a score of five:
$db->reviews->update({ 'novel.$id' => $novel->_id }, { '$set' => { score => 5 } }, { multiple => 1 }); # updates are by default singular, so we add the 'multiple' option
This is exactly like using MongoDB::Collection directly. If we're updating a specific document we've
already loaded, however, MongoDBx::Class provides a much more comfortable way. Instead of doing:
$db->novels->update({ _id => $novel->_id }, { ... })
We can do:
$novel->update({ year => 1915 });
This will effectively invoke a '$set' update like this:
$db->novels->update({ _id => $novel->_id }, { '$set' => { year => 1915 } });
But this isn't really the Moose way of doing things, so MongoDBx::Class gives us yet another way of
updating a document:
$novel->set_year(1915); # we can do this because we've added a 'writer' option to the 'year' attribute
$novel->update;
When invoking "update()" on a document object with no arguments, a "snapshot" of the document is taken,
and the following update is effectively performed:
$db->novels->update({ _id => $novel->_id }, { title => "The Valley of Fear", year => 1915, ... });
When we pass arguments to the "update()" method (there are two arguments we can pass, the hash-ref of
updates to perform, and the standard options hash-ref we know from the original "update()" method in
MongoDB::Collection), MongoDBx::Class simply performs a '$set' update on the passed hash-ref attributes
only. So doing this:
$novel->set_year(1915);
$novel->update({ title => 'The Valley of Fearrrrrr' });
Will only result in the 'title' attribute being updated, not the year attribute.
Updating embedded documents is similarly easy:
$novel->author->set_first_name('Sir Arthur');
$novel->update;
REMOVING DOCUMENTS
Removing documents with MongoDBx::Class is very easy. Having the document object, simply call:
$novel->remove;
Or:
$novel->delete;
And this novel document will be removed from the database. Note, however, that the delete operation does
not cascade, so only the novel document is deleted. The synopsis and reviews are not deleted, and you
have to do so manually.
You can still use the original "remove()" method on collections, now mostly to remove multiple documents:
$db->get_collection('reviews')->remove({ 'novel.$id' => $novel->_id }); # removes are by default multiple
FAQ
Can I use more than one database?
Yes, you can use as many databases as you like and use the same document classes across them:
my $data_db = $conn->get_database('myapp_data');
my $user_db = $conn->get_database('myapp_users');
Can I define different document classes to different databases?
There currently isn't a way to define individual schemas for different databases. You can, however,
"split" your schema. For example, if your application has a data DB and a user DB, you can put all the
document classes of the data DB under MyApp::Schema::Data, and all the document classes of the user DB
under MyApp::Schema::User.
What if I want to use the asynchronous AnyMongo driver instead?
Currently, MongoDBx::Class only supports the official MongoDB driver, but support for AnyMongo is
planned.
What if I have attributes I don't want to save in the database?
MongoDBx::Class does not provide an option like that yet, but will probably do so in upcoming versions.
I'm not getting document objects but just the document hash-refs, what gives?
If, either when searching for documents or creating/updating documents, you are not receiving expanded
document objects back but only the document hash-refs when searching/updating, or the documents'
MongoDB::OIDs when inserting, there might be a few reasons for this:
1. You are not using safe operations: MongoDBx::Class cannot expand documents when not using safe
operations. Either enable the 'safe' option when inserting/updating, or enable the safe option globally
when connecting using MongoDBx::Class's "connect()" method.
2. The document hash-ref does not define the '_class' attribute: MongoDBx::Class cannot expand document
without knowing to which document class the document belongs. Therefore, documents in the MongoDB
database must have the '_class' attribute.
3. The '_class' attribute is wrong or does not exist: If the document has the '_class' attribute and
you're still not getting document objects back, then MongoDBx::Class probably can't find the document
class. This might be because the class name is wrong, or the class was not found when loading
MongoDBx::Class. If that is the case, you might wanna take a look at the "search_dirs" attribute of
MongoDBx::Class.
Who framed Roger Rabbit?
I framed Roger Rabbit!
WRAP UP
You now know how you can use MongoDBx::Class in your applications, and make MongoDB act like a relational
database, without sacrificing its NoSQL nature and special features.
Before using MongoDBx::Class, please take into account that its alpha software, and is not ready yet for
production use. If you find bugs, please report them in the usual channels (see "BUGS" in
MongoDBx::Class).
AUTHOR
Ido Perlmuter, "<ido at ido50.net>"
SUPPORT
You can find documentation for this module with the perldoc command.
perldoc MongoDBx::Class::Tutorial
SEE ALSO
MongoDBx::Class, MongoDB, <http://www.mongodb.org/>.
LICENSE AND COPYRIGHT
Copyright 2010-2012 Ido Perlmuter.
This program is free software; you can redistribute it and/or modify it under the terms of either: the
GNU General Public License as published by the Free Software Foundation; or the Artistic License.
See http://dev.perl.org/licenses/ for more information.