X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FDBIx%2FClass%2FRelationship.pm;h=b95867f01077542e150dcaf14d0526f15fe43850;hb=7d9fbacf13c288615dc718bbb76deb9fa28d8aa9;hp=c479e4c707021fae6dbc5b37011a6ea2e94fc4ed;hpb=d2113a6853f7ae702b922d936f5ac4d323c7da65;p=dbsrgits%2FDBIx-Class.git diff --git a/lib/DBIx/Class/Relationship.pm b/lib/DBIx/Class/Relationship.pm index c479e4c..b95867f 100644 --- a/lib/DBIx/Class/Relationship.pm +++ b/lib/DBIx/Class/Relationship.pm @@ -13,15 +13,15 @@ __PACKAGE__->load_own_components(qw/ Base /); -=head1 NAME +=head1 NAME DBIx::Class::Relationship - Inter-table relationships =head1 SYNOPSIS - MyDB::Schema::Actor->has_many('actorroles' => 'MyDB::Schema::ActorRole', + MyDB::Schema::Actor->has_many('actorroles' => 'MyDB::Schema::ActorRole', 'actor'); - MyDB::Schema::Role->has_many('actorroles' => 'MyDB::Schema::ActorRole', + 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'); @@ -31,7 +31,7 @@ DBIx::Class::Relationship - Inter-table relationships $schema->resultset('Actor')->roles(); $schema->resultset('Role')->search_related('actors', { Name => 'Fred' }); - $schema->resultset('ActorRole')->add_to_role({ Name => 'Sherlock Holmes'}); + $schema->resultset('ActorRole')->add_to_roles({ Name => 'Sherlock Holmes'}); See L for more. @@ -65,10 +65,10 @@ we can do this instead: my $fredsbooks = $schema->resultset('Author')->find({ Name => 'Fred' })->books; -Each relationship sets up an accessor method on the +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. +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. @@ -83,7 +83,7 @@ the data for an actual item, no time is wasted producing them. will produce a query something like: - SELECT * FROM Author me + 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 @@ -103,68 +103,165 @@ All helper methods take the following arguments: 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. + +See L for a list of valid attributes and valid +relationship attributes. =head2 belongs_to +=over 4 + +=item Arguments: $accessor_name, $related_class, $foreign_key_column|$cond?, $attr? + +=back + # 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); + My::DBIC::Schema::Book->belongs_to( author => 'My::DBIC::Schema::Author' ); + + my $author_obj = $obj->author; # get author object + $obj->author( $new_author_obj ); # set author object + +The above belongs_to relationship could also have been specified as, -Creates a relationship where the calling class stores the foreign class's -primary key in one (or more) of its columns. If $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 $cond is not given, the relname is used as -the column name. + My::DBIC::Schema::Book->belongs_to( author, + 'My::DBIC::Schema::Author', + { 'foreign.author' => 'self.author' } ); + +Creates a relationship where the calling class stores the foreign class's +primary key in one (or more) of its columns. This relationship defaults to +using C<$accessor_name> as the foreign key in C<$related_class> to resolve the +join, unless C<$foreign_key_column> specifies the foreign key column in +C<$related_class> or C<$cond> specifies a reference to a join condition hash. + +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. Thus, 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. +See L for documentation on relationship +methods and valid relationship attributes. + =head2 has_many - # in an Author class (where Author has many Books) +=over 4 + +=item Arguments: $accessor_name, $related_class, $foreign_key_column|$cond?, $attr? + +=back + + # 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); +The above C relationship could also have been specified with an +explicit join condition: + + My::DBIC::Schema::Author->has_many( books => 'My::DBIC::Schema::Book', { + 'foreign.author' => 'self.author', + }); + 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 -$cond argument, or specify a complete join condition. - -As well as the accessor method, a 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. +columns. This relationship defaults to using C<$accessor_name> as the foreign +key in C<$related_class> to resolve the join, unless C<$foreign_key_column> +specifies the foreign key column in C<$related_class> or C<$cond> specifies a +reference to a join condition hash. + +Three methods are created when you create a has_many relationship. The first +method is the expected accessor method, C<$accessor_name()>. 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_$relname >>, 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 -related objects will be deleted as well. However, any database-level -cascade or restrict will take precedence. +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. + +See L for documentation on relationship +methods and valid relationship attributes. =head2 might_have - My::DBIC::Schema::Author->might_have(pseudonym => - 'My::DBIC::Schema::Pseudonyms'); +=over 4 + +=item Arguments: $accessor_name, $related_class, $foreign_key_column|$cond?, $attr? + +=back + + My::DBIC::Schema::Author->might_have( pseudonym => + 'My::DBIC::Schema::Pseudonym' ); + 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 $cond specifies a column or join condition. +The above might_have relationship could have been specified as: + + My::DBIC::Schema::Author->might_have( pseudonym => + 'My::DBIC::Schema::Pseudonym', + 'author' ); + +Or even: + + My::DBIC::Schema::Author->might_have( pseudonym => + 'My::DBIC::Schema::Pseudonym', + { 'foreign.author' => 'self.author' } ); + +Assuming the Pseudonym table has + +Creates an optional one-to-one relationship with a class. This relationship +defaults to using C<$accessor_name> as the foreign key in C<$related_class> to +resolve the join, unless C<$foreign_key_column> specifies the foreign key +column in C<$related_class> or C<$cond> specifies a reference to a join +condition hash. If you update or delete an object in a class with a C -relationship, the related object will be updated or deleted as well. -Any database-level update or delete constraints will override this behaviour. +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. + +See L for documentation on relationship +methods and valid relationship attributes. =head2 has_one +=over 4 + +=item Arguments: $accessor_name, $related_class_name, $join_condition?, $attr? + +=back + My::DBIC::Schema::Book->has_one(isbn => 'My::DBIC::Schema::ISBN'); - my $isbn_obj = $obj->isbn; + + my $isbn_obj = $obj->isbn; # to get the ISBN object Creates a one-to-one relationship with another class. This is just like C, except the implication is that the other object is always @@ -172,31 +269,74 @@ present. The only difference between C and C is that C uses an (ordinary) inner join, whereas C uses a left join. +The has_one relationship should be used when a row in the table has exactly one +related row in another table. If the related row might not exist in the foreign +table, use the L relationship. + +In the above example, each Book in the database is associated with exactly one +ISBN object. + +See L for documentation on relationship +methods and valid relationship attributes. =head2 many_to_many - My::DBIC::Schema::Actor->has_many( actor_roles => +=over 4 + +=item Arguments: $accessor_name, $link_rel_name, $foreign_rel_name, $attr? + +=back + +To create a many_to_many relationship from Actor to Role: + + My::DBIC::Schema::Actor->has_many( actor_roles => 'My::DBIC::Schema::ActorRoles', 'actor' ); - My::DBIC::Schema::ActorRoles->belongs_to( role => + My::DBIC::Schema::ActorRoles->belongs_to( role => 'My::DBIC::Schema::Role' ); - My::DBIC::Schema::ActorRoles->belongs_to( actor => + My::DBIC::Schema::ActorRoles->belongs_to( actor => 'My::DBIC::Schema::Actor' ); My::DBIC::Schema::Actor->many_to_many( roles => 'actor_roles', - 'My::DBIC::Schema::Roles' ); + 'role' ); + +And, for the reverse relationship, from Role to Actor: - ... + My::DBIC::Schema::Role->has_many( actor_roles => + 'My::DBIC::Schema::ActorRoles', + 'role' ); - my @role_objs = $actor->roles; + My::DBIC::Schema::Role->many_to_many( actors => 'actor_roles', 'actor' ); + +To add a role for your actor, and fill in the year of the role in the +actor_roles table: + + $actor->add_to_roles($role, { year => 1995 }); + +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 +C<$related_resultset> and similar methods which operate on true relationships. + +In the above example, ActorRoles is the link table class, and Role is the +foreign class. The C<$link_rel_name> parameter is the name of the accessor for +the has_many relationship from this table to the link table, and the +C<$foreign_rel_name> parameter is the accessor for the belongs_to relationship +from the link table to the foreign table. -Creates an accessor 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 +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. +In the above example, the Actor class will have 3 many_to_many accessor methods +set: C<$roles>, C<$add_to_roles>, C<$set_roles>, and similarly named accessors +will be created for the Role class for the C many_to_many +relationship. + +See L for documentation on relationship +methods and valid relationship attributes. + =cut 1;