ResultSet. The new one will contain all the conditions of the
original, plus any new conditions added in the C<search> call.
-A ResultSet is also an iterator. L</next> is used to return all the
-L<DBIx::Class::Row>s the ResultSet represents.
+A ResultSet also incorporates an implicit iterator. L</next> and L</reset>
+can be used to walk through all the L<DBIx::Class::Row>s the ResultSet
+represents.
The query that the ResultSet represents is B<only> executed against
the database when these methods are called:
-
-=over
-
-=item L</find>
-
-=item L</next>
-
-=item L</all>
-
-=item L</count>
-
-=item L</single>
-
-=item L</first>
-
-=back
+L</find> L</next> L</all> L</first> L</single> L</count>
=head1 EXAMPLES
sub cursor {
my ($self) = @_;
- my $attrs = { %{$self->_resolved_attrs} };
+ my $attrs = $self->_resolved_attrs_copy;
return $self->{cursor}
||= $self->result_source->storage->select($attrs->{from}, $attrs->{select},
$attrs->{where},$attrs);
$self->throw_exception('single() only takes search conditions, no attributes. You want ->search( $cond, $attrs )->single()');
}
- my $attrs = { %{$self->_resolved_attrs} };
+ my $attrs = $self->_resolved_attrs_copy;
if ($where) {
if (defined $attrs->{where}) {
$attrs->{where} = {
sub search_like {
my $class = shift;
- carp join ("\n",
- 'search_like() is deprecated and will be removed in 0.09.',
- 'Instead use ->search({ x => { -like => "y%" } })',
- '(note the outer pair of {}s - they are important!)'
+ carp (
+ 'search_like() is deprecated and will be removed in DBIC version 0.09.'
+ .' Instead use ->search({ x => { -like => "y%" } })'
+ .' (note the outer pair of {}s - they are important!)'
);
my $attrs = (@_ > 1 && ref $_[$#_] eq 'HASH' ? pop(@_) : {});
my $query = ref $_[0] eq 'HASH' ? { %{shift()} }: {@_};
=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.
+with to find the number of elements. Passing arguments is equivalent to
+C<< $rs->search ($cond, \%attrs)->count >>
=cut
return $self->search(@_)->count if @_ and defined $_[0];
return scalar @{ $self->get_cache } if $self->get_cache;
- my @subq_attrs = qw/prefetch collapse distinct group_by having having_bind/;
-
+ my @grouped_subq_attrs = qw/prefetch collapse distinct group_by having/;
+ my @subq_attrs = ();
+
+ my $attrs = $self->_resolved_attrs;
# if we are not paged - we are simply asking for a limit
- if (not $self->{attrs}{page} and not $self->{attrs}{software_limit}) {
+ if (not $attrs->{page} and not $attrs->{software_limit}) {
push @subq_attrs, qw/rows offset/;
}
- return $self->_has_attr (@subq_attrs)
- ? $self->_count_subq
+ my $need_subq = $self->_has_attr (@subq_attrs);
+ my $need_group_subq = $self->_has_attr (@grouped_subq_attrs);
+
+ return ($need_subq || $need_group_subq)
+ ? $self->_count_subq ($need_group_subq)
: $self->_count_simple
}
sub _count_subq {
- my $self = shift;
+ my ($self, $add_group_by) = @_;
- my $attrs = { %{$self->_resolved_attrs} };
+ my $attrs = $self->_resolved_attrs_copy;
# copy for the subquery, we need to do some adjustments to it too
my $sub_attrs = { %$attrs };
- # these can not go in the subquery either
- delete $sub_attrs->{$_} for qw/prefetch select +select as +as columns +columns/;
+ # these can not go in the subquery, and there is no point of ordering it
+ delete $sub_attrs->{$_} for qw/prefetch collapse select +select as +as columns +columns order_by/;
+
+ # if needed force a group_by and the same set of columns (most databases require this)
+ if ($add_group_by) {
- # force a group_by and the same set of columns (most databases require this)
- $sub_attrs->{columns} = $sub_attrs->{group_by} ||= [ map { "$attrs->{alias}.$_" } ($self->result_source->primary_columns) ];
+ # if we prefetch, we group_by primary keys only as this is what we would get out of the rs via ->next/->all
+ # simply deleting group_by suffices, as the code below will re-fill it
+ # Note: we check $attrs, as $sub_attrs has collapse deleted
+ if (ref $attrs->{collapse} and keys %{$attrs->{collapse}} ) {
+ delete $sub_attrs->{group_by};
+ }
+
+ $sub_attrs->{columns} = $sub_attrs->{group_by} ||= [ map { "$attrs->{alias}.$_" } ($self->result_source->primary_columns) ];
+ }
$attrs->{from} = [{
count_subq => (ref $self)->new ($self->result_source, $sub_attrs )->as_query
}];
# the subquery replaces this
- delete $attrs->{$_} for qw/where bind prefetch collapse group_by having/;
+ delete $attrs->{$_} for qw/where bind prefetch collapse distinct group_by having having_bind/;
return $self->__count ($attrs);
}
# need to take offset from resolved attrs
- $count -= $self->{_attrs}{offset} if $self->{_attrs}{offset};
- $count = $self->{attrs}{rows} if
- $self->{attrs}{rows} and $self->{attrs}{rows} < $count;
+ my $attrs = $self->_resolved_attrs;
+
+ $count -= $attrs->{offset} if $attrs->{offset};
+ $count = $attrs->{rows} if $attrs->{rows} and $attrs->{rows} < $count;
$count = 0 if ($count < 0);
return $count;
}
sub __count {
my ($self, $attrs) = @_;
- $attrs ||= { %{$self->{attrs}} };
+ $attrs ||= $self->_resolved_attrs_copy;
# take off any column specs, any pagers, record_filter is cdbi, and no point of ordering a count
delete $attrs->{$_} for (qw/columns +columns select +select as +as rows offset page pager order_by record_filter/);
if ($needs_group_by_subq or $needs_subq) {
# make a new $rs selecting only the PKs (that's all we really need)
- my $attrs = $self->_resolved_attrs;
+ my $attrs = $self->_resolved_attrs_copy;
- delete $attrs->{$_} for qw/prefetch select +select as +as columns +columns/;
+ delete $attrs->{$_} for qw/prefetch collapse select +select as +as columns +columns/;
$attrs->{columns} = [ map { "$attrs->{alias}.$_" } ($self->result_source->primary_columns) ];
if ($needs_group_by_subq) {
return ($from,$seen);
}
+# too many times we have to do $attrs = { %{$self->_resolved_attrs} }
+sub _resolved_attrs_copy {
+ my $self = shift;
+ return { %{$self->_resolved_attrs (@_)} };
+}
+
sub _resolved_attrs {
my $self = shift;
return $self->{_attrs} if $self->{_attrs};
}
- $attrs->{group_by} ||= $attrs->{select}
- if delete $attrs->{distinct};
if ( $attrs->{order_by} ) {
$attrs->{order_by} = (
ref( $attrs->{order_by} ) eq 'ARRAY'
}
push( @{ $attrs->{order_by} }, @pre_order );
}
+
+ if (delete $attrs->{distinct}) {
+ $attrs->{group_by} ||= [ grep { !ref($_) || (ref($_) ne 'HASH') } @{$attrs->{select}} ];
+ }
+
$attrs->{collapse} = $collapse;
if ( $attrs->{page} and not defined $attrs->{offset} ) {