X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FDBIx%2FClass%2FResultSet.pm;h=22e9129b429cfa3369185d2c4461260e5b1f997e;hb=eaefb953638f736ee8988251bf8cfc8bedad2563;hp=461a837e8d56e7225401a94d96223f0c8b255dd6;hpb=d2c26f3fdccf7aead269ab2d7c8c1d0c5b14b9a1;p=dbsrgits%2FDBIx-Class.git

diff --git a/lib/DBIx/Class/ResultSet.pm b/lib/DBIx/Class/ResultSet.pm
index 461a837..22e9129 100644
--- a/lib/DBIx/Class/ResultSet.pm
+++ b/lib/DBIx/Class/ResultSet.pm
@@ -51,9 +51,15 @@ In the examples below, the following table classes are used:
 
 =head1 METHODS
 
-=head2 new
+=head2 new 
 
-=head3 Arguments: ($source, \%$attrs)
+=over 4
+
+=item Arguments: $source, \%$attrs
+
+=item Return Value: $rs
+
+=back
 
 The resultset constructor. Takes a source object (usually a
 L<DBIx::Class::ResultSourceProxy::Table>) and an attribute hash (see
@@ -65,6 +71,12 @@ automatically get one from e.g. a L</search> called in scalar context:
 
   my $rs = $schema->resultset('CD')->search({ title => '100th Window' });
 
+IMPORTANT: If called on an object, proxies to new_result instead so
+
+  my $cd = $schema->resultset('CD')->new({ title => 'Spoon' });
+
+will return a CD object, not a ResultSet.
+
 =cut
 
 sub new {
@@ -157,8 +169,19 @@ sub new {
 
 =head2 search
 
-  my @cds    = $rs->search({ year => 2001 }); # "... WHERE year = 2001"
-  my $new_rs = $rs->search({ year => 2005 });
+=over 4
+
+=item Arguments: $cond, \%attrs?
+
+=item Return Value: $resultset (scalar context), @row_objs (list context)
+
+=back
+
+  my @cds    = $cd_rs->search({ year => 2001 }); # "... WHERE year = 2001"
+  my $new_rs = $cd_rs->search({ year => 2005 });
+
+  my $new_rs = $cd_rs->search([ { year => 2005 }, { year => 2004 } ]);
+                 # year = 2005 OR year = 2004
 
 If you need to pass in additional attributes but no additional condition,
 call it as C<search(undef, \%attrs);>.
@@ -215,11 +238,19 @@ sub search {
 
 =head2 search_literal
 
-  my @obj    = $rs->search_literal($literal_where_cond, @bind);
-  my $new_rs = $rs->search_literal($literal_where_cond, @bind);
+=over 4
+
+=item Arguments: $sql_fragment, @bind_values
+
+=item Return Value: $resultset (scalar context), @row_objs (list context)
+
+=back
+
+  my @cds   = $cd_rs->search_literal('year = ? AND title = ?', qw/2001 Reload/);
+  my $newrs = $artist_rs->search_literal('name = ?', 'Metallica');
 
 Pass a literal chunk of SQL to be added to the conditional part of the
-resultset.
+resultset query.
 
 =cut
 
@@ -232,7 +263,13 @@ sub search_literal {
 
 =head2 find
 
-=head3 Arguments: (@colvalues) | (\%cols, \%attrs?)
+=over 4
+
+=item Arguments: @values | \%cols, \%attrs?
+
+=item Return Value: $row_object
+
+=back
 
 Finds a row based on its primary key or unique constraint. For example:
 
@@ -296,10 +333,20 @@ sub find {
 
 =head2 search_related
 
-  $rs->search_related('relname', $cond?, $attrs?);
+=over 4
+
+=item Arguments: $cond, \%attrs?
 
-Search the specified relationship. Optionally specify a condition for matching
-records.
+=item Return Value: $new_resultset
+
+=back
+
+  $new_rs = $cd_rs->search_related('artist', {
+    name => 'Emo-R-Us',
+  });
+
+Search the specified relationship, optionally specify a condition and
+attributes for matching records. See L</ATTRIBUTES> for more information.
 
 =cut
 
@@ -309,7 +356,16 @@ sub search_related {
 
 =head2 cursor
 
-Returns a storage-driven cursor to the given resultset.
+=over 4
+
+=item Arguments: none
+
+=item Return Value: $cursor
+
+=back
+
+Returns a storage-driven cursor to the given resultset. See
+L<DBIx::Class::Cursor> for more information.
 
 =cut
 
@@ -323,7 +379,18 @@ sub cursor {
 
 =head2 single
 
-Inflates the first result without creating a cursor
+=over 4
+
+=item Arguments: $cond?
+
+=item Return Value: $row_object?
+
+=back
+
+  my $cd = $schema->resultset('CD')->single({ year => 2001 });
+
+Inflates the first result without creating a cursor if the resultset has
+any records in it; if not returns nothing. Used by find() as an optimisation.
 
 =cut
 
@@ -350,8 +417,19 @@ sub single {
 
 =head2 search_like
 
-Perform a search, but use C<LIKE> instead of equality as the condition. Note
-that this is simply a convenience method; you most likely want to use
+=over 4
+
+=item Arguments: $cond, \%attrs?
+
+=item Return Value: $resultset (scalar context), @row_objs (list context)
+
+=back
+
+  # WHERE title LIKE '%blue%'
+  $cd_rs = $rs->search_like({ title => '%blue%'});
+
+Perform a search, but use C<LIKE> instead of C<=> as the condition. Note
+that this is simply a convenience method. You most likely want to use
 L</search> with specific operators.
 
 For more information, see L<DBIx::Class::Manual::Cookbook>.
@@ -368,9 +446,19 @@ sub search_like {
 
 =head2 slice
 
-=head3 Arguments: ($first, $last)
+=over 4
+
+=item Arguments: $first, $last
 
-Returns a subset of elements from the resultset.
+=item Return Value: $resultset (scalar context), @row_objs (list context)
+
+=back
+
+Returns a resultset or object list representing a subset of elements from the
+resultset slice is called on.  Indexes are from 0 - i.e. to get the first
+three records, call
+
+  my ($one, $two, $three) = $rs->slice(0, 2);
 
 =cut
 
@@ -386,6 +474,14 @@ sub slice {
 
 =head2 next
 
+=over 4
+
+=item Arguments: none
+
+=item Return Value: $result?
+
+=back
+
 Returns the next element in the resultset (C<undef> is there is none).
 
 Can be used to efficiently iterate over records in the resultset:
@@ -501,13 +597,30 @@ sub _collapse_result {
 
 =head2 result_source
 
-Returns a reference to the result source for this recordset.
+=over 4
+
+=item Arguments: $result_source?
+
+=item Return Value: $result_source
+
+=back
+
+An accessor for the primary ResultSource object from which this ResultSet
+is derived.
 
 =cut
 
 
 =head2 count
 
+=over 4
+
+=item Arguments: $cond, \%attrs??
+
+=item Return Value: $count
+
+=back
+
 Performs an SQL C<COUNT> with the same query as the resultset was built
 with to find the number of elements. If passed arguments, does a search
 on the resultset and counts the results of that.
@@ -568,7 +681,16 @@ sub _count { # Separated out so pager can get the full count
 
 =head2 count_literal
 
-Calls L</search_literal> with the passed arguments, then L</count>.
+=over 4
+
+=item Arguments: $sql_fragment, @bind_values
+
+=item Return Value: $count
+
+=back
+
+Counts the results in a literal query. Equivalent to calling L</search_literal>
+with the passed arguments, then L</count>.
 
 =cut
 
@@ -576,7 +698,15 @@ sub count_literal { shift->search_literal(@_)->count; }
 
 =head2 all
 
-Returns all elements in the resultset. Called implictly if the resultset
+=over 4
+
+=item Arguments: none
+
+=item Return Value: @objects
+
+=back
+
+Returns all elements in the resultset. Called implicitly if the resultset
 is returned in list context.
 
 =cut
@@ -610,6 +740,14 @@ sub all {
 
 =head2 reset
 
+=over 4
+
+=item Arguments: none
+
+=item Return Value: $self
+
+=back
+
 Resets the resultset's cursor, so you can iterate through the elements again.
 
 =cut
@@ -623,7 +761,16 @@ sub reset {
 
 =head2 first
 
-Resets the resultset and returns the first element.
+=over 4
+
+=item Arguments: none
+
+=item Return Value: $object?
+
+=back
+
+Resets the resultset and returns an object for the first result (if the
+resultset contains anything).
 
 =cut
 
@@ -633,9 +780,17 @@ sub first {
 
 =head2 update
 
-=head3 Arguments: (\%values)
+=over 4
+
+=item Arguments: \%values
+
+=item Return Value: $storage_rv
 
-Sets the specified columns in the resultset to the supplied values.
+=back
+
+Sets the specified columns in the resultset to the supplied values in a
+single query. Return value will be true if the update succeeded or false
+if no records were updated; exact type of success value is storage-dependent.
 
 =cut
 
@@ -644,12 +799,19 @@ sub update {
   $self->throw_exception("Values for update must be a hash")
     unless ref $values eq 'HASH';
   return $self->result_source->storage->update(
-           $self->result_source->from, $values, $self->{cond});
+    $self->result_source->from, $values, $self->{cond}
+  );
 }
 
 =head2 update_all
 
-=head3 Arguments: (\%values)
+=over 4
+
+=item Arguments: \%values
+
+=item Return Value: 1
+
+=back
 
 Fetches all objects and updates them one at a time.  Note that C<update_all>
 will run cascade triggers while L</update> will not.
@@ -668,7 +830,16 @@ sub update_all {
 
 =head2 delete
 
-Deletes the contents of the resultset from its result source.
+=over 4
+
+=item Arguments: none
+
+=item Return Value: 1
+
+=back
+
+Deletes the contents of the resultset from its result source. Note that this
+will not run cascade triggers. See L</delete_all> if you need triggers to run.
 
 =cut
 
@@ -705,9 +876,11 @@ sub delete {
         $del->{$1} = $self->{cond}{$key};
       }
     }
+
   } else {
     $self->throw_exception(
-      "Can't delete on resultset with condition unless hash or array");
+      "Can't delete on resultset with condition unless hash or array"
+    );
   }
 
   $self->result_source->storage->delete($self->result_source->from, $del);
@@ -716,6 +889,14 @@ sub delete {
 
 =head2 delete_all
 
+=over 4
+
+=item Arguments: none
+
+=item Return Value: 1
+
+=back
+
 Fetches all objects and deletes them one at a time.  Note that C<delete_all>
 will run cascade triggers while L</delete> will not.
 
@@ -729,7 +910,15 @@ sub delete_all {
 
 =head2 pager
 
-Returns a L<Data::Page> object for the current resultset. Only makes
+=over 4
+
+=item Arguments: none
+
+=item Return Value: $pager
+
+=back
+
+Return Value a L<Data::Page> object for the current resultset. Only makes
 sense for queries with a C<page> attribute.
 
 =cut
@@ -746,9 +935,17 @@ sub pager {
 
 =head2 page
 
-=head3 Arguments: ($page_num)
+=over 4
 
-Returns a new resultset for the specified page.
+=item Arguments: $page_number
+
+=item Return Value: $rs
+
+=back
+
+Returns a resultset for the $page_number page of the resultset on which page
+is called, where each page contains a number of rows equal to the 'rows'
+attribute set on the resultset, or 10 by default
 
 =cut
 
@@ -761,9 +958,15 @@ sub page {
 
 =head2 new_result
 
-=head3 Arguments: (\%vals)
+=over 4
+
+=item Arguments: \%vals
 
-Creates a result in the resultset's result class.
+=item Return Value: $object
+
+=back
+
+Creates an object in the resultset's result class and returns it.
 
 =cut
 
@@ -786,9 +989,15 @@ sub new_result {
 
 =head2 create
 
-=head3 Arguments: (\%vals)
+=over 4
+
+=item Arguments: \%vals
+
+=item Return Value: $object
+
+=back
 
-Inserts a record into the resultset and returns the object.
+Inserts a record into the resultset and returns the object representing it.
 
 Effectively a shortcut for C<< ->new_result(\%vals)->insert >>.
 
@@ -803,7 +1012,13 @@ sub create {
 
 =head2 find_or_create
 
-=head3 Arguments: (\%vals, \%attrs?)
+=over 4
+
+=item Arguments: \%vals, \%attrs?
+
+=item Return Value: $object
+
+=back
 
   $class->find_or_create({ key => $val, ... });
 
@@ -842,7 +1057,15 @@ sub find_or_create {
 
 =head2 update_or_create
 
-  $class->update_or_create({ key => $val, ... });
+=over 4
+
+=item Arguments: \%col_values, { key => $unique_constraint }?
+
+=item Return Value: $object
+
+=back
+
+  $class->update_or_create({ col => $val, ... });
 
 First, search for an existing row matching one of the unique constraints
 (including the primary key) on the source of this resultset.  If a row is
@@ -907,7 +1130,15 @@ sub update_or_create {
 
 =head2 get_cache
 
-Gets the contents of the cache for the resultset.
+=over 4
+
+=item Arguments: none
+
+=item Return Value: \@cache_objects?
+
+=back
+
+Gets the contents of the cache for the resultset if the cache is set
 
 =cut
 
@@ -917,8 +1148,18 @@ sub get_cache {
 
 =head2 set_cache
 
+=over 4
+
+=item Arguments: \@cache_objects
+
+=item Return Value: \@cache_objects
+
+=back
+
 Sets the contents of the cache for the resultset. Expects an arrayref
-of objects of the same class as those produced by the resultset.
+of objects of the same class as those produced by the resultset. Note that
+if the cache is set the resultset will return the cached objects rather
+than re-querying the database even if the cache attr is not set.
 
 =cut
 
@@ -937,6 +1178,14 @@ sub set_cache {
 
 =head2 clear_cache
 
+=over 4
+
+=item Arguments: none
+
+=item Return Value: []
+
+=back
+
 Clears the cache for the resultset.
 
 =cut
@@ -947,6 +1196,14 @@ sub clear_cache {
 
 =head2 related_resultset
 
+=over 4
+
+=item Arguments: $relationship_name
+
+=item Return Value: $resultset
+
+=back
+
 Returns a related resultset for the supplied relationship name.
 
   $artist_rs = $schema->resultset('CD')->related_resultset('Artist');
@@ -954,7 +1211,7 @@ Returns a related resultset for the supplied relationship name.
 =cut
 
 sub related_resultset {
-  my ( $self, $rel, @rest ) = @_;
+  my ( $self, $rel ) = @_;
   $self->{related_resultsets} ||= {};
   return $self->{related_resultsets}{$rel} ||= do {
       #warn "fetching related resultset for rel '$rel'";
@@ -976,13 +1233,13 @@ sub related_resultset {
                alias => $alias,
                select => undef,
                as => undef }
-           )->search(@rest);      
+           );
   };
 }
 
 =head2 throw_exception
 
-See Schema's throw_exception
+See L<DBIx::Class::Schema/throw_exception> for details.
 
 =cut
 
@@ -991,6 +1248,8 @@ sub throw_exception {
   $self->result_source->schema->throw_exception(@_);
 }
 
+# XXX: FIXME: Attributes docs need clearing up
+
 =head1 ATTRIBUTES
 
 The resultset takes various attributes that modify its behavior. Here's an
@@ -998,13 +1257,23 @@ overview of them:
 
 =head2 order_by
 
+=over 4
+
+=item Value: ($order_by | \@order_by)
+
+=back
+
 Which column(s) to order the results by. This is currently passed
 through directly to SQL, so you can give e.g. C<year DESC> for a
 descending order on the column `year'.
 
 =head2 columns
 
-=head3 Arguments: (arrayref)
+=over 4
+
+=item Value: \@columns
+
+=back
 
 Shortcut to request a particular set of columns to be retrieved.  Adds
 C<me.> onto the start of any column without a C<.> in it and sets C<select>
@@ -1013,7 +1282,11 @@ use the C<cols> attribute, as in earlier versions of DBIC.)
 
 =head2 include_columns
 
-=head3 Arguments: (arrayref)
+=over 4
+
+=item Value: \@columns
+
+=back
 
 Shortcut to include additional columns in the returned results - for example
 
@@ -1027,7 +1300,11 @@ passed to object inflation
 
 =head2 select
 
-=head3 Arguments: (arrayref)
+=over 4
+
+=item Value: \@select_columns
+
+=back
 
 Indicates which columns should be selected from the storage. You can use
 column names, or in the case of RDBMS back ends, function or stored procedure
@@ -1047,7 +1324,11 @@ return a column named C<count(employeeid)> in the above example.
 
 =head2 as
 
-=head3 Arguments: (arrayref)
+=over 4
+
+=item Value: \@inflation_names
+
+=back
 
 Indicates column names for object inflation. This is used in conjunction with
 C<select>, usually when C<select> contains one or more function or stored
@@ -1079,6 +1360,12 @@ L<DBIx::Class::Manual::Cookbook> for details.
 
 =head2 join
 
+=over 4
+
+=item Value: ($rel_name | \@rel_names | \%rel_names)
+
+=back
+
 Contains a list of relationships that should be joined for this query.  For
 example:
 
@@ -1126,7 +1413,11 @@ below.
 
 =head2 prefetch
 
-=head3 Arguments: arrayref/hashref
+=over 4
+
+=item Value: ($rel_name | \@rel_names | \%rel_names)
+
+=back
 
 Contains one or more relationships that should be fetched along with the main 
 query (when they are accessed afterwards they will have already been
@@ -1163,7 +1454,11 @@ with an accessor type of 'single' or 'filter').
 
 =head2 from
 
-=head3 Arguments: (arrayref)
+=over 4
+
+=item Value: \@from_clause
+
+=back
 
 The C<from> attribute gives you manual control over the C<FROM> clause of SQL
 statements generated by L<DBIx::Class>, allowing you to express custom C<JOIN>
@@ -1178,7 +1473,7 @@ In simple terms, C<from> works as follows:
     [
         { <alias> => <table>, -join-type => 'inner|left|right' }
         [] # nested JOIN (optional)
-        { <table.column> = <foreign_table.foreign_key> }
+        { <table.column> => <foreign_table.foreign_key> }
     ]
 
     JOIN
@@ -1252,20 +1547,34 @@ with a father in the person table, we could explicitly use C<INNER JOIN>:
 
 =head2 page
 
-For a paged resultset, specifies which page to retrieve.  Leave unset
-for an unpaged resultset.
+=over 4
+
+=item Value: $page
+
+=back
+
+Makes the resultset paged and specifies the page to retrieve. Effectively
+identical to creating a non-pages resultset and then calling ->page($page)
+on it.
 
 =head2 rows
 
-For a paged resultset, how many rows per page:
+=over 4
 
-  rows => 10
+=item Value: $rows
 
-Can also be used to simulate an SQL C<LIMIT>.
+=back
+
+Specifes the maximum number of rows for direct retrieval or the number of
+rows per page if the page attribute or method is used.
 
 =head2 group_by
 
-=head3 Arguments: (arrayref)
+=over 4
+
+=item Value: \@columns
+
+=back
 
 A arrayref of columns to group by. Can include columns of joined tables.
 
@@ -1273,6 +1582,12 @@ A arrayref of columns to group by. Can include columns of joined tables.
 
 =head2 distinct
 
+=over 4
+
+=item Value: (0 | 1)
+
+=back
+
 Set to 1 to group by all columns.
 
 =head2 cache