fallback => 1;
use Data::Page;
use Storable;
+use Scalar::Util qw/weaken/;
use base qw/DBIx::Class/;
__PACKAGE__->load_components(qw/AccessorGroup/);
=head1 SYNOPSIS
my $rs = $schema->resultset('User')->search(registered => 1);
- my @rows = $schema->resultset('Foo')->search(bar => 'baz');
+ my @rows = $schema->resultset('CD')->search(year => 2005);
=head1 DESCRIPTION
=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 L</ATTRIBUTES>
-below). Does not perform any queries -- these are executed as needed by the
-other methods.
+L<DBIx::Class::ResultSourceProxy::Table>) and an attribute hash (see
+L</ATTRIBUTES> below). Does not perform any queries -- these are
+executed as needed by the other methods.
Generally you won't need to construct a resultset manually. You'll
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 {
return $class->new_result(@_) if ref $class;
my ($source, $attrs) = @_;
- #use Data::Dumper; warn Dumper($attrs);
+ weaken $source;
$attrs = Storable::dclone($attrs || {}); # { %{ $attrs || {} } };
+ #use Data::Dumper; warn Dumper($attrs);
my $alias = ($attrs->{alias} ||= 'me');
$attrs->{columns} ||= delete $attrs->{cols} if $attrs->{cols};
delete $attrs->{as} if $attrs->{columns};
$attrs->{columns} ||= [ $source->columns ] unless $attrs->{select};
- $attrs->{select} = [ map { m/\./ ? $_ : "${alias}.$_" } @{delete $attrs->{columns}} ]
- if $attrs->{columns};
- $attrs->{as} ||= [ map { m/^\Q$alias.\E(.+)$/ ? $1 : $_ } @{$attrs->{select}} ];
+ $attrs->{select} = [
+ map { m/\./ ? $_ : "${alias}.$_" } @{delete $attrs->{columns}}
+ ] if $attrs->{columns};
+ $attrs->{as} ||= [
+ map { m/^\Q$alias.\E(.+)$/ ? $1 : $_ } @{$attrs->{select}}
+ ];
if (my $include = delete $attrs->{include_columns}) {
push(@{$attrs->{select}}, @$include);
push(@{$attrs->{as}}, map { m/([^.]+)$/; $1; } @$include);
$seen{$j} = 1;
}
}
- push(@{$attrs->{from}}, $source->resolve_join($join, $attrs->{alias}, $attrs->{seen_join}));
+ push(@{$attrs->{from}}, $source->resolve_join(
+ $join, $attrs->{alias}, $attrs->{seen_join})
+ );
}
$attrs->{group_by} ||= $attrs->{select} if delete $attrs->{distinct};
- $attrs->{order_by} = [ $attrs->{order_by} ] if $attrs->{order_by} and !ref($attrs->{order_by});
+ $attrs->{order_by} = [ $attrs->{order_by} ] if
+ $attrs->{order_by} and !ref($attrs->{order_by});
$attrs->{order_by} ||= [];
my $collapse = $attrs->{collapse} || {};
=head2 search
- my @obj = $rs->search({ foo => 3 }); # "... WHERE foo = 3"
- my $new_rs = $rs->search({ foo => 3 });
+=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);>.
- # "SELECT foo, bar FROM $class_table"
- my @all = $class->search(undef, { columns => [qw/foo bar/] });
+ # "SELECT name, artistid FROM $artist_table"
+ my @all_artists = $schema->resultset('Artist')->search(undef, {
+ columns => [qw/name artistid/],
+ });
=cut
=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
=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:
my @cols = $self->result_source->primary_columns;
if (exists $attrs->{key}) {
my %uniq = $self->result_source->unique_constraints;
- $self->throw_exception( "Unknown key $attrs->{key} on $self->name" )
- unless exists $uniq{$attrs->{key}};
+ $self->throw_exception(
+ "Unknown key $attrs->{key} on '" . $self->result_source->name . "'"
+ ) unless exists $uniq{$attrs->{key}};
@cols = @{ $uniq{$attrs->{key}} };
}
#use Data::Dumper; warn Dumper($attrs, @vals, @cols);
- $self->throw_exception( "Can't find unless a primary key or unique constraint is defined" )
- unless @cols;
+ $self->throw_exception(
+ "Can't find unless a primary key or unique constraint is defined"
+ ) unless @cols;
my $query;
if (ref $vals[0] eq 'HASH') {
my $rs = $self->search($query,$attrs);
return keys %{$rs->{collapse}} ? $rs->next : $rs->single;
} else {
- return keys %{$self->{collapse}} ? $self->search($query)->next : $self->single($query);
+ return keys %{$self->{collapse}} ?
+ $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.
+Search the specified relationship, optionally specify 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
=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>.
=head2 slice
-=head3 Arguments: ($first, $last)
+=over 4
-Returns a subset of elements from the resultset.
+=item Arguments: $first, $last
+
+=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
=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:
$self->{all_cache_position} = 1;
return ($self->all)[0];
}
- my @row = (exists $self->{stashed_row}
- ? @{delete $self->{stashed_row}}
- : $self->cursor->next);
+ my @row = (exists $self->{stashed_row} ?
+ @{delete $self->{stashed_row}} :
+ $self->cursor->next
+ );
# warn Dumper(\@row); use Data::Dumper;
return unless (@row);
return $self->_construct_object(@row);
}
}
- my @collapse = (defined($prefix)
- ? (map { (m/^\Q${prefix}.\E(.+)$/ ? ($1) : ()); }
- keys %{$self->{collapse}})
- : keys %{$self->{collapse}});
+ my @collapse;
+ if (defined $prefix) {
+ @collapse = map {
+ m/^\Q${prefix}.\E(.+)$/ ? ($1) : ()
+ } keys %{$self->{collapse}}
+ } else {
+ @collapse = keys %{$self->{collapse}};
+ };
+
if (@collapse) {
my ($c) = sort { length $a <=> length $b } @collapse;
my $target = $info;
my $tree = $self->_collapse_result($as, $row, $c_prefix);
my (@final, @raw);
while ( !(grep {
- !defined($tree->[0]->{$_})
- || $co_check{$_} ne $tree->[0]->{$_}
+ !defined($tree->[0]->{$_}) ||
+ $co_check{$_} ne $tree->[0]->{$_}
} @co_key) ) {
push(@final, $tree);
last unless (@raw = $self->cursor->next);
=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];
- unless (defined $self->{count}) {
- return scalar @{ $self->get_cache } if @{ $self->get_cache };
- my $select = { count => '*' };
- my $attrs = { %{ $self->{attrs} } };
- if (my $group_by = delete $attrs->{group_by}) {
- delete $attrs->{having};
- my @distinct = (ref $group_by ? @$group_by : ($group_by));
- # todo: try CONCAT for multi-column pk
- my @pk = $self->result_source->primary_columns;
- if (@pk == 1) {
- foreach my $column (@distinct) {
- if ($column =~ qr/^(?:\Q$attrs->{alias}.\E)?$pk[0]$/) {
- @distinct = ($column);
- last;
- }
- }
- }
+ return scalar @{ $self->get_cache } if @{ $self->get_cache };
- $select = { count => { distinct => \@distinct } };
- #use Data::Dumper; die Dumper $select;
- }
+ my $count = $self->_count;
+ return 0 unless $count;
- $attrs->{select} = $select;
- $attrs->{as} = [qw/count/];
- # offset, order by and page are not needed to count. record_filter is cdbi
- delete $attrs->{$_} for qw/rows offset order_by page pager record_filter/;
-
- ($self->{count}) = (ref $self)->new($self->result_source, $attrs)->cursor->next;
- }
- return 0 unless $self->{count};
- my $count = $self->{count};
$count -= $self->{attrs}{offset} if $self->{attrs}{offset};
$count = $self->{attrs}{rows} if
$self->{attrs}{rows} and $self->{attrs}{rows} < $count;
return $count;
}
+sub _count { # Separated out so pager can get the full count
+ my $self = shift;
+ my $select = { count => '*' };
+ my $attrs = { %{ $self->{attrs} } };
+ if (my $group_by = delete $attrs->{group_by}) {
+ delete $attrs->{having};
+ my @distinct = (ref $group_by ? @$group_by : ($group_by));
+ # todo: try CONCAT for multi-column pk
+ my @pk = $self->result_source->primary_columns;
+ if (@pk == 1) {
+ foreach my $column (@distinct) {
+ if ($column =~ qr/^(?:\Q$attrs->{alias}.\E)?$pk[0]$/) {
+ @distinct = ($column);
+ last;
+ }
+ }
+ }
+
+ $select = { count => { distinct => \@distinct } };
+ #use Data::Dumper; die Dumper $select;
+ }
+
+ $attrs->{select} = $select;
+ $attrs->{as} = [qw/count/];
+
+ # offset, order by and page are not needed to count. record_filter is cdbi
+ delete $attrs->{$_} for qw/rows offset order_by page pager record_filter/;
+
+ my ($count) = (ref $self)->new($self->result_source, $attrs)->cursor->next;
+ return $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
=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
# If we're collapsing has_many prefetches it probably makes
# very little difference, and this is cleaner than hacking
# _construct_object to survive the approach
- my @row;
$self->cursor->reset;
- while (@row = $self->cursor->next) {
+ my @row = $self->cursor->next;
+ while (@row) {
push(@obj, $self->_construct_object(@row));
+ @row = (exists $self->{stashed_row}
+ ? @{delete $self->{stashed_row}}
+ : $self->cursor->next);
}
} else {
@obj = map { $self->_construct_object(@$_) } $self->cursor->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
=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
=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
sub update {
my ($self, $values) = @_;
- $self->throw_exception("Values for update must be a hash") unless ref $values eq 'HASH';
+ $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.
sub update_all {
my ($self, $values) = @_;
- $self->throw_exception("Values for update must be a hash") unless ref $values eq 'HASH';
+ $self->throw_exception("Values for update must be a hash")
+ unless ref $values eq 'HASH';
foreach my $obj ($self->all) {
$obj->set_columns($values)->update;
}
=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
sub delete {
my ($self) = @_;
my $del = {};
- $self->throw_exception("Can't delete on resultset with condition unless hash or array")
- unless (ref($self->{cond}) eq 'HASH' || ref($self->{cond}) eq 'ARRAY');
- if (ref $self->{cond} eq 'ARRAY') {
+
+ if (!ref($self->{cond})) {
+
+ # No-op. No condition, we're deleting everything
+
+ } elsif (ref $self->{cond} eq 'ARRAY') {
+
$del = [ map { my %hash;
foreach my $key (keys %{$_}) {
$key =~ /([^.]+)$/;
$hash{$1} = $_->{$key};
}; \%hash; } @{$self->{cond}} ];
- } elsif ((keys %{$self->{cond}})[0] eq '-and') {
- $del->{-and} = [ map { my %hash;
- foreach my $key (keys %{$_}) {
+
+ } elsif (ref $self->{cond} eq 'HASH') {
+
+ if ((keys %{$self->{cond}})[0] eq '-and') {
+
+ $del->{-and} = [ map { my %hash;
+ foreach my $key (keys %{$_}) {
+ $key =~ /([^.]+)$/;
+ $hash{$1} = $_->{$key};
+ }; \%hash; } @{$self->{cond}{-and}} ];
+
+ } else {
+
+ foreach my $key (keys %{$self->{cond}}) {
$key =~ /([^.]+)$/;
- $hash{$1} = $_->{$key};
- }; \%hash; } @{$self->{cond}{-and}} ];
- } else {
- foreach my $key (keys %{$self->{cond}}) {
- $key =~ /([^.]+)$/;
- $del->{$1} = $self->{cond}{$key};
+ $del->{$1} = $self->{cond}{$key};
+ }
}
+
+ } else {
+ $self->throw_exception(
+ "Can't delete on resultset with condition unless hash or array"
+ );
}
+
$self->result_source->storage->delete($self->result_source->from, $del);
return 1;
}
=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.
=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
sub pager {
my ($self) = @_;
my $attrs = $self->{attrs};
- $self->throw_exception("Can't create pager for non-paged rs") unless $self->{page};
+ $self->throw_exception("Can't create pager for non-paged rs")
+ unless $self->{page};
$attrs->{rows} ||= 10;
- $self->count;
return $self->{pager} ||= Data::Page->new(
- $self->{count}, $attrs->{rows}, $self->{page});
+ $self->_count, $attrs->{rows}, $self->{page});
}
=head2 page
-=head3 Arguments: ($page_num)
+=over 4
+
+=item Arguments: $page_number
-Returns a new resultset for the specified page.
+=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
=head2 new_result
-=head3 Arguments: (\%vals)
+=over 4
+
+=item Arguments: \%vals
+
+=item Return Value: $object
-Creates a result in the resultset's result class.
+=back
+
+Creates an object in the resultset's result class and returns it.
=cut
my ($self, $values) = @_;
$self->throw_exception( "new_result needs a hash" )
unless (ref $values eq 'HASH');
- $self->throw_exception( "Can't abstract implicit construct, condition not a hash" )
- if ($self->{cond} && !(ref $self->{cond} eq 'HASH'));
+ $self->throw_exception(
+ "Can't abstract implicit construct, condition not a hash"
+ ) if ($self->{cond} && !(ref $self->{cond} eq 'HASH'));
my %new = %$values;
my $alias = $self->{attrs}{alias};
foreach my $key (keys %{$self->{cond}||{}}) {
=head2 create
-=head3 Arguments: (\%vals)
+=over 4
+
+=item Arguments: \%vals
+
+=item Return Value: $object
-Inserts a record into the resultset and returns the object.
+=back
+
+Inserts a record into the resultset and returns the object representing it.
Effectively a shortcut for C<< ->new_result(\%vals)->insert >>.
sub create {
my ($self, $attrs) = @_;
- $self->throw_exception( "create needs a hashref" ) unless ref $attrs eq 'HASH';
+ $self->throw_exception( "create needs a hashref" )
+ unless ref $attrs eq 'HASH';
return $self->new_result($attrs)->insert;
}
=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, ... });
=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
=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
=head2 set_cache
-Sets the contents of the cache for the resultset. Expects an arrayref of objects of the same class as those produced by the resultset.
+=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. 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
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;
+ $self->throw_exception(
+ "cannot cache object of type '$_', expected '$result_class'"
+ ) if ref $_ ne $result_class;
}
$self->{all_cache} = $data;
}
=head2 clear_cache
+=over 4
+
+=item Arguments: none
+
+=item Return Value: []
+
+=back
+
Clears the cache for the resultset.
=cut
=head2 related_resultset
+=over 4
+
+=item Arguments: $relationship_name
+
+=item Return Value: $resultset
+
+=back
+
Returns a related resultset for the supplied relationship name.
- $rs = $rs->related_resultset('foo');
+ $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(@_);
}
+# XXX: FIXME: Attributes docs need clearing up
+
=head1 ATTRIBUTES
The resultset takes various attributes that modify its behavior. Here's an
=head2 order_by
-Which column(s) to order the results by. This is currently passed through
-directly to SQL, so you can give e.g. C<foo DESC> for a descending order.
+=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>
=head2 include_columns
-=head3 Arguments: (arrayref)
+=over 4
+
+=item Value: \@columns
+
+=back
Shortcut to include additional columns in the returned results - for example
- { include_columns => ['foo.name'], join => ['foo'] }
+ $schema->resultset('CD')->search(undef, {
+ include_columns => ['artist.name'],
+ join => ['artist']
+ });
-would add a 'name' column to the information passed to object inflation
+would return all CDs and include a 'name' column to the information
+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
names:
- $rs = $schema->resultset('Foo')->search(
- undef,
- {
- select => [
- 'column_name',
- { count => 'column_to_count' },
- { sum => 'column_to_sum' }
- ]
- }
- );
+ $rs = $schema->resultset('Employee')->search(undef, {
+ select => [
+ 'name',
+ { count => 'employeeid' },
+ { sum => 'salary' }
+ ]
+ });
When you use function/stored procedure names and do not supply an C<as>
attribute, the column names returned are storage-dependent. E.g. MySQL would
-return a column named C<count(column_to_count)> in the above example.
+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
procedure names:
- $rs = $schema->resultset('Foo')->search(
- undef,
- {
- select => [
- 'column1',
- { count => 'column2' }
- ],
- as => [qw/ column1 column2_count /]
- }
- );
+ $rs = $schema->resultset('Employee')->search(undef, {
+ select => [
+ 'name',
+ { count => 'employeeid' }
+ ],
+ as => ['name', 'employee_count'],
+ });
- my $foo = $rs->first(); # get the first Foo
+ my $employee = $rs->first(); # get the first Employee
If the object against which the search is performed already has an accessor
matching a column name specified in C<as>, the value can be retrieved using
the accessor as normal:
- my $column1 = $foo->column1();
+ my $name = $employee->name();
If on the other hand an accessor does not exist in the object, you need to
use C<get_column> instead:
- my $column2_count = $foo->get_column('column2_count');
+ my $employee_count = $employee->get_column('employee_count');
You can create your own accessors if required - see
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:
If the same join is supplied twice, it will be aliased to <rel>_2 (and
similarly for a third time). For e.g.
- my $rs = $schema->resultset('Artist')->search(
- { 'cds.title' => 'Foo',
- 'cds_2.title' => 'Bar' },
- { join => [ qw/cds cds/ ] });
+ my $rs = $schema->resultset('Artist')->search({
+ 'cds.title' => 'Down to Earth',
+ 'cds_2.title' => 'Popular',
+ }, {
+ join => [ qw/cds cds/ ],
+ });
-will return a set of all artists that have both a cd with title Foo and a cd
-with title Bar.
+will return a set of all artists that have both a cd with title 'Down
+to Earth' and a cd with title 'Popular'.
If you want to fetch related objects from other tables as well, see C<prefetch>
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
=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>
[
{ <alias> => <table>, -join-type => 'inner|left|right' }
[] # nested JOIN (optional)
- { <table.column> = <foreign_table.foreign_key> }
+ { <table.column> => <foreign_table.foreign_key> }
]
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.
=head2 distinct
+=over 4
+
+=item Value: (0 | 1)
+
+=back
+
Set to 1 to group by all columns.
+=head2 cache
+
+Set to 1 to cache search results. This prevents extra SQL queries if you
+revisit rows in your ResultSet:
+
+ my $resultset = $schema->resultset('Artist')->search( undef, { cache => 1 } );
+
+ while( my $artist = $resultset->next ) {
+ ... do stuff ...
+ }
+
+ $rs->first; # without cache, this would issue a query
+
+By default, searches are not cached.
+
For more examples of using these attributes, see
L<DBIx::Class::Manual::Cookbook>.