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} = {
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/;
+ 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 $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 collapse 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/;
- # 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 needed force a group_by and the same set of columns (most databases require this)
+ if ($add_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
sub __count {
my ($self, $attrs) = @_;
- $attrs ||= { %{$self->_resolved_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 collapse select +select as +as columns +columns/;
$attrs->{columns} = [ map { "$attrs->{alias}.$_" } ($self->result_source->primary_columns) ];
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} ||= [ grep { !ref($_) || (ref($_) ne 'HASH') } @{$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} ) {