=head1 SYNOPSIS
## Creating relationships
- MyDB::Schema::Actor->has_many('actorroles' => 'MyDB::Schema::ActorRole',
+ MyApp::Schema::Actor->has_many('actorroles' => 'MyApp::Schema::ActorRole',
'actor');
- MyDB::Schema::Role->has_many('actorroles' => 'MyDB::Schema::ActorRole',
+ MyApp::Schema::Role->has_many('actorroles' => 'MyApp::Schema::ActorRole',
'role');
- MyDB::Schema::ActorRole->belongs_to('role' => 'MyDB::Schema::Role');
- MyDB::Schema::ActorRole->belongs_to('actor' => 'MyDB::Schema::Actor');
+ MyApp::Schema::ActorRole->belongs_to('role' => 'MyApp::Schema::Role');
+ MyApp::Schema::ActorRole->belongs_to('actor' => 'MyApp::Schema::Actor');
- MyDB::Schema::Role->many_to_many('actors' => 'actorroles', 'actor');
- MyDB::Schema::Actor->many_to_many('roles' => 'actorroles', 'role');
+ MyApp::Schema::Role->many_to_many('actors' => 'actorroles', 'actor');
+ MyApp::Schema::Actor->many_to_many('roles' => 'actorroles', 'role');
## Using relationships
$schema->resultset('Actor')->find({ id => 1})->roles();
All helper methods are called similar to the following template:
- __PACKAGE__->$method_name('relname', 'Foreign::Class',
- \%cond | \@cond | \&conf, \%attrs);
+ __PACKAGE__->$method_name('relname', 'Foreign::Class', \%cond|\@cond|\&cond?, \%attrs?);
Both C<cond> and C<attrs> are optional. Pass C<undef> for C<cond> if
you want to use the default value for it, but still want to set C<attrs>.
-See L<DBIx::Class::Relationship::Base/condition> for full documentation on definition of the C<cond> argument.
+See L<DBIx::Class::Relationship::Base/condition> for full documentation on
+definition of the C<cond> argument.
See L<DBIx::Class::Relationship::Base/attributes> for documentation on the
attributes that are allowed in the C<attrs> argument.
=item cond
A hashref, arrayref or coderef specifying a custom join expression. For
-documentation see L<DBIx::Class::Relationship/condition>.
+more info see L<DBIx::Class::Relationship::Base/condition>.
=back
# in a Book class (where Author has many Books)
- My::DBIC::Schema::Book->belongs_to(
- author =>
- 'My::DBIC::Schema::Author',
+ My::DBIC::Schema::Book->belongs_to(
+ author =>
+ 'My::DBIC::Schema::Author',
'author_id'
);
My::DBIC::Schema::Book->belongs_to(
author =>
'My::DBIC::Schema::Author',
- { 'foreign.author_id' => 'self.author_id' }
+ { 'foreign.author_id' => 'self.author_id' }
);
# OR (similar result but uglier accessor name)
- My::DBIC::Schema::Book->belongs_to(
+ My::DBIC::Schema::Book->belongs_to(
author_id =>
'My::DBIC::Schema::Author'
);
# in a Book class (where Author has_many Books)
__PACKAGE__->belongs_to(
- author =>
+ author =>
'My::DBIC::Schema::Author',
- 'author',
+ 'author',
{ join_type => 'left' }
);
=over 4
-=item Arguments: $accessor_name, $related_class, $their_fk_column|\%cond|\@cond\&cond?, \%attrs?
+=item Arguments: $accessor_name, $related_class, $their_fk_column|\%cond|\@cond|\&cond?, \%attrs?
=back
Creates a one-to-many relationship where the foreign class refers to
this class's primary key. This relationship refers to zero or more
-records in the foreign table (e.g. a C<LEFT JOIN>). This relationship
+records in the foreign table (e.g. a C<LEFT JOIN>). This relationship
defaults to using the end of this classes namespace as the foreign key
in C<$related_class> to resolve the join, unless C<$their_fk_column>
specifies the foreign key column in C<$related_class> or C<cond>
=item cond
A hashref, arrayref or coderef specifying a custom join expression. For
-documentation see L<DBIx::Class::Relationship/condition>.
+more info see L<DBIx::Class::Relationship::Base/condition>.
=back
# in an Author class (where Author has_many Books)
# assuming related class is storing our PK in "author_id"
My::DBIC::Schema::Author->has_many(
- books =>
- 'My::DBIC::Schema::Book',
+ books =>
+ 'My::DBIC::Schema::Book',
'author_id'
);
# OR (same result)
My::DBIC::Schema::Author->has_many(
- books =>
- 'My::DBIC::Schema::Book',
+ books =>
+ 'My::DBIC::Schema::Book',
{ 'foreign.author_id' => 'self.id' },
);
# OR (similar result, assuming related_class is storing our PK, in "author")
# (the "author" is guessed at from "Author" in the class namespace)
My::DBIC::Schema::Author->has_many(
- books =>
- 'My::DBIC::Schema::Book',
+ books =>
+ 'My::DBIC::Schema::Book',
);
# Usage
- # resultset of Books belonging to author
+ # resultset of Books belonging to author
my $booklist = $author->books;
# resultset of Books belonging to author, restricted by author name
=item cond
A hashref, arrayref or coderef specifying a custom join expression. For
-documentation see L<DBIx::Class::Relationship/condition>.
+more info see L<DBIx::Class::Relationship::Base/condition>.
=back
true value), than C<might_have> will warn about this because it's naughty and
you shouldn't do that. The warning will look something like:
- "might_have/has_one" must not be on columns with is_nullable set to true (MySchema::SomeClass/key)
+ "might_have/has_one" must not be on columns with is_nullable set to true (MySchema::SomeClass/key)
If you must be naughty, you can suppress the warning by setting
C<DBIC_DONT_VALIDATE_RELS> environment variable to a true value. Otherwise,
=item cond
A hashref, arrayref or coderef specifying a custom join expression. For
-documentation see L<DBIx::Class::Relationship/condition>.
+more info see L<DBIx::Class::Relationship::Base/condition>.
=back
# Every book has exactly one ISBN
My::DBIC::Schema::Book->has_one(
- isbn =>
+ isbn =>
'My::DBIC::Schema::ISBN',
'book_id',
);
# OR (same result, assuming related_class stores our PK)
My::DBIC::Schema::Book->has_one(
- isbn =>
+ isbn =>
'My::DBIC::Schema::ISBN',
);
# OR (same result)
My::DBIC::Schema::Book->has_one(
- isbn =>
+ isbn =>
'My::DBIC::Schema::ISBN',
{ 'foreign.book_id' => 'self.id' },
);
C<many_to_many> is not strictly a relationship in its own right. Instead, it is
a bridge between two resultsets which provide the same kind of convenience
-accessors as true relationships provide. Although the accessor will return a
-resultset or collection of objects just like has_many does, you cannot call
+accessors as true relationships provide. Although the accessor will return a
+resultset or collection of objects just like has_many does, you cannot call
C<related_resultset> and similar methods which operate on true relationships.
=over