X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FDBIx%2FClass%2FRelationship%2FBase.pm;h=4fb98bc6fe5c179ea68a4019fe7aea9dd8423055;hb=30236e4788db222d813d881c71269e500b3f8385;hp=05f25081fe65356e87c5dbed10fca97a092d64f5;hpb=daec44b85cffd777869c9652273670b27625e167;p=dbsrgits%2FDBIx-Class.git diff --git a/lib/DBIx/Class/Relationship/Base.pm b/lib/DBIx/Class/Relationship/Base.pm index 05f2508..4fb98bc 100644 --- a/lib/DBIx/Class/Relationship/Base.pm +++ b/lib/DBIx/Class/Relationship/Base.pm @@ -3,228 +3,293 @@ package DBIx::Class::Relationship::Base; use strict; use warnings; -use base qw/Class::Data::Inheritable/; +use base qw/DBIx::Class/; __PACKAGE__->mk_classdata('_relationships', { } ); =head1 NAME -DBIx::Class::Relationship - Inter-table relationships +DBIx::Class::Relationship::Base - Inter-table relationships =head1 SYNOPSIS =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 describe the relationships between the +tables in your database model. These are the "bare bones" relationships +methods, for predefined ones, look in L. =head1 METHODS +=head2 add_relationship + +=head3 Arguments: ('relname', 'Foreign::Class', $cond, $attrs) + + __PACKAGE__->add_relationship('relname', 'Foreign::Class', $cond, $attrs); + +The condition needs to be an SQL::Abstract-style representation of the +join between the tables. When resolving the condition for use in a JOIN, +keys using the psuedo-table I are resolved to mean "the Table on the +other side of the relationship", and values using the psuedo-table I +are resolved to mean "the Table this class is representing". Other +restrictions, such as by value, sub-select and other tables, may also be +used. Please check your database for JOIN parameter support. + +For example, if you're creating a rel from Author to Book, where the Book +table has a column author_id containing the ID of the Author row: + + { 'foreign.author_id' => 'self.id' } + +will result in the JOIN clause + + author me JOIN book book ON bar.author_id = me.id + +You can specify as many foreign => self mappings as necessary. Each key/value +pair provided in a hashref will be used as ANDed conditions, to add an ORed +condition, use an arrayref of hashrefs. See the L documentation +for more details. + +Valid attributes are as follows: + =over 4 +=item join_type + +Explicitly specifies the type of join to use in the relationship. Any SQL +join type is valid, e.g. C or C. It will be placed in the SQL +command immediately before C. + +=item proxy + +An arrayref containing a list of accessors in the foreign class to create in +the main class. If, for example, you do the following: + + MyDB::Schema::CD->might_have(liner_notes => 'MyDB::Schema::LinerNotes', undef, { + proxy => [ qw/notes/ ], + }); + +Then, assuming MyDB::Schema::LinerNotes has an accessor named notes, you can do: + + my $cd = MyDB::Schema::CD->find(1); + $cd->notes('Notes go here'); # set notes -- LinerNotes object is + # created if it doesn't exist + +=item accessor + +Specifies the type of accessor that should be created for the relationship. +Valid values are C (for when there is only a single related object), +C (when there can be many), and C (for when there is a single +related object, but you also want the relationship accessor to double as +a column accessor). For C accessors, an add_to_* method is also +created, which calls C for the relationship. + +=back + +=head2 register_relationship + +=head3 Arguments: ($relname, $rel_info) + +Registers a relationship on the class. This is called internally by +L to set up Accessors and Proxies. + =cut -sub add_relationship { - my ($class, $rel, $f_class, $cond, $attrs) = @_; - die "Can't create relationship without join condition" unless $cond; - $attrs ||= {}; - eval "use $f_class;"; - my %rels = %{ $class->_relationships }; - $rels{$rel} = { class => $f_class, - cond => $cond, - attrs => $attrs }; - $class->_relationships(\%rels); - #warn %{$f_class->_columns}; - - return unless eval { %{$f_class->_columns}; }; # Foreign class not loaded - my %join = (%$attrs, _action => 'join', - _aliases => { 'self' => 'me', 'foreign' => $rel }, - _classes => { 'me' => $class, $rel => $f_class }); - eval { $class->resolve_condition($cond, \%join) }; - - if ($@) { # If the resolve failed, back out and re-throw the error - delete $rels{$rel}; # - $class->_relationships(\%rels); - $class->throw("Error creating relationship $rel: $@"); - } - 1; -} +sub register_relationship { } -sub resolve_condition { - my ($self, $cond, $attrs) = @_; - if (ref $cond eq 'HASH') { - my %ret; - foreach my $key (keys %$cond) { - my $val = $cond->{$key}; - if (ref $val) { - $self->throw("Can't handle this yet :("); - } else { - $ret{$self->_cond_key($attrs => $key)} - = $self->_cond_value($attrs => $key => $val); - } - } - return \%ret; - } else { - $self->throw("Can't handle this yet :("); - } -} +=head2 related_resultset($name) -sub _cond_key { - my ($self, $attrs, $key) = @_; - my $action = $attrs->{_action} || ''; - if ($action eq 'convert') { - unless ($key =~ s/^foreign\.//) { - $self->throw("Unable to convert relationship to WHERE clause: invalid key ${key}"); - } - return $key; - } elsif ($action eq 'join') { - my ($type, $field) = split(/\./, $key); - if (my $alias = $attrs->{_aliases}{$type}) { - my $class = $attrs->{_classes}{$alias}; - $self->throw("Unknown column $field on $class as $alias") - unless exists $class->_columns->{$field}; - return join('.', $alias, $field); - } else { - $self->throw( "Unable to resolve type ${type}: only have aliases for ". - join(', ', keys %{$attrs->{_aliases} || {}}) ); - } - } - return $self->NEXT::ACTUAL::_cond_key($attrs, $key); -} + $rs = $obj->related_resultset('related_table'); -sub _cond_value { - my ($self, $attrs, $key, $value) = @_; - my $action = $attrs->{_action} || ''; - if ($action eq 'convert') { - unless ($value =~ s/^self\.//) { - $self->throw( "Unable to convert relationship to WHERE clause: invalid value ${value}" ); - } - unless ($self->_columns->{$value}) { - $self->throw( "Unable to convert relationship to WHERE clause: no such accessor ${value}" ); - } - return $self->get_column($value); - } elsif ($action eq 'join') { - my ($type, $field) = split(/\./, $value); - if (my $alias = $attrs->{_aliases}{$type}) { - my $class = $attrs->{_classes}{$alias}; - $self->throw("Unknown column $field on $class as $alias") - unless exists $class->_columns->{$field}; - my $ret = join('.', $alias, $field); - # return { '=' => \$ret }; # SQL::Abstract doesn't handle this yet :( - $ret = " = ${ret}"; - return \$ret; +Returns a L for the relationship named $name. + +=cut + +sub related_resultset { + my $self = shift; + $self->throw_exception("Can't call *_related as class methods") unless ref $self; + my $rel = shift; + my $rel_obj = $self->relationship_info($rel); + $self->throw_exception( "No such relationship ${rel}" ) unless $rel_obj; + + return $self->{related_resultsets}{$rel} ||= do { + my $attrs = (@_ > 1 && ref $_[$#_] eq 'HASH' ? pop(@_) : {}); + $attrs = { %{$rel_obj->{attrs} || {}}, %$attrs }; + + $self->throw_exception( "Invalid query: @_" ) if (@_ > 1 && (@_ % 2 == 1)); + my $query = ((@_ > 1) ? {@_} : shift); + + my $cond = $self->result_source->resolve_condition($rel_obj->{cond}, $rel, $self); + if (ref $cond eq 'ARRAY') { + $cond = [ map { my $hash; + foreach my $key (keys %$_) { + my $newkey = $key =~ /\./ ? "me.$key" : $key; + $hash->{$newkey} = $_->{$key}; + }; $hash } @$cond ]; } else { - $self->throw( "Unable to resolve type ${type}: only have aliases for ". - join(', ', keys %{$attrs->{_aliases} || {}}) ); + foreach my $key (grep { ! /\./ } keys %$cond) { + $cond->{"me.$key"} = delete $cond->{$key}; + } } - } - - return $self->NEXT::ACTUAL::_cond_value($attrs, $key, $value) + $query = ($query ? { '-and' => [ $cond, $query ] } : $cond); + $self->result_source->related_source($rel)->resultset->search($query, $attrs); + }; } +=head2 search_related + + $rs->search_related('relname', $cond, $attrs); + +Run a search on a related resultset. The search will be restricted to the +item or items represented by the L it was called +upon. This method can be called on a ResultSet, a Row or a ResultSource class. + +=cut + sub search_related { - my $self = shift; - return $self->_query_related('search', @_); + return shift->related_resultset(shift)->search(@_); } +=head2 count_related + + $obj->count_related('relname', $cond, $attrs); + +Returns the count of all the items in the related resultset, restricted by +the current item or where conditions. Can be called on a L or a L object. + +=cut + sub count_related { my $self = shift; - return $self->_query_related('count', @_); + return $self->search_related(@_)->count; } -sub _query_related { - my $self = shift; - my $meth = shift; - my $rel = shift; - my $attrs = { }; - if (@_ > 1 && ref $_[$#_] eq 'HASH') { - $attrs = { %{ pop(@_) } }; - } - my $rel_obj = $self->_relationships->{$rel}; - $self->throw( "No such relationship ${rel}" ) unless $rel_obj; - $attrs = { %{$rel_obj->{attrs} || {}}, %{$attrs || {}} }; - - $self->throw( "Invalid query: @_" ) if (@_ > 1 && (@_ % 2 == 1)); - my $query = ((@_ > 1) ? {@_} : shift); - - $attrs->{_action} = 'convert'; # shouldn't we resolve the cond to something - # to merge into the AST really? - my ($cond) = $self->resolve_condition($rel_obj->{cond}, $attrs); - $query = ($query ? { '-and' => [ $cond, $query ] } : $cond); - #use Data::Dumper; warn Dumper($query); - #warn $rel_obj->{class}." $meth $cond ".join(', ', @{$attrs->{bind}||[]}); - delete $attrs->{_action}; - return $self->resolve_class($rel_obj->{class} - )->$meth($query, $attrs); +=head2 new_related + + my $new_obj = $obj->new_related('relname', \%col_data); + +Create a new item of the related foreign class. If called on a +L object, it will magically +set any primary key values into foreign key columns for you. The newly +created item will not be saved into your storage until you call C +on it. + +=cut + +sub new_related { + my ($self, $rel, $values, $attrs) = @_; + return $self->search_related($rel)->new($values, $attrs); } +=head2 create_related + + my $new_obj = $obj->create_related('relname', \%col_data); + +Creates a new item, similarly to new_related, and also inserts the item's data +into your storage medium. See the distinction between C and C +in L for details. + +=cut + sub create_related { - my $class = shift; - return $class->new_related(@_)->insert; + my $self = shift; + my $rel = shift; + my $obj = $self->search_related($rel)->create(@_); + delete $self->{related_resultsets}->{$rel}; + return $obj; } -sub new_related { - my ($self, $rel, $values, $attrs) = @_; - $self->throw( "Can't call new_related as class method" ) - unless ref $self; - $self->throw( "new_related needs a hash" ) - unless (ref $values eq 'HASH'); - my $rel_obj = $self->_relationships->{$rel}; - $self->throw( "No such relationship ${rel}" ) unless $rel_obj; - $self->throw( "Can't abstract implicit create for ${rel}, condition not a hash" ) - unless ref $rel_obj->{cond} eq 'HASH'; - $attrs = { %{$rel_obj->{attrs}}, %{$attrs || {}}, _action => 'convert' }; - - my %fields = %{$self->resolve_condition($rel_obj->{cond},$attrs)}; - $fields{$_} = $values->{$_} for keys %$values; - - return $self->resolve_class($rel_obj->{class})->new(\%fields); +=head2 find_related + + my $found_item = $obj->find_related('relname', @pri_vals | \%pri_vals); + +Attempt to find a related object using its primary key or unique constraints. +See C in L for details. + +=cut + +sub find_related { + my $self = shift; + my $rel = shift; + return $self->search_related($rel)->find(@_); } +=head2 find_or_create_related + + my $new_obj = $obj->find_or_create_related('relname', \%col_data); + +Find or create an item of a related class. See C in +L for details. + +=cut + sub find_or_create_related { my $self = shift; - return ($self->search_related(@_))[0] || $self->create_related(@_); + return $self->find_related(@_) || $self->create_related(@_); } +=head2 set_from_related + + $book->set_from_related('author', $author_obj); + +Set column values on the current object, using related values from the given +related object. This is used to associate previously separate objects, for +example, to set the correct author for a book, find the Author object, then +call set_from_related on the book. + +The columns are only set in the local copy of the object, call C to set +them in the storage. + +=cut + sub set_from_related { my ($self, $rel, $f_obj) = @_; - my $rel_obj = $self->_relationships->{$rel}; - $self->throw( "No such relationship ${rel}" ) unless $rel_obj; + my $rel_obj = $self->relationship_info($rel); + $self->throw_exception( "No such relationship ${rel}" ) unless $rel_obj; my $cond = $rel_obj->{cond}; - $self->throw( "set_from_related can only handle a hash condition; the " + $self->throw_exception( "set_from_related can only handle a hash condition; the " ."condition for $rel is of type ".(ref $cond ? ref $cond : 'plain scalar')) unless ref $cond eq 'HASH'; - my $f_class = $self->resolve_class($rel_obj->{class}); - $self->throw( "Object $f_obj isn't a ".$f_class ) + my $f_class = $self->result_source->schema->class($rel_obj->{class}); + $self->throw_exception( "Object $f_obj isn't a ".$f_class ) unless $f_obj->isa($f_class); - foreach my $key (keys %$cond) { - next if ref $cond->{$key}; # Skip literals and complex conditions - $self->throw("set_from_related can't handle $key as key") - unless $key =~ m/^foreign\.([^\.]+)$/; - my $val = $f_obj->get_column($1); - $self->throw("set_from_related can't handle ".$cond->{$key}." as value") - unless $cond->{$key} =~ m/^self\.([^\.]+)$/; - $self->set_column($1 => $val); - } + $self->set_columns( + $self->result_source->resolve_condition( + $rel_obj->{cond}, $f_obj, $rel)); return 1; } +=head2 update_from_related + + $book->update_from_related('author', $author_obj); + +As C, but the changes are immediately updated onto your +storage. + +=cut + sub update_from_related { my $self = shift; $self->set_from_related(@_); $self->update; } +=head2 delete_related + + $obj->delete_related('relname', $cond, $attrs); + +Delete any related item subject to the given conditions. + +=cut + sub delete_related { my $self = shift; - return $self->search_related(@_)->delete; + my $obj = $self->search_related(@_)->delete; + delete $self->{related_resultsets}->{$_[0]}; + return $obj; } 1; -=back - =head1 AUTHORS Matt S. Trout