X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FDBIx%2FClass%2FResultSet.pm;h=4e8467eaad5bc96bb67136995511f7e8464323dc;hb=7e51afbf1951bc8febf00897e5e3f0f25dfc34aa;hp=e59b88ad9f01d488ca0e82d59268bddebfa6d4e7;hpb=56e2b93052fe8f5701b954f1085dbece67ff69d2;p=dbsrgits%2FDBIx-Class-Historic.git diff --git a/lib/DBIx/Class/ResultSet.pm b/lib/DBIx/Class/ResultSet.pm index e59b88a..4e8467e 100644 --- a/lib/DBIx/Class/ResultSet.pm +++ b/lib/DBIx/Class/ResultSet.pm @@ -15,7 +15,7 @@ use List::Util (); use Scalar::Util (); use base qw/DBIx::Class/; -__PACKAGE__->mk_group_accessors('simple' => qw/result_class _source_handle/); +__PACKAGE__->mk_group_accessors('simple' => qw/_result_class _source_handle/); =head1 NAME @@ -108,7 +108,6 @@ sub new { # see https://bugzilla.redhat.com/show_bug.cgi?id=196836 my $self = { _source_handle => $source, - result_class => $attrs->{result_class} || $source->resolve->result_class, cond => $attrs->{where}, count => undef, pager => undef, @@ -117,6 +116,10 @@ sub new { bless $self, $class; + $self->result_class( + $attrs->{result_class} || $source->resolve->result_class + ); + return $self; } @@ -200,7 +203,7 @@ sub search_rs { my $new_attrs = { %{$our_attrs}, %{$attrs} }; # merge new attrs into inherited - foreach my $key (qw/join prefetch/) { + foreach my $key (qw/join prefetch +select +as/) { next unless exists $attrs->{$key}; $new_attrs->{$key} = $self->_merge_attr($our_attrs->{$key}, $attrs->{$key}); } @@ -341,6 +344,9 @@ source for which column data is provided, including the primary key. If your table does not have a primary key, you B provide a value for the C attribute matching one of the unique constraints on the source. +In addition to C, L recognizes and applies standard +L in the same way as L does. + Note: If your query does not return only one row, a warning is generated: Query returned more than one row @@ -731,8 +737,8 @@ sub get_column { $cd_rs = $rs->search_like({ title => '%blue%'}); Performs a search, but uses C instead of C<=> as the condition. Note -that this is simply a convenience method. You most likely want to use -L with specific operators. +that this is simply a convenience method retained for ex Class::DBI users. +You most likely want to use L with specific operators. For more information, see L. @@ -985,6 +991,14 @@ L<"table"|DBIx::Class::Manual::Glossary/"ResultSource"> class. =cut +sub result_class { + my ($self, $result_class) = @_; + if ($result_class) { + $self->ensure_class_loaded($result_class); + $self->_result_class($result_class); + } + $self->_result_class; +} =head2 count @@ -1293,11 +1307,26 @@ Deletes the contents of the resultset from its result source. Note that this will not run DBIC cascade triggers. See L if you need triggers to run. See also L. +delete may not generate correct SQL for a query with joins or a resultset +chained from a related resultset. In this case it will generate a warning:- + + WARNING! Currently $rs->delete() does not generate proper SQL on + joined resultsets, and may delete rows well outside of the contents + of $rs. Use at your own risk + +In these cases you may find that delete_all is more appropriate, or you +need to respecify your query in a way that can be expressed without a join. + =cut sub delete { my ($self) = @_; - + $self->throw_exception("Delete should not be passed any arguments") + if $_[1]; + carp( 'WARNING! Currently $rs->delete() does not generate proper SQL' + . ' on joined resultsets, and may delete rows well outside of the' + . ' contents of $rs. Use at your own risk' ) + if ( $self->{attrs}{seen_join} ); my $cond = $self->_cond_for_update_delete; $self->result_source->storage->delete($self->result_source, $cond); @@ -1333,8 +1362,9 @@ sub delete_all { =back -Pass an arrayref of hashrefs. Each hashref should be a structure suitable for -submitting to a $resultset->create(...) method. +Accepts either an arrayref of hashrefs or alternatively an arrayref of arrayrefs. +For the arrayref of hashrefs style each hashref should be a structure suitable +forsubmitting to a $resultset->create(...) method. In void context, C in L is used to insert the data, as this is a faster method. @@ -1374,7 +1404,18 @@ Example: Assuming an Artist Class that has many CDs Classes relating: print $ArtistOne->name; ## response is 'Artist One' print $ArtistThree->cds->count ## reponse is '2' - + +For the arrayref of arrayrefs style, the first element should be a list of the +fieldsnames to which the remaining elements are rows being inserted. For +example: + + $Arstist_rs->populate([ + [qw/artistid name/], + [100, 'A Formally Unknown Singer'], + [101, 'A singer that jumped the shark two albums ago'], + [102, 'An actually cool singer.'], + ]); + Please note an important effect on your data when choosing between void and wantarray context. Since void context goes straight to C in L this will skip any component that is overriding @@ -1386,7 +1427,10 @@ values. =cut sub populate { - my ($self, $data) = @_; + my $self = shift @_; + my $data = ref $_[0][0] eq 'HASH' + ? $_[0] : ref $_[0][0] eq 'ARRAY' ? $self->_normalize_populate_args($_[0]) : + $self->throw_exception('Populate expects an arrayref of hashes or arrayref of arrayrefs'); if(defined wantarray) { my @created; @@ -1460,6 +1504,28 @@ sub populate { } } +=head2 _normalize_populate_args ($args) + +Private method used by L to normalize it's incoming arguments. Factored +out in case you want to subclass and accept new argument structures to the +L method. + +=cut + +sub _normalize_populate_args { + my ($self, $data) = @_; + my @names = @{shift(@$data)}; + my @results_to_create; + foreach my $datum (@$data) { + my %result_to_create; + foreach my $index (0..$#names) { + $result_to_create{$names[$index]} = $$datum[$index]; + } + push @results_to_create, \%result_to_create; + } + return \@results_to_create; +} + =head2 pager =over 4 @@ -2028,6 +2094,49 @@ sub related_resultset { }; } +=head2 current_source_alias + +=over 4 + +=item Arguments: none + +=item Return Value: $source_alias + +=back + +Returns the current table alias for the result source this resultset is built +on, that will be used in the SQL query. Usually it is C. + +Currently the source alias that refers to the result set returned by a +L/L family method depends on how you got to the resultset: it's +C by default, but eg. L aliases it to the related result +source name (and keeps C referring to the original result set). The long +term goal is to make L always alias the current resultset as C +(and make this method unnecessary). + +Thus it's currently necessary to use this method in predefined queries (see +L) when referring to the +source alias of the current result set: + + # in a result set class + sub modified_by { + my ($self, $user) = @_; + + my $me = $self->current_source_alias; + + return $self->search( + "$me.modified" => $user->id, + ); + } + +=cut + +sub current_source_alias { + my ($self) = @_; + + return ($self->{attrs} || {})->{alias} || 'me'; +} + sub _resolve_from { my ($self, $extra_join) = @_; my $source = $self->result_source; @@ -2309,6 +2418,10 @@ L) you will need to do C<\'year DESC' > specify an order. (The scalar ref causes it to be passed as raw sql to the DB, so you will need to manually quote things as appropriate.) +If your L version supports it (>=1.50), you can also use +C<{-desc => 'year'}>, which takes care of the quoting for you. This is the +recommended syntax. + =head2 columns =over 4 @@ -2769,6 +2882,58 @@ with a father in the person table, we could explicitly use C: # SELECT child.* FROM person child # INNER JOIN person father ON child.father_id = father.id +If you need to express really complex joins or you need a subselect, you +can supply literal SQL to C via a scalar reference. In this case +the contents of the scalar will replace the table name asscoiated with the +resultsource. + +WARNING: This technique might very well not work as expected on chained +searches - you have been warned. + + # Assuming the Event resultsource is defined as: + + MySchema::Event->add_columns ( + sequence => { + data_type => 'INT', + is_auto_increment => 1, + }, + location => { + data_type => 'INT', + }, + type => { + data_type => 'INT', + }, + ); + MySchema::Event->set_primary_key ('sequence'); + + # This will get back the latest event for every location. The column + # selector is still provided by DBIC, all we do is add a JOIN/WHERE + # combo to limit the resultset + + $rs = $schema->resultset('Event'); + $table = $rs->result_source->name; + $latest = $rs->search ( + undef, + { from => \ " + (SELECT e1.* FROM $table e1 + JOIN $table e2 + ON e1.location = e2.location + AND e1.sequence < e2.sequence + WHERE e2.sequence is NULL + ) me", + }, + ); + + # Equivalent SQL (with the DBIC chunks added): + + SELECT me.sequence, me.location, me.type FROM + (SELECT e1.* FROM events e1 + JOIN events e2 + ON e1.location = e2.location + AND e1.sequence < e2.sequence + WHERE e2.sequence is NULL + ) me; + =head2 for =over 4