=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
=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 {
$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);>.
+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
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
=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
-Search the specified relationship. Optionally specify a condition for matching
-records.
+=item Arguments: $cond, \%attrs?
+
+=item Return Value: $new_resultset
+
+=back
+
+ $new_rs = $cd_rs->search_related('artist', {
+ name => 'Emo-R-Us',
+ });
+
+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>.
=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
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);
+ 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);
$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];
- 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
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
-=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';
+
+ 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
+ );
}
=head2 update_all
-=head3 Arguments: (\%values)
+=over 4
-Fetches all objects and updates them one at a time. Note that C<update_all>
-will run cascade triggers while L</update> will not.
+=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 DBIC cascade triggers, while L</update> will not.
=cut
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 DBIC 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') {
- $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 %{$_}) {
- $key =~ /([^.]+)$/;
- $hash{$1} = $_->{$key};
- }; \%hash; } @{$self->{cond}{-and}} ];
- } else {
- foreach my $key (keys %{$self->{cond}}) {
- $key =~ /([^.]+)$/;
- $del->{$1} = $self->{cond}{$key};
- }
- }
- $self->result_source->storage->delete($self->result_source->from, $del);
+
+ my $cond = $self->_cond_for_update_delete;
+
+ $self->result_source->storage->delete($self->result_source->from, $cond);
return 1;
}
=head2 delete_all
-Fetches all objects and deletes them one at a time. Note that C<delete_all>
-will run cascade triggers while L</delete> will not.
+=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 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
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 (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
+
+=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 >>.
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
-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
+=item Arguments: \%col_values, { key => $unique_constraint }?
+
+=item Return Value: $object
+
+=back
+
+ $class->update_or_create({ col => $val, ... });
+
+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
-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
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.
- $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
-Contains one or more relationships that should be fetched along with the main
+=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
"prefetched"). This is useful for when you know you will need the related
objects, because it saves at least one query:
=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>
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' }
],
]
=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
+
+=item Value: $rows
- rows => 10
+=back
-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
-=head3 Arguments: (arrayref)
+=over 4
+
+=item Value: \@columns
+
+=back
A arrayref of columns to group by. Can include columns of joined tables.
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
+
+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>.
projects / dbsrgits/DBIx-Class.git / blobdiff