=over 4
-=item Arguments: ($source, \%$attrs)
+=item Arguments: $source, \%$attrs
+
+=item Return Value: $rs
=back
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 {
=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);>.
+call it as C<search(undef, \%attrs)>.
# "SELECT name, artistid FROM $artist_table"
my @all_artists = $schema->resultset('Artist')->search(undef, {
sub search {
my $self = shift;
-
- my $rs;
- if( @_ ) {
- my $attrs = { %{$self->{attrs}} };
- my $having = delete $attrs->{having};
- $attrs = { %$attrs, %{ pop(@_) } } if @_ > 1 and ref $_[$#_] eq 'HASH';
-
- my $where = (@_
- ? ((@_ == 1 || ref $_[0] eq "HASH")
- ? shift
- : ((@_ % 2)
- ? $self->throw_exception(
- "Odd number of arguments to search")
- : {@_}))
- : undef());
- if (defined $where) {
- $attrs->{where} = (defined $attrs->{where}
- ? { '-and' =>
- [ map { ref $_ eq 'ARRAY' ? [ -or => $_ ] : $_ }
- $where, $attrs->{where} ] }
- : $where);
- }
-
- if (defined $having) {
- $attrs->{having} = (defined $attrs->{having}
- ? { '-and' =>
- [ map { ref $_ eq 'ARRAY' ? [ -or => $_ ] : $_ }
- $having, $attrs->{having} ] }
- : $having);
- }
+ my $attrs = { %{$self->{attrs}} };
+ my $having = delete $attrs->{having};
+ $attrs = { %$attrs, %{ pop(@_) } } if @_ > 1 and ref $_[$#_] eq 'HASH';
+
+ my $where = (@_
+ ? ((@_ == 1 || ref $_[0] eq "HASH")
+ ? shift
+ : ((@_ % 2)
+ ? $self->throw_exception(
+ "Odd number of arguments to search")
+ : {@_}))
+ : undef());
+ if (defined $where) {
+ $attrs->{where} = (defined $attrs->{where}
+ ? { '-and' =>
+ [ map { ref $_ eq 'ARRAY' ? [ -or => $_ ] : $_ }
+ $where, $attrs->{where} ] }
+ : $where);
+ }
- $rs = (ref $self)->new($self->result_source, $attrs);
+ if (defined $having) {
+ $attrs->{having} = (defined $attrs->{having}
+ ? { '-and' =>
+ [ map { ref $_ eq 'ARRAY' ? [ -or => $_ ] : $_ }
+ $having, $attrs->{having} ] }
+ : $having);
}
- else {
- $rs = $self;
- $rs->reset;
+
+ my $rs = (ref $self)->new($self->result_source, $attrs);
+
+ unless (@_) { # no search, effectively just a clone
+ my $rows = $self->get_cache;
+ if ($rows) {
+ $rs->set_cache($rows);
+ }
}
+
return (wantarray ? $rs->all : $rs);
}
=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
=over 4
-=item Arguments: (@colvalues) | (\%cols, \%attrs?)
+=item Arguments: @values | \%cols, \%attrs?
+
+=item Return Value: $row_object
=back
return keys %{$rs->{collapse}} ? $rs->next : $rs->single;
} else {
return keys %{$self->{collapse}} ?
- $self->search($query)->next :
- $self->single($query);
+ $self->search($query)->next :
+ $self->single($query);
}
}
=head2 search_related
- $rs->search_related('relname', $cond?, $attrs?);
+=over 4
+
+=item Arguments: $cond, \%attrs?
+
+=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 for matching
-records.
+Searches the specified relationship, optionally specifying a condition and
+attributes for matching records. See L</ATTRIBUTES> for more information.
=cut
=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
=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
if ($where) {
if (defined $attrs->{where}) {
$attrs->{where} = {
- '-and' =>
+ '-and' =>
[ map { ref $_ eq 'ARRAY' ? [ -or => $_ ] : $_ }
$where, delete $attrs->{where} ]
};
=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%'});
+
+Performs a search, but uses 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>.
=over 4
-=item Arguments: ($first, $last)
+=item Arguments: $first, $last
+
+=item Return Value: $resultset (scalar context), @row_objs (list context)
=back
-Returns a subset of elements from the resultset.
+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
sub slice {
my ($self, $min, $max) = @_;
- my $attrs = { %{ $self->{attrs} || {} } };
- $attrs->{offset} ||= 0;
+ my $attrs = {}; # = { %{ $self->{attrs} || {} } };
+ $attrs->{offset} = $self->{attrs}{offset} || 0;
$attrs->{offset} += $min;
$attrs->{rows} = ($max ? ($max - $min + 1) : 1);
- my $slice = (ref $self)->new($self->result_source, $attrs);
- return (wantarray ? $slice->all : $slice);
+ return $self->search(undef(), $attrs);
+ #my $slice = (ref $self)->new($self->result_source, $attrs);
+ #return (wantarray ? $slice->all : $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:
print $cd->title;
}
+Note that you need to store the resultset object, and call C<next> on it.
+Calling C<< resultset('Table')->next >> repeatedly will always return the
+first record from the resultset.
+
=cut
sub next {
my ($self) = @_;
- if (@{$self->{all_cache} || []}) {
+ if (my $cache = $self->get_cache) {
$self->{all_cache_position} ||= 0;
- return $self->{all_cache}->[$self->{all_cache_position}++];
+ return $cache->[$self->{all_cache_position}++];
}
if ($self->{attrs}{cache}) {
$self->{all_cache_position} = 1;
return ($self->all)[0];
}
my @row = (exists $self->{stashed_row} ?
- @{delete $self->{stashed_row}} :
- $self->cursor->next
+ @{delete $self->{stashed_row}} :
+ $self->cursor->next
);
# warn Dumper(\@row); use Data::Dumper;
return unless (@row);
my @collapse;
if (defined $prefix) {
@collapse = map {
- m/^\Q${prefix}.\E(.+)$/ ? ($1) : ()
+ m/^\Q${prefix}.\E(.+)$/ ? ($1) : ()
} keys %{$self->{collapse}}
} else {
@collapse = keys %{$self->{collapse}};
my (@final, @raw);
while ( !(grep {
!defined($tree->[0]->{$_}) ||
- $co_check{$_} ne $tree->[0]->{$_}
+ $co_check{$_} ne $tree->[0]->{$_}
} @co_key) ) {
push(@final, $tree);
last unless (@raw = $self->cursor->next);
$row = $self->{stashed_row} = \@raw;
$tree = $self->_collapse_result($as, $row, $c_prefix);
- #warn Data::Dumper::Dumper($tree, $row);
}
- @$target = @final;
+ @$target = (@final ? @final : [ {}, {} ]);
+ # single empty result to indicate an empty prefetched has_many
}
return $info;
=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.
sub count {
my $self = shift;
return $self->search(@_)->count if @_ and defined $_[0];
- return scalar @{ $self->get_cache } if @{ $self->get_cache };
+ return scalar @{ $self->get_cache } if $self->get_cache;
my $count = $self->_count;
return 0 unless $count;
@distinct = ($column);
last;
}
- }
+ }
}
$select = { count => { distinct => \@distinct } };
=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
=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
sub all {
my ($self) = @_;
- return @{ $self->get_cache } if @{ $self->get_cache };
+ return @{ $self->get_cache } if $self->get_cache;
my @obj;
=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
=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 returns anything).
=cut
return $_[0]->reset->next;
}
+# _cond_for_update_delete
+#
+# update/delete require the condition to be modified to handle
+# the differing SQL syntax available. This transforms the $self->{cond}
+# appropriately, returning the new condition.
+
+sub _cond_for_update_delete {
+ my ($self) = @_;
+ my $cond = {};
+
+ if (!ref($self->{cond})) {
+ # No-op. No condition, we're updating/deleting everything
+ }
+ elsif (ref $self->{cond} eq 'ARRAY') {
+ $cond = [
+ map {
+ my %hash;
+ foreach my $key (keys %{$_}) {
+ $key =~ /([^.]+)$/;
+ $hash{$1} = $_->{$key};
+ }
+ \%hash;
+ } @{$self->{cond}}
+ ];
+ }
+ elsif (ref $self->{cond} eq 'HASH') {
+ if ((keys %{$self->{cond}})[0] eq '-and') {
+ $cond->{-and} = [];
+
+ my @cond = @{$self->{cond}{-and}};
+ for (my $i = 0; $i < @cond - 1; $i++) {
+ my $entry = $cond[$i];
+
+ my %hash;
+ if (ref $entry eq 'HASH') {
+ foreach my $key (keys %{$entry}) {
+ $key =~ /([^.]+)$/;
+ $hash{$1} = $entry->{$key};
+ }
+ }
+ else {
+ $entry =~ /([^.]+)$/;
+ $hash{$entry} = $cond[++$i];
+ }
+
+ push @{$cond->{-and}}, \%hash;
+ }
+ }
+ else {
+ foreach my $key (keys %{$self->{cond}}) {
+ $key =~ /([^.]+)$/;
+ $cond->{$1} = $self->{cond}{$key};
+ }
+ }
+ }
+ else {
+ $self->throw_exception(
+ "Can't update/delete on resultset with condition unless hash or array"
+ );
+ }
+
+ return $cond;
+}
+
+
=head2 update
=over 4
-=item Arguments: (\%values)
+=item Arguments: \%values
+
+=item Return Value: $storage_rv
=back
-Sets the specified columns in the resultset to the supplied values.
+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
my ($self, $values) = @_;
$self->throw_exception("Values for update must be a hash")
unless ref $values eq 'HASH';
+
+ my $cond = $self->_cond_for_update_delete;
+
return $self->result_source->storage->update(
- $self->result_source->from, $values, $self->{cond}
+ $self->result_source->from, $values, $cond
);
}
=over 4
-=item Arguments: (\%values)
+=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.
+Fetches all objects and updates them one at a time. Note that C<update_all>
+will run DBIC cascade triggers, while L</update> will not.
=cut
=head2 delete
-Deletes the contents of the resultset from its result source.
-
-=cut
+=over 4
-sub delete {
- my ($self) = @_;
- my $del = {};
+=item Arguments: none
- if (!ref($self->{cond})) {
+=item Return Value: 1
- # No-op. No condition, we're deleting everything
+=back
- } elsif (ref $self->{cond} eq 'ARRAY') {
+Deletes the contents of the resultset from its result source. Note that this
+will not run DBIC cascade triggers. See L</delete_all> if you need triggers
+to run.
- $del = [ map { my %hash;
- foreach my $key (keys %{$_}) {
- $key =~ /([^.]+)$/;
- $hash{$1} = $_->{$key};
- }; \%hash; } @{$self->{cond}} ];
+=cut
- } elsif (ref $self->{cond} eq 'HASH') {
+sub delete {
+ my ($self) = @_;
+ my $del = {};
- if ((keys %{$self->{cond}})[0] eq '-and') {
+ my $cond = $self->_cond_for_update_delete;
- $del->{-and} = [ map { my %hash;
- foreach my $key (keys %{$_}) {
- $key =~ /([^.]+)$/;
- $hash{$1} = $_->{$key};
- }; \%hash; } @{$self->{cond}{-and}} ];
+ $self->result_source->storage->delete($self->result_source->from, $cond);
+ return 1;
+}
- } else {
+=head2 delete_all
- foreach my $key (keys %{$self->{cond}}) {
- $key =~ /([^.]+)$/;
- $del->{$1} = $self->{cond}{$key};
- }
- }
+=over 4
- } else {
- $self->throw_exception(
- "Can't delete on resultset with condition unless hash or array"
- );
- }
+=item Arguments: none
- $self->result_source->storage->delete($self->result_source->from, $del);
- return 1;
-}
+=item Return Value: 1
-=head2 delete_all
+=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.
+Fetches all objects and deletes them one at a time. Note that C<delete_all>
+will run DBIC cascade triggers, while L</delete> will not.
=cut
=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
=over 4
-=item Arguments: ($page_num)
+=item Arguments: $page_number
+
+=item Return Value: $rs
=back
-Returns a new resultset for the specified page.
+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 (10 by default).
=cut
=over 4
-=item Arguments: (\%vals)
+=item Arguments: \%vals
+
+=item Return Value: $object
=back
-Creates a result in the resultset's result class.
+Creates an object in the resultset's result class and returns it.
=cut
=over 4
-=item Arguments: (\%vals)
+=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 >>.
=over 4
-=item Arguments: (\%vals, \%attrs?)
+=item Arguments: \%vals, \%attrs?
+
+=item Return Value: $object
=back
=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
-found, update it with the other given column values. Otherwise, create a new
+First, searches for an existing row matching one of the unique constraints
+(including the primary key) on the source of this resultset. If a row is
+found, updates it with the other given column values. Otherwise, creates a new
row.
Takes an optional C<key> attribute to search on a specific unique constraint.
If no C<key> is specified, it searches on all unique constraints defined on the
source, including the primary key.
-If the C<key> is specified as C<primary>, search only on the primary key.
+If the C<key> is specified as C<primary>, it searches only on the primary key.
See also L</find> and L</find_or_create>.
if (@unique_hashes) {
my $row = $self->single(\@unique_hashes);
if (defined $row) {
- $row->set_columns($hash);
- $row->update;
+ $row->update($hash);
return $row;
}
}
=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
sub get_cache {
- shift->{all_cache} || [];
+ shift->{all_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
sub set_cache {
my ( $self, $data ) = @_;
$self->throw_exception("set_cache requires an arrayref")
- if ref $data ne 'ARRAY';
- my $result_class = $self->result_class;
- foreach( @$data ) {
- $self->throw_exception(
- "cannot cache object of type '$_', expected '$result_class'"
- ) if ref $_ ne $result_class;
- }
+ if defined($data) && (ref $data ne 'ARRAY');
$self->{all_cache} = $data;
}
=head2 clear_cache
+=over 4
+
+=item Arguments: none
+
+=item Return Value: []
+
+=back
+
Clears the cache for the resultset.
=cut
sub clear_cache {
- shift->set_cache([]);
+ shift->set_cache(undef);
}
=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');
=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'";
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
$self->result_source->schema->throw_exception(@_);
}
-=head1 ATTRIBUTES
+# XXX: FIXME: Attributes docs need clearing up
-XXX: FIXME: Attributes docs need clearing up
+=head1 ATTRIBUTES
The resultset takes various attributes that modify its behavior. Here's an
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'.
=over 4
-=item Arguments: (\@columns)
+=item Value: \@columns
=back
=over 4
-=item Arguments: (\@columns)
+=item Value: \@columns
=back
=over 4
-=item Arguments: (\@columns)
+=item Value: \@select_columns
=back
=over 4
-=item Arguments: (\@names)
+=item Value: \@inflation_names
=back
=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:
=over 4
-=item Arguments: (\@relationships)
+=item Value: ($rel_name | \@rel_names | \%rel_names)
=back
-Contains one or more relationships that should be fetched along with the main
+Contains one or more relationships that should be fetched along with the main
query (when they are accessed afterwards they will have already been
"prefetched"). This is useful for when you know you will need the related
objects, because it saves at least one query:
=over 4
-=item Arguments: (\@array)
+=item Value: \@from_clause
=back
In simple terms, C<from> works as follows:
[
- { <alias> => <table>, -join-type => 'inner|left|right' }
+ { <alias> => <table>, -join_type => 'inner|left|right' }
[] # nested JOIN (optional)
- { <table.column> = <foreign_table.foreign_key> }
+ { <table.column> => <foreign_table.foreign_key> }
]
JOIN
from => [
{ child => 'person' },
[
- { father => 'person', -join-type => 'inner' },
+ { father => 'person', -join_type => 'inner' },
{ 'father.id' => 'child.father_id' }
],
]
=over 4
-=item Arguments: ($page)
+=item Value: $page
=back
-For a paged resultset, specifies which page to retrieve. Leave unset
-for an unpaged resultset.
+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
=over 4
-=item Arguments: ($rows)
+=item Value: $rows
=back
-For a paged resultset, specifies how many rows are in each page:
-
- rows => 10
-
-Can also be used to simulate an SQL C<LIMIT>.
+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
=over 4
-=item Arguments: (\@columns)
+=item Value: \@columns
=back
group_by => [qw/ column1 column2 ... /]
+=head2 having
+
+=over 4
+
+=item Value: $condition
+
+=back
+
+HAVING is a select statement attribute that is applied between GROUP BY and
+ORDER BY. It is applied to the after the grouping calculations have been
+done.
+
+ having => { 'count(employee)' => { '>=', 100 } }
+
=head2 distinct
+=over 4
+
+=item Value: (0 | 1)
+
+=back
+
Set to 1 to group by all columns.
=head2 cache
... do stuff ...
}
- $rs->first; # without cache, this would issue a query
+ $rs->first; # without cache, this would issue a query
By default, searches are not cached.
projects / dbsrgits/DBIx-Class.git / blobdiff