X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FDBIx%2FClass%2FRelationship.pm;h=c6720e9a609361b1455d553aea25d25c0ce25763;hb=a918d9014c5fc4684efb8b6c2abb84cf60d9c826;hp=4b9d64ffed1fda7fa255b8a42bcc9785d00350fe;hpb=22b15c96c84ddc1aeddddac637ca4c59a6465dcf;p=dbsrgits%2FDBIx-Class.git diff --git a/lib/DBIx/Class/Relationship.pm b/lib/DBIx/Class/Relationship.pm index 4b9d64f..c6720e9 100644 --- a/lib/DBIx/Class/Relationship.pm +++ b/lib/DBIx/Class/Relationship.pm @@ -3,34 +3,235 @@ package DBIx::Class::Relationship; use strict; use warnings; -use base qw/DBIx::Class Class::Data::Inheritable/; +use base qw/DBIx::Class/; -__PACKAGE__->load_own_components(qw/Accessor CascadeActions ProxyMethods Base HasOne/); +__PACKAGE__->load_own_components(qw/ + Helpers + Accessor + CascadeActions + ProxyMethods + Base +/); -__PACKAGE__->mk_classdata('_relationships', { } ); - -=head1 NAME +=head1 NAME DBIx::Class::Relationship - Inter-table relationships =head1 SYNOPSIS + MyDB::Schema::Actor->has_many('actorroles' => 'MyDB::Schema::ActorRole', + 'actor'); + MyDB::Schema::Role->has_many('actorroles' => 'MyDB::Schema::ActorRole', + 'role'); + MyDB::Schema::ActorRole->belongs_to('role' => 'MyDB::Schema::Role'); + MyDB::Schema::ActorRole->belongs_to('actor' => 'MyDB::Schema::Actor'); + + MyDB::Schema::Role->many_to_many('actors' => 'actorroles', 'actor'); + MyDB::Schema::Actor->many_to_many('roles' => 'actorroles', 'role'); + + $schema->resultset('Actor')->roles(); + $schema->resultset('Role')->search_related('actors', { Name => 'Fred' }); + $schema->resultset('ActorRole')->add_to_roles({ Name => 'Sherlock Holmes'}); + +See L for more. + =head1 DESCRIPTION -This class handles relationships between the tables in your database -model. It allows your to set up relationships, and to perform joins -on searches. +This class provides methods to set up relationships between the tables +in your database model. Relationships are the most useful and powerful +technique that L provides. To create efficient database queries, +create relationships between any and all tables that have something in +common, for example if you have a table Authors: + + ID | Name | Age + ------------------ + 1 | Fred | 30 + 2 | Joe | 32 + +and a table Books: + + ID | Author | Name + -------------------- + 1 | 1 | Rulers of the universe + 2 | 1 | Rulers of the galaxy + +Then without relationships, the method of getting all books by Fred goes like +this: + + my $fred = $schema->resultset('Author')->find({ Name => 'Fred' }); + my $fredsbooks = $schema->resultset('Book')->search({ Author => $fred->ID }); +With a has_many relationship called "books" on Author (see below for details), +we can do this instead: + + my $fredsbooks = $schema->resultset('Author')->find({ Name => 'Fred' })->books; + +Each relationship sets up an accessor method on the +L objects that represent the items +of your table. From L objects, +the relationships can be searched using the "search_related" method. +In list context, each returns a list of Row objects for the related class, +in scalar context, a new ResultSet representing the joined tables is +returned. Thus, the calls can be chained to produce complex queries. +Since the database is not actually queried until you attempt to retrieve +the data for an actual item, no time is wasted producing them. + + my $cheapfredbooks = $schema->resultset('Author')->find({ + Name => 'Fred', + })->books->search_related('prices', { + Price => { '<=' => '5.00' }, + }); + +will produce a query something like: + + SELECT * FROM Author me + LEFT JOIN Books books ON books.author = me.id + LEFT JOIN Prices prices ON prices.book = books.id + WHERE prices.Price <= 5.00 + +all without needing multiple fetches. + +Only the helper methods for setting up standard relationship types +are documented here. For the basic, lower-level methods, and a description +of all the useful *_related methods that you get for free, see +L. =head1 METHODS +All helper methods take the following arguments: + + __PACKAGE__>$method_name('relname', 'Foreign::Class', $cond, $attrs); + +Both C<$cond> and C<$attrs> are optional. Pass C for C<$cond> if +you want to use the default value for it, but still want to set C<$attrs>. +See L for a list of valid attributes. + +=head2 belongs_to + + # in a Book class (where Author has many Books) + My::DBIC::Schema::Book->belongs_to(author => 'My::DBIC::Schema::Author'); + my $author_obj = $obj->author; + $obj->author($new_author_obj); + +Creates a relationship where the calling class stores the foreign class's +primary key in one (or more) of its columns. If C<$cond> is a column name +instead of a join condition hash, that is used as the name of the column +holding the foreign key. If C<$cond> is not given, the relname is used as +the column name. + +If the relationship is optional - i.e. the column containing the foreign +key can be NULL - then the belongs_to relationship does the right +thing - so in the example above C<$obj-Eauthor> would return C. +However in this case you would probably want to set the C +attribute so that a C is done, which makes complex +resultsets involving C or C operations work correctly. +The modified declaration is shown below: + + # in a Book class (where Author has_many Books) + __PACKAGE__->belongs_to(author => 'My::DBIC::Schema::Author', + 'author', {join_type => 'left'}); + + +Cascading deletes are off by default on a C +relationship. To turn them on, pass C<< cascade_delete => 1 >> +in the $attr hashref. + +NOTE: If you are used to L relationships, this is the equivalent +of C. + +=head2 has_many + + # in an Author class (where Author has_many Books) + My::DBIC::Schema::Author->has_many(books => 'My::DBIC::Schema::Book', 'author'); + my $booklist = $obj->books; + my $booklist = $obj->books({ + name => { LIKE => '%macaroni%' }, + { prefetch => [qw/book/], + }); + my @book_objs = $obj->books; + my $books_rs = $obj->books; + ( $books_rs ) = $obj->books_rs; + + $obj->add_to_books(\%col_data); + +Creates a one-to-many relationship, where the corresponding elements of the +foreign class store the calling class's primary key in one (or more) of its +columns. You should pass the name of the column in the foreign class as the +C<$cond> argument, or specify a complete join condition. + +Three methods are created when you create a has_many relationship. The first +method is the expected accessor method. The second is almost exactly the same +as the accessor method but "_rs" is added to the end of the method name. This +method works just like the normal accessor, except that it returns a resultset +no matter what, even in list context. The third method, named +C<< add_to_ >>, will also be added to your Row items; this allows +you to insert new related items, using the same mechanism as in +L. + +If you delete an object in a class with a C relationship, all +the related objects will be deleted as well. To turn this behaviour off, +pass C<< cascade_delete => 0 >> in the C<$attr> hashref. However, any +database-level cascade or restrict will take precedence over a +DBIx-Class-based cascading delete. + +=head2 might_have + + My::DBIC::Schema::Author->might_have(pseudonym => + 'My::DBIC::Schema::Pseudonyms'); + my $pname = $obj->pseudonym; # to get the Pseudonym object + +Creates an optional one-to-one relationship with a class, where the foreign +class stores our primary key in one of its columns. Defaults to the primary +key of the foreign class unless C<$cond> specifies a column or join condition. + +If you update or delete an object in a class with a C +relationship, the related object will be updated or deleted as well. To +turn off this behavior, add C<< cascade_delete => 0 >> to the C<$attr> +hashref. Any database-level update or delete constraints will override +this behavior. + +=head2 has_one + + My::DBIC::Schema::Book->has_one(isbn => 'My::DBIC::Schema::ISBN'); + my $isbn_obj = $obj->isbn; + +Creates a one-to-one relationship with another class. This is just like +C, except the implication is that the other object is always +present. The only difference between C and C is that +C uses an (ordinary) inner join, whereas C uses a +left join. + + +=head2 many_to_many + =over 4 +=item Arguments: $accessor_name, $link_rel_name, $foreign_rel_name + +=back + + My::DBIC::Schema::Actor->has_many( actor_roles => + 'My::DBIC::Schema::ActorRoles', + 'actor' ); + My::DBIC::Schema::ActorRoles->belongs_to( role => + 'My::DBIC::Schema::Role' ); + My::DBIC::Schema::ActorRoles->belongs_to( actor => + 'My::DBIC::Schema::Actor' ); + + My::DBIC::Schema::Actor->many_to_many( roles => 'actor_roles', + 'role' ); + +Creates accessors bridging two relationships; not strictly a relationship in +its own right, although the accessor will return a resultset or collection of +objects just as a has_many would. + +To use many_to_many, existing relationships from the original table to the link +table, and from the link table to the end table must already exist, these +relation names are then used in the many_to_many call. + =cut 1; -=back - =head1 AUTHORS Matt S. Trout