my $aliastypes = $self->_resolve_aliastypes_from_select_args(@_);
- # don't care
- delete $aliastypes->{joining};
+ my $orig_joins = delete $aliastypes->{joining};
+ my $orig_multiplying = $aliastypes->{multiplying};
# a grouped set will not be affected by amount of rows. Thus any
# {multiplying} joins can go
for my $j (@{$from}[1..$#$from]) {
push @newfrom, $j if (
- (! $j->[0]{-alias}) # legacy crap
+ (! defined $j->[0]{-alias}) # legacy crap
||
$need_joins{$j->[0]{-alias}}
);
}
- return \@newfrom;
+ return ( \@newfrom, {
+ multiplying => { map { $need_joins{$_} ? ($_ => $orig_multiplying->{$_}) : () } keys %$orig_multiplying },
+ %$aliastypes,
+ joining => { map { $_ => $orig_joins->{$_} } keys %need_joins },
+ } );
}
#
# generate inner/outer attribute lists, remove stuff that doesn't apply
my $outer_attrs = { %$attrs };
- delete $outer_attrs->{$_} for qw/where bind rows offset group_by _grouped_by_distinct having/;
+ delete @{$outer_attrs}{qw(where bind rows offset group_by _grouped_by_distinct having)};
my $inner_attrs = { %$attrs };
- delete $inner_attrs->{$_} for qw/from for collapse select as _related_results_construction/;
+ delete @{$inner_attrs}{qw(from for collapse select as _related_results_construction)};
# there is no point of ordering the insides if there is no limit
delete $inner_attrs->{order_by} if (
local $self->{_use_join_optimizer} = 1;
# throw away multijoins since we def. do not care about those inside the subquery
- my $inner_from = $self->_prune_unused_joins ($from, $inner_select, $where, {
+ my ($inner_from, $inner_aliastypes) = $self->_prune_unused_joins ($from, $inner_select, $where, {
%$inner_attrs, _force_prune_multiplying_joins => 1
});
- my $inner_aliastypes =
- $self->_resolve_aliastypes_from_select_args( $inner_from, $inner_select, $where, $inner_attrs );
-
# uh-oh a multiplier (which is not us) left in, this is a problem
if (
$inner_aliastypes->{multiplying}
) {
# if none of the multipliers came from an order_by (guaranteed to have been combined
- # with a limit) - easy - just slap a group_by to simulate a collape and be on our way
+ # with a limit) - easy - just slap a group_by to simulate a collapse and be on our way
if (
! $inner_aliastypes->{ordering}
or
# exactly what we expect
# supplement the main selection with pks if not already there,
- # as they will have to be a part of the group_by to colapse
+ # as they will have to be a part of the group_by to collapse
# things properly
my $cur_sel = { map { $_ => 1 } @$inner_select };
# scan the *remaining* from spec against different attributes, and see which joins are needed
# in what role
- my $outer_aliastypes =
+ my $outer_aliastypes = $outer_attrs->{_aliastypes} =
$self->_resolve_aliastypes_from_select_args( $from, $outer_select, $where, $outer_attrs );
# unroll parents
# Unfortunately not much can be done until SQLA2 introspection arrives, and even
# then if where conditions apply to the *right* side of the prefetch, you may have
# to both filter the inner select (e.g. to apply a limit) and then have to re-filter
- # the outer select to exclude joins you didin't want in the first place
+ # the outer select to exclude joins you didn't want in the first place
#
# OTOH it can be seen as a plus: <ash> (notes that this query would make a DBA cry ;)
return (\@outer_from, $outer_select, $where, $outer_attrs);
#
# Due to a lack of SQLA2 we fall back to crude scans of all the
# select/where/order/group attributes, in order to determine what
-# aliases are neded to fulfill the query. This information is used
+# aliases are needed to fulfill the query. This information is used
# throughout the code to prune unnecessary JOINs from the queries
# in an attempt to reduce the execution time.
# Although the method is pretty horrific, the worst thing that can
die 'How did we get here...';
}
-# returns an arrayref of column names which *definitely* have som
+# returns an arrayref of column names which *definitely* have some
# sort of non-nullable equality requested in the given condition
# specification. This is used to figure out if a resultset is
# constrained to a column which is part of a unique constraint,