X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FDBIx%2FClass%2FRelationship.pm;h=c6f744d3a9b47578b833b1b48f881fee402ffcc5;hb=fb13a49f;hp=228499b35dc5861090ce92996d27e3dfefe81f2e;hpb=c9070342751920cd363a24b065b75fbc2a466d25;p=dbsrgits%2FDBIx-Class.git diff --git a/lib/DBIx/Class/Relationship.pm b/lib/DBIx/Class/Relationship.pm index 228499b..c6f744d 100644 --- a/lib/DBIx/Class/Relationship.pm +++ b/lib/DBIx/Class/Relationship.pm @@ -20,15 +20,15 @@ DBIx::Class::Relationship - Inter-table relationships =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(); @@ -39,6 +39,9 @@ See L for more. =head1 DESCRIPTION +The word I has a specific meaning in DBIx::Class, see +the definition in the L. + 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, @@ -72,7 +75,7 @@ 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 list context, each returns a list of Result 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 @@ -102,36 +105,39 @@ L. All helper methods are called similar to the following template: - __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>. + __PACKAGE__->$method_name('relname', 'Foreign::Class', \%cond|\@cond|\&cond?, \%attrs?); + +Both C and C are optional. Pass C for C if +you want to use the default value for it, but still want to set C. + +See L for full documentation on +definition of the C argument. -See L for documentation on the -attrubutes that are allowed in the C<$attrs> argument. +See L for documentation on the +attributes that are allowed in the C argument. =head2 belongs_to =over 4 -=item Arguments: $accessor_name, $related_class, $fk_column|\%cond|\@cond?, \%attr? +=item Arguments: $accessor_name, $related_class, $our_fk_column|\%cond|\@cond|\$cond?, \%attrs? =back 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 column in this class -to resolve the join against the primary key from C<$related_class>, -unless C<$fk_column> specifies the foreign key column in this class or -C specifies a reference to a join condition hash. +class's primary key in one (or more) of the calling class columns. +This relationship defaults to using C<$accessor_name> as the column +name in this class to resolve the join against the primary key from +C<$related_class>, unless C<$our_fk_column> specifies the foreign key column +in this class or C specifies a reference to a join condition. =over =item accessor_name This argument is the name of the method you can call on a -L object to retrieve the instance of the foreign +L object to retrieve the instance of the foreign class matching this relationship. This is often called the C. @@ -144,7 +150,7 @@ indicated by this relationship. This is the class name of the table referenced by the foreign key in this class. -=item fk_column +=item our_fk_column The column name on this class that contains the foreign key. @@ -152,17 +158,15 @@ OR =item cond -A hashref where the keys are C and -the values are C. This is useful for -relations that are across multiple columns. +A hashref, arrayref or coderef specifying a custom join expression. For +more info see L. =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' ); @@ -170,11 +174,11 @@ relations that are across multiple columns. 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' ); @@ -188,18 +192,20 @@ relations that are across multiple columns. $book->get_column('author_id'); -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: +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->author >> would +return C. However in this case you would probably want to set +the L 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 => + author => 'My::DBIC::Schema::Author', - 'author', + 'author', { join_type => 'left' } ); @@ -208,36 +214,43 @@ Cascading deletes are off by default on a C relationship. To turn them on, pass C<< cascade_delete => 1 >> in the $attr hashref. +By default, DBIC will return undef and avoid querying the database if a +C accessor is called when any part of the foreign key IS NULL. To +disable this behavior, pass C<< undef_on_null_fk => 0 >> in the C<\%attrs> +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. +See L for documentation on relationship +methods and valid relationship attributes. Also see L +for a L +which can be assigned to relationships as well. =head2 has_many =over 4 -=item Arguments: $accessor_name, $related_class, $foreign_key_column|\%cond|\@cond?, \%attr? +=item Arguments: $accessor_name, $related_class, $their_fk_column|\%cond|\@cond|\&cond?, L<\%attrs?|DBIx::Class::ResultSet/ATTRIBUTES> =back -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. 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<$foreign_key_column> specifies the foreign -key column in C<$related_class> or C specifies a reference to a -join condition hash. +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). 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 +specifies a reference to a join condition. =over =item accessor_name This argument is the name of the method you can call on a -L object to retrieve a resultset of the related -class restricted to the ones related to the row object. In list -context it returns the row objects. This is often called the +L object to retrieve a resultset of the related +class restricted to the ones related to the result object. In list +context it returns the result objects. This is often called the C. Use this accessor_name in L @@ -249,7 +262,7 @@ indicated by this relationship. This is the class name of the table which contains a foreign key column containing PK values of this class. -=item foreign_key_column +=item their_fk_column The column name on the related class that contains the foreign key. @@ -257,47 +270,36 @@ OR =item cond -A hashref where the keys are C and -the values are C. This is useful for -relations that are across multiple columns. - -OR - -An arrayref containing an SQL::Abstract-like condition. For example a -link table where two columns link back to the same table. This is an -OR condition. - - My::Schema::Item->has_many('rels', 'My::Schema::Relationships', - [ { 'foreign.LItemID' => 'self.ID' }, - { 'foreign.RItemID' => 'self.ID'} ]); +A hashref, arrayref or coderef specifying a custom join expression. For +more info see L. =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 @@ -319,13 +321,14 @@ OR condition. $author->add_to_books(\%col_data); -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 always returns a resultset, 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 +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, eg C<$accessor_name_rs()>. +This method works just like the normal accessor, except that it always +returns a resultset, 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 @@ -342,29 +345,32 @@ the related objects will be copied as well. To turn this behaviour off, pass C<< cascade_copy => 0 >> in the C<$attr> hashref. The behaviour defaults to C<< cascade_copy => 1 >>. -See L for documentation on relationship -methods and valid relationship attributes. +See L for documentation on +relationship methods and valid relationship attributes. Also see +L for a L which can be assigned to +relationships as well. =head2 might_have =over 4 -=item Arguments: $accessor_name, $related_class, $foreign_key_column|\%cond|\@cond?, \%attr? +=item Arguments: $accessor_name, $related_class, $their_fk_column|\%cond|\@cond|\&cond?, L<\%attrs?|DBIx::Class::ResultSet/ATTRIBUTES> =back 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 +resolve the join, unless C<$their_fk_column> specifies the foreign key column in C<$related_class> or C specifies a reference to a join -condition hash. +condition. =over =item accessor_name This argument is the name of the method you can call on a -L object to retrieve the instance of the foreign +L object to retrieve the instance of the foreign class matching this relationship. This is often called the C. @@ -377,7 +383,7 @@ indicated by this relationship. This is the class name of the table which contains a foreign key column containing PK values of this class. -=item foreign_key_column +=item their_fk_column The column name on the related class that contains the foreign key. @@ -385,9 +391,8 @@ OR =item cond -A hashref where the keys are C and -the values are C. This is useful for -relations that are across multiple columns. +A hashref, arrayref or coderef specifying a custom join expression. For +more info see L. =back @@ -424,29 +429,43 @@ update, so if your database has a constraint on the relationship, it will have deleted/updated the related records or raised an exception before DBIx::Class gets to perform the cascaded operation. -See L for documentation on relationship -methods and valid relationship attributes. +See L for documentation on +relationship methods and valid relationship attributes. Also see +L for a L which can be assigned to +relationships as well. + +Note that if you supply a condition on which to join, and the column in the +current table allows nulls (i.e., has the C attribute set to a +true value), than C 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) + +If you must be naughty, you can suppress the warning by setting +C environment variable to a true value. Otherwise, +you probably just meant to use C. =head2 has_one =over 4 -=item Arguments: $accessor_name, $related_class, $foreign_key_column|\%cond|\@cond?, \%attr? +=item Arguments: $accessor_name, $related_class, $their_fk_column|\%cond|\@cond|\&cond?, L<\%attrs?|DBIx::Class::ResultSet/ATTRIBUTES> =back Creates a 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 +resolve the join, unless C<$their_fk_column> specifies the foreign key column in C<$related_class> or C specifies a reference to a join -condition hash. +condition. =over =item accessor_name This argument is the name of the method you can call on a -L object to retrieve the instance of the foreign +L object to retrieve the instance of the foreign class matching this relationship. This is often called the C. @@ -459,7 +478,7 @@ indicated by this relationship. This is the class name of the table which contains a foreign key column containing PK values of this class. -=item foreign_key_column +=item their_fk_column The column name on the related class that contains the foreign key. @@ -467,28 +486,27 @@ OR =item cond -A hashref where the keys are C and -the values are C. This is useful for -relations that are across multiple columns. +A hashref, arrayref or coderef specifying a custom join expression. For +more info see L. =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' }, ); @@ -502,28 +520,41 @@ always present. The only difference between C and C is that C uses an (ordinary) inner join, whereas C defaults to 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. +The has_one relationship should be used when a row in the table must +have 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. +See L for documentation on +relationship methods and valid relationship attributes. Also see +L for a L which can be assigned to +relationships as well. + +Note that if you supply a condition on which to join, if the column in the +current table allows nulls (i.e., has the C attribute set to a +true value), than warnings might apply just as with +L. =head2 many_to_many =over 4 -=item Arguments: $accessor_name, $link_rel_name, $foreign_rel_name, \%attr? +=item Arguments: $accessor_name, $link_rel_name, $foreign_rel_name, L<\%attrs?|DBIx::Class::ResultSet/ATTRIBUTES> =back +C is a I which has a specific +meaning in DBIx::Class, see the definition in the +L. + C 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 and similar methods which operate on true relationships. =over @@ -531,7 +562,7 @@ C and similar methods which operate on true relationships. =item accessor_name This argument is the name of the method you can call on a -L object to retrieve the rows matching this +L object to retrieve the rows matching this relationship. On a many_to_many, unlike other relationships, this cannot be used in @@ -592,16 +623,19 @@ set: C, C, C, 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. +See L for documentation on +relationship methods and valid relationship attributes. Also see +L for a L which can be assigned to +relationships as well. =cut 1; -=head1 AUTHORS +=head1 AUTHOR AND CONTRIBUTORS -see L +See L and L in DBIx::Class =head1 LICENSE