DBIx/Class/Storage/DBIHacks.pm

filter: Statementstmt 97.0% 523 / 539 Branchbran 89.5% 301 / 336 Conditioncond 77.0% 265 / 344 MC/DCmcdc 58.1% 107 / 184 Subroutinesub 100% 26 / 26 Podpod n/a totaltotal 85.5% 1222 / 1429 CC 339 SCAR 37.3
CC
339
Cov
89%
_collapse_cond
73.0
_resolve_aliastypes_from_select_args
57.0
_adjust_select_args_for_complex_prefetch
51.2
CRAP 41.7
« DBIx/Class/Storage/DBI/SQLite.pm ↑ Summary DBIx/Class/ResultSet.pm »
1 package #hide from PAUSE
2 DBIx::Class::Storage::DBIHacks;
3  
4 #
5 # This module contains code supporting a battery of special cases and tests for
6 # many corner cases pushing the envelope of what DBIC can do. When work on
7 # these utilities began in mid 2009 (51a296b402c) it wasn't immediately obvious
8 # that these pieces, despite their misleading on-first-sighe-flakiness, will
9 # become part of the generic query rewriting machinery of DBIC, allowing it to
10 # both generate and process queries representing incredibly complex sets with
11 # reasonable efficiency.
12 #
13 # Now (end of 2019), more than 10 years later the routines in this class have
14 # stabilized enough, and are meticulously covered with tests, to a point where
15 # an effort to formalize them into user-facing APIs might be worthwhile.
16 #
17 # An implementor working on publicizing and/or replacing the routines with a
18 # more modern SQL generation framework should keep in mind that pretty much all
19 # existing tests are constructed on the basis of real-world code used in
20 # production somewhere.
21 #
22 # Please hack on this responsibly ;)
23 #
24  
25 266 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
26 266 ▶use warnings;
Subroutine BEGIN: called CC=1 SCAR=0.0
27  
28 266 ▶use base 'DBIx::Class::Storage';
Subroutine BEGIN: called CC=1 SCAR=0.0
29 266 ▶use mro 'c3';
Subroutine BEGIN: called CC=1 SCAR=0.0
30  
31 266 ▶use Scalar::Util 'blessed';
Subroutine BEGIN: called CC=1 SCAR=0.0
32 266 ▶use DBIx::Class::_Util qw(UNRESOLVABLE_CONDITION serialize);
Subroutine BEGIN: called CC=1 SCAR=0.0
33 266 ▶use SQL::Abstract::Util qw(is_plain_value is_literal_value);
Subroutine BEGIN: called CC=1 SCAR=0.0
34 266 ▶use DBIx::Class::Carp;
Subroutine BEGIN: called CC=1 SCAR=0.0
35 266 ▶use namespace::clean;
Subroutine BEGIN: called CC=1 SCAR=0.0
36  
37 #
38 # This code will remove non-selecting/non-restricting joins from
39 # {from} specs, aiding the RDBMS query optimizer
40 #
41 954 ▶sub _prune_unused_joins {
Subroutine _prune_unused_joins: called CC=16 SCAR=28.1
42 954 my ($self, $attrs) = @_;
43  
44 # only standard {from} specs are supported, and we could be disabled in general
45 return ($attrs->{from}, {}) unless (
46 ref $attrs->{from} eq 'ARRAY'
47 and
48 954 @{$attrs->{from}} > 1
49 and
50 ref $attrs->{from}[0] eq 'HASH'
51 and
52 954 ▶ ref $attrs->{from}[1] eq 'ARRAY'
Branch: 1 branch
BranchTrueFalseTotal
unless ref $attrs->{"from"} eq "ARRAY" and @{$attrs->{"from"};} > 1 and ref $attrs->{"from"}[0] eq "HASH" and ref $attrs->{"from"}[1] eq "ARRAY" and $self->_use_join_optimizer 57 897 954
Condition41%5/12
ref $attrs->{"from"} eq "ARRAY" and @{$attrs->{"from"};} > 1 and ref $attrs->{"from"}[0] eq "HASH" and ref $attrs->{"from"}[1] eq "ARRAY" and $self->_use_join_optimizer
!ll&&!rl&&r
057897
ref $attrs->{"from"} eq "ARRAY" and @{$attrs->{"from"};} > 1 and ref $attrs->{"from"}[0] eq "HASH" and ref $attrs->{"from"}[1] eq "ARRAY"
!ll&&!rl&&r
00954
ref $attrs->{"from"} eq "ARRAY" and @{$attrs->{"from"};} > 1 and ref $attrs->{"from"}[0] eq "HASH"
!ll&&!rl&&r
00954
ref $attrs->{"from"} eq "ARRAY" and @{$attrs->{"from"};} > 1
!ll&&!rl&&r
00954
MC/DC20%1/5
ref $attrs->{"from"} eq "ARRAY" and @{$attrs->{"from"};} > 1 and ref $attrs->{"from"}[0] eq "HASH" and ref $attrs->{"from"}[1] eq "ARRAY" and $self->_use_join_optimizer
ref $attrs->{"from"} eq "ARRAY" @{$attrs->{"from"};} > 1 ref $attrs->{"from"}[0] eq "HASH" ref $attrs->{"from"}[1] eq "ARRAY" $self->_use_join_optimizer
Truth table33%2/6
A and B and C and D and E
A= ref $attrs->{"from"} eq "ARRAY"B= @{$attrs->{"from"};} > 1C= ref $attrs->{"from"}[0] eq "HASH"D= ref $attrs->{"from"}[1] eq "ARRAY"E= $self->_use_join_optimizer
ABCDEresult
0XXXX0
10XXX0
110XX0
1110X0
111100
111111
53 and
54 $self->_use_join_optimizer
55 );
56  
57 897 my $orig_aliastypes = $self->_resolve_aliastypes_from_select_args($attrs);
58  
59 897 my $new_aliastypes = { %$orig_aliastypes };
60  
61 # we will be recreating this entirely
62 897 my @reclassify = 'joining';
63  
64 # a grouped set will not be affected by amount of rows. Thus any
65 # purely multiplicator classifications can go
66 # (will be reintroduced below if needed by something else)
67 push @reclassify, qw(multiplying premultiplied)
68 897 ▶ if $attrs->{_force_prune_multiplying_joins} or $attrs->{group_by};
Branch: 1 branch
BranchTrueFalseTotal
if $attrs->{"_force_prune_multiplying_joins"} or $attrs->{"group_by"} 224 673 897
Condition100%3/3
$attrs->{"_force_prune_multiplying_joins"} or $attrs->{"group_by"}
l!l&&r!l&&!r
107117673
MC/DC100%2/2
$attrs->{"_force_prune_multiplying_joins"} or $attrs->{"group_by"}
$attrs->{"_force_prune_multiplying_joins"} $attrs->{"group_by"}
Truth table100%3/3
A or B
A= $attrs->{"_force_prune_multiplying_joins"}B= $attrs->{"group_by"}
ABresult
1X1
011
000
69  
70 # nuke what will be recalculated
71 897 delete @{$new_aliastypes}{@reclassify};
72  
73 897 my @newfrom = $attrs->{from}[0]; # FROM head is always present
74  
75 # recalculate what we need once the multipliers are potentially gone
76 # ignore premultiplies, since they do not add any value to anything
77 897 my %need_joins;
78 897 for ( @{$new_aliastypes}{grep { $_ ne 'premultiplied' } keys %$new_aliastypes }) {
79 # add all requested aliases
80 2391 $need_joins{$_} = 1 for keys %$_;
81  
82 # add all their parents (as per joinpath which is an AoH { table => alias })
83 2391 $need_joins{$_} = 1 for map { values %$_ } map { @{$_->{-parents}} } values %$_;
84 }
85  
86 897 for my $j (@{$attrs->{from}}[1..$#{$attrs->{from}}]) {
87 push @newfrom, $j if (
88 (! defined $j->[0]{-alias}) # legacy crap
89 ||
90 $need_joins{$j->[0]{-alias}}
91 1531 ▶ );
Branch: 1 branch
BranchTrueFalseTotal
if not defined $j->[0]{"-alias"} or $need_joins{$j->[0]{"-alias"}} 1400 131 1531
Condition100%3/3
not defined $j->[0]{"-alias"} or $need_joins{$j->[0]{"-alias"}}
l!l&&r!l&&!r
41396131
MC/DC100%2/2
not defined $j->[0]{"-alias"} or $need_joins{$j->[0]{"-alias"}}
not defined $j->[0]{"-alias"} $need_joins{$j->[0]{"-alias"}}
Truth table100%3/3
not(A) or B
A= not defined $j->[0]{"-alias"}B= $need_joins{$j->[0]{"-alias"}}
ABresult
1X1
011
000
92 }
93  
94 # we have a new set of joiners - for everything we nuked pull the classification
95 # off the original stack
96 897 for my $ctype (@reclassify) {
97 $new_aliastypes->{$ctype} = { map
98 2701 ▶ { $need_joins{$_} ? ( $_ => $orig_aliastypes->{$ctype}{$_} ) : () }
Branch: 1 branch
BranchTrueFalseTotal
$need_joins{$_} ? : 2478 223 2701
99 1345 keys %{$orig_aliastypes->{$ctype}}
100 }
101 }
102  
103 897 return ( \@newfrom, $new_aliastypes );
104 }
105  
106 #
107 # This is the code producing joined subqueries like:
108 # SELECT me.*, other.* FROM ( SELECT me.* FROM ... ) JOIN other ON ...
109 #
110 87 ▶sub _adjust_select_args_for_complex_prefetch {
Subroutine _adjust_select_args_for_complex_prefetch: called CC=46 SCAR=39.4
111 87 my ($self, $attrs) = @_;
112  
113 $self->throw_exception ('Complex prefetches are not supported on resultsets with a custom from attribute') unless (
114 ref $attrs->{from} eq 'ARRAY'
115 and
116 87 @{$attrs->{from}} > 1
117 and
118 ref $attrs->{from}[0] eq 'HASH'
119 and
120 87 ▶ ref $attrs->{from}[1] eq 'ARRAY'
Branch: 1 branch
BranchTrueFalseTotal
unless ref $attrs->{"from"} eq "ARRAY" and @{$attrs->{"from"};} > 1 and ref $attrs->{"from"}[0] eq "HASH" and ref $attrs->{"from"}[1] eq "ARRAY" 0 87 87
Condition33%3/9
ref $attrs->{"from"} eq "ARRAY" and @{$attrs->{"from"};} > 1 and ref $attrs->{"from"}[0] eq "HASH" and ref $attrs->{"from"}[1] eq "ARRAY"
!ll&&!rl&&r
0087
ref $attrs->{"from"} eq "ARRAY" and @{$attrs->{"from"};} > 1 and ref $attrs->{"from"}[0] eq "HASH"
!ll&&!rl&&r
0087
ref $attrs->{"from"} eq "ARRAY" and @{$attrs->{"from"};} > 1
!ll&&!rl&&r
0087
MC/DC0%0/4
ref $attrs->{"from"} eq "ARRAY" and @{$attrs->{"from"};} > 1 and ref $attrs->{"from"}[0] eq "HASH" and ref $attrs->{"from"}[1] eq "ARRAY"
ref $attrs->{"from"} eq "ARRAY" @{$attrs->{"from"};} > 1 ref $attrs->{"from"}[0] eq "HASH" ref $attrs->{"from"}[1] eq "ARRAY"
Truth table20%1/5
A and B and C and D
A= ref $attrs->{"from"} eq "ARRAY"B= @{$attrs->{"from"};} > 1C= ref $attrs->{"from"}[0] eq "HASH"D= ref $attrs->{"from"}[1] eq "ARRAY"
ABCDresult
0XXX0
10XX0
110X0
11100
11111
121 );
122  
123 87 my $root_alias = $attrs->{alias};
124  
125 # generate inner/outer attribute lists, remove stuff that doesn't apply
126 87 my $outer_attrs = { %$attrs };
127 87 delete @{$outer_attrs}{qw(from bind rows offset group_by _grouped_by_distinct having)};
128  
129 87 my $inner_attrs = { %$attrs, _simple_passthrough_construction => 1 };
130 87 delete @{$inner_attrs}{qw(for collapse select as)};
131  
132 # there is no point of ordering the insides if there is no limit
133 delete $inner_attrs->{order_by} if (
134 delete $inner_attrs->{_order_is_artificial}
135 or
136 ! $inner_attrs->{rows}
137 87 ▶ );
Branch: 1 branch
BranchTrueFalseTotal
if delete $inner_attrs->{"_order_is_artificial"} or not $inner_attrs->{"rows"} 15 72 87
Condition100%3/3
delete $inner_attrs->{"_order_is_artificial"} or not $inner_attrs->{"rows"}
l!l&&r!l&&!r
41172
MC/DC100%2/2
delete $inner_attrs->{"_order_is_artificial"} or not $inner_attrs->{"rows"}
delete $inner_attrs->{"_order_is_artificial"} not $inner_attrs->{"rows"}
Truth table100%3/3
A or not(B)
A= delete $inner_attrs->{"_order_is_artificial"}B= not $inner_attrs->{"rows"}
ABresult
1X1
011
000
138  
139 # generate the inner/outer select lists
140 # for inside we consider only stuff *not* brought in by the prefetch
141 # on the outside we substitute any function for its alias
142 87 $outer_attrs->{select} = [ @{$attrs->{select}} ];
143  
144 87 my ($root_node, $root_node_offset);
145  
146 87 for my $i (0 .. $#{$inner_attrs->{from}}) {
147 107 my $node = $inner_attrs->{from}[$i];
148 107 ▶ my $h = (ref $node eq 'HASH') ? $node
Branch: 2 branches
BranchTrueFalseTotal
ref $node eq 'HASH' ? : 87 20 107
ref $node eq 'ARRAY' && ref $node->[0] eq 'HASH' ? : 20 0 20
Condition33%1/3
ref $node eq "ARRAY" and ref $node->[0] eq "HASH"
!ll&&!rl&&r
0020
MC/DC0%0/2
ref $node eq "ARRAY" and ref $node->[0] eq "HASH"
ref $node eq "ARRAY" ref $node->[0] eq "HASH"
Truth table33%1/3
A and B
A= ref $node eq "ARRAY"B= ref $node->[0] eq "HASH"
ABresult
0X0
100
111
149 : (ref $node eq 'ARRAY' and ref $node->[0] eq 'HASH') ? $node->[0]
150 : next
151 ;
152  
153 107 ▶ if ( ($h->{-alias}||'') eq $root_alias and $h->{-rsrc} ) {
Branch: 1 branch
BranchTrueFalseTotal
if (($h->{"-alias"} || "") eq $root_alias and $h->{"-rsrc"}) 87 20 107
Condition60%3/5
($h->{"-alias"} || "") eq $root_alias and $h->{"-rsrc"}
!ll&&!rl&&r
20087
$h->{'-alias'} || ''
l!l
1070
MC/DC0%0/2
($h->{"-alias"} || "") eq $root_alias and $h->{"-rsrc"}
$h->{'-alias'} $h->{"-rsrc"}
Truth table33%1/3
A and B
A= $h->{'-alias'}B= $h->{"-rsrc"}
ABresult
0X0
100
111
154 87 $root_node = $h;
155 87 $root_node_offset = $i;
156 87 last;
157 }
158 }
159  
160 87 ▶ $self->throw_exception ('Complex prefetches are not supported on resultsets with a custom from attribute')
Branch: 1 branch
BranchTrueFalseTotal
unless $root_node 0 87 87
161 unless $root_node;
162  
163 # use the heavy duty resolver to take care of aliased/nonaliased naming
164 87 my $colinfo = $self->_resolve_column_info($inner_attrs->{from});
165 87 my $selected_root_columns;
166  
167 87 for my $i (0 .. $#{$outer_attrs->{select}}) {
168 754 my $sel = $outer_attrs->{select}->[$i];
169  
170 next if (
171 754 ▶ $colinfo->{$sel} and $colinfo->{$sel}{-source_alias} ne $root_alias
Branch: 1 branch
BranchTrueFalseTotal
if $colinfo->{$sel} and $colinfo->{$sel}{"-source_alias"} ne $root_alias 432 322 754
Condition100%3/3
$colinfo->{$sel} and $colinfo->{$sel}{"-source_alias"} ne $root_alias
!ll&&!rl&&r
27295432
MC/DC100%2/2
$colinfo->{$sel} and $colinfo->{$sel}{"-source_alias"} ne $root_alias
$colinfo->{$sel} $colinfo->{$sel}{"-source_alias"} ne $root_alias
Truth table100%3/3
A and B
A= $colinfo->{$sel}B= $colinfo->{$sel}{"-source_alias"} ne $root_alias
ABresult
0X0
100
111
172 );
173  
174 322 ▶ if (ref $sel eq 'HASH' ) {
Branch: 2 branches
BranchTrueFalseTotal
if (ref $sel eq 'HASH') { } 17 305 322
elsif (not ref $sel and my $ci = $colinfo->{$sel}) { } 295 20 315
175 17 ▶ $sel->{-as} ||= $attrs->{as}[$i];
Condition66%2/3
$sel->{"-as"} ||= $attrs->{"as"}[$i]
l!l&&r!l&&!r
1070
MC/DC0%0/2
$sel->{"-as"} ||= $attrs->{"as"}[$i]
$sel->{"-as"} $attrs->{"as"}[$i]
Truth table66%2/3
A ||= B
A= $sel->{"-as"}B= $attrs->{"as"}[$i]
ABresult
1X1
011
000
176 17 ▶ $outer_attrs->{select}->[$i] = join ('.', $root_alias, ($sel->{-as} || "inner_column_$i") );
Condition50%1/2
$sel->{'-as'} || "inner_column_$i"
l!l
170
MC/DC0%0/1
$sel->{'-as'} || "inner_column_$i"
$sel->{'-as'}
Truth table50%1/2
A
A= $sel->{'-as'}
Aresult
11
00
177 }
178 ▶ elsif (! ref $sel and my $ci = $colinfo->{$sel}) {
Condition66%2/3
not ref $sel and my $ci = $colinfo->{$sel}
!ll&&!rl&&r
100295
MC/DC50%1/2
not ref $sel and my $ci = $colinfo->{$sel}
not ref $sel my $ci = $colinfo->{$sel}
Truth table66%2/3
not(A) and B
A= not ref $selB= my $ci = $colinfo->{$sel}
ABresult
0X0
100
111
179 295 $selected_root_columns->{$ci->{-colname}} = 1;
180 }
181  
182 322 push @{$inner_attrs->{select}}, $sel;
183  
184 322 push @{$inner_attrs->{as}}, $attrs->{as}[$i];
185 }
186  
187 # We will need to fetch all native columns in the inner subquery, which may
188 # be a part of an *outer* join condition, or an order_by (which needs to be
189 # preserved outside), or wheres. In other words everything but the inner
190 # selector
191 # We can not just fetch everything because a potential has_many restricting
192 # join collapse *will not work* on heavy data types.
193 87 my $connecting_aliastypes = $self->_resolve_aliastypes_from_select_args({
194 %$inner_attrs,
195 select => [],
196 });
197  
198 87 ▶ for (sort map { keys %{$_->{-seen_columns}||{}} } map { values %$_ } values %$connecting_aliastypes) {
Condition100%2/2
$_->{'-seen_columns'} || {}
l!l
411219
MC/DC100%1/1
$_->{'-seen_columns'} || {}
$_->{'-seen_columns'}
Truth table100%2/2
A
A= $_->{'-seen_columns'}
Aresult
11
00
199 555 ▶ my $ci = $colinfo->{$_} or next;
Branch: 1 branch
BranchTrueFalseTotal
my $ci = $colinfo->{$_} or next 555 0 555
200 555 ▶ if (
Branch: 1 branch
BranchTrueFalseTotal
if ($ci->{"-source_alias"} eq $root_alias and not $$selected_root_columns{$ci->{"-colname"}}++) 37 518 555
Condition100%3/3
$ci->{"-source_alias"} eq $root_alias and not $$selected_root_columns{$ci->{"-colname"}}++
!ll&&!rl&&r
23628237
MC/DC100%2/2
$ci->{"-source_alias"} eq $root_alias and not $$selected_root_columns{$ci->{"-colname"}}++
$ci->{"-source_alias"} eq $root_alias not $$selected_root_columns{$ci->{"-colname"}}++
Truth table100%3/3
A and not(B)
A= $ci->{"-source_alias"} eq $root_aliasB= not $$selected_root_columns{$ci->{"-colname"}}++
ABresult
0X0
100
111
201 $ci->{-source_alias} eq $root_alias
202 and
203 ! $selected_root_columns->{$ci->{-colname}}++
204 ) {
205 # adding it to both to keep limits not supporting dark selectors happy
206 37 push @{$inner_attrs->{select}}, $ci->{-fq_colname};
207 37 push @{$inner_attrs->{as}}, $ci->{-fq_colname};
208 }
209 }
210  
211 # construct the inner {from} and lock it in a subquery
212 # we need to prune first, because this will determine if we need a group_by below
213 # throw away all non-selecting, non-restricting multijoins
214 # (since we def. do not care about multiplication of the contents of the subquery)
215 87 my $inner_subq = do {
216  
217 # must use it here regardless of user requests (vastly gentler on optimizer)
218 87 local $self->{_use_join_optimizer} = 1;
219  
220 # throw away multijoins since we def. do not care about those inside the subquery
221 87 ($inner_attrs->{from}, my $inner_aliastypes) = $self->_prune_unused_joins ({
222 %$inner_attrs, _force_prune_multiplying_joins => 1
223 });
224  
225 # uh-oh a multiplier (which is not us) left in, this is a problem for limits
226 # we will need to add a group_by to collapse the resultset for proper counts
227 87 ▶ if (
Branch: 1 branch
BranchTrueFalseTotal
if (grep {$_ ne $root_alias;} keys %{$inner_aliastypes->{"multiplying"} or {};} and !$inner_aliastypes->{"grouping"} || $inner_attrs->{"_grouped_by_distinct"}) 39 48 87
Condition100%3/3
grep {$_ ne $root_alias;} keys %{$inner_aliastypes->{"multiplying"} or {};} and !$inner_aliastypes->{"grouping"} || $inner_attrs->{"_grouped_by_distinct"}
!ll&&!rl&&r
42639
MC/DC100%2/2
grep {$_ ne $root_alias;} keys %{$inner_aliastypes->{"multiplying"} or {};} and !$inner_aliastypes->{"grouping"} || $inner_attrs->{"_grouped_by_distinct"}
grep {$_ ne $root_alias;} keys %{$inner_aliastypes->{"multiplying"} or {};} !$inner_aliastypes->{"grouping"} || $inner_attrs->{"_grouped_by_distinct"}
Truth table100%3/3
A and B
A= grep {$_ ne $root_alias;} keys %{$inner_aliastypes->{"multiplying"} or {};}B= !$inner_aliastypes->{"grouping"} || $inner_attrs->{"_grouped_by_distinct"}
ABresult
0X0
100
111
228 64 ▶ grep { $_ ne $root_alias } keys %{ $inner_aliastypes->{multiplying} || {} }
Condition80%4/5
$inner_aliastypes->{'multiplying'} || {}
l!l
870
not $inner_aliastypes->{"grouping"} or $inner_attrs->{"_grouped_by_distinct"}
l!l&&r!l&&!r
3276
MC/DC0%0/1
$inner_aliastypes->{'multiplying'} || {}
$inner_aliastypes->{'multiplying'}
MC/DC100%2/2
not $inner_aliastypes->{"grouping"} or $inner_attrs->{"_grouped_by_distinct"}
not $inner_aliastypes->{"grouping"} $inner_attrs->{"_grouped_by_distinct"}
Truth table50%1/2
A
A= $inner_aliastypes->{'multiplying'}
Aresult
11
00
Truth table100%3/3
not(A) or B
A= not $inner_aliastypes->{"grouping"}B= $inner_attrs->{"_grouped_by_distinct"}
ABresult
1X1
011
000
229 and
230 # if there are user-supplied groups - assume user knows wtf they are up to
231 ( ! $inner_aliastypes->{grouping} or $inner_attrs->{_grouped_by_distinct} )
232 ) {
233  
234 39 my $cur_sel = { map { $_ => 1 } @{$inner_attrs->{select}} };
235  
236 # *possibly* supplement the main selection with pks if not already
237 # there, as they will have to be a part of the group_by to collapse
238 # things properly
239 39 my $inner_select_with_extras;
240 39 my @pks = map { "$root_alias.$_" } $root_node->{-rsrc}->primary_columns
241 or $self->throw_exception( sprintf
242 'Unable to perform complex limited prefetch off %s without declared primary key',
243 $root_node->{-rsrc}->source_name,
244 39 ▶ );
Branch: 1 branch
BranchTrueFalseTotal
my(@pks) = map({"$root_alias.$_";} $root_node->{"-rsrc"}->primary_columns) or $self->throw_exception(sprintf("Unable to perform complex limited prefetch off %s without declared primary key", $root_node->{"-rsrc"}->source_name)) 39 0 39
245 39 for my $col (@pks) {
246 0 ▶ push @{ $inner_select_with_extras ||= [ @{$inner_attrs->{select}} ] }, $col
Condition0%0/2
$inner_select_with_extras ||= [@{$inner_attrs->{"select"};}]
l!l
00
MC/DC0%0/1
$inner_select_with_extras ||= [@{$inner_attrs->{"select"};}]
$inner_select_with_extras
Truth table0%0/2
A
A= $inner_select_with_extras
Aresult
11
00
247 39 ▶ unless $cur_sel->{$col}++;
Branch: 1 branch
BranchTrueFalseTotal
unless $cur_sel->{$col}++ 0 39 39
248 }
249  
250 39 ▶ ($inner_attrs->{group_by}, $inner_attrs->{order_by}) = $self->_group_over_selection({
Branch: 1 branch
BranchTrueFalseTotal
$inner_select_with_extras ? : 0 39 39
251 %$inner_attrs,
252 $inner_select_with_extras ? ( select => $inner_select_with_extras ) : (),
253 _aliastypes => $inner_aliastypes,
254 });
255 }
256  
257 # we already optimized $inner_attrs->{from} above
258 # and already local()ized
259 86 $self->{_use_join_optimizer} = 0;
260  
261 # generate the subquery
262 $self->_select_args_to_query (
263 86 @{$inner_attrs}{qw(from select where)},
264 $inner_attrs,
265 );
266 };
267  
268 # Generate the outer from - this is relatively easy (really just replace
269 # the join slot with the subquery), with a major caveat - we can not
270 # join anything that is non-selecting (not part of the prefetch), but at
271 # the same time is a multi-type relationship, as it will explode the result.
272 #
273 # There are two possibilities here
274 # - either the join is non-restricting, in which case we simply throw it away
275 # - it is part of the restrictions, in which case we need to collapse the outer
276 # result by tackling yet another group_by to the outside of the query
277  
278 # work on a shallow copy
279 86 my @orig_from = @{$attrs->{from}};
280  
281  
282 86 $outer_attrs->{from} = \ my @outer_from;
283  
284 # we may not be the head
285 86 ▶ if ($root_node_offset) {
Branch: 1 branch
BranchTrueFalseTotal
if ($root_node_offset) { } 17 69 86
286 # first generate the outer_from, up to the substitution point
287 17 @outer_from = splice @orig_from, 0, $root_node_offset;
288  
289 # substitute the subq at the right spot
290 push @outer_from, [
291 {
292 -alias => $root_alias,
293 -rsrc => $root_node->{-rsrc},
294 $root_alias => $inner_subq,
295 },
296 # preserve attrs from what is now the head of the from after the splice
297 17 @{$orig_from[0]}[1 .. $#{$orig_from[0]}],
298 ];
299 }
300 else {
301 @outer_from = {
302 -alias => $root_alias,
303 -rsrc => $root_node->{-rsrc},
304 69 $root_alias => $inner_subq,
305 };
306 }
307  
308 86 shift @orig_from; # what we just replaced above
309  
310 # scan the *remaining* from spec against different attributes, and see which joins are needed
311 # in what role
312 my $outer_aliastypes = $outer_attrs->{_aliastypes} =
313 86 $self->_resolve_aliastypes_from_select_args({ %$outer_attrs, from => \@orig_from });
314  
315 # unroll parents
316 86 my ($outer_select_chain, @outer_nonselecting_chains) = map { +{
317 344 ▶ map { $_ => 1 } map { values %$_} map { @{$_->{-parents}} } values %{ $outer_aliastypes->{$_} || {} }
Condition100%2/2
$outer_aliastypes->{$_} || {}
l!l
140204
MC/DC100%1/1
$outer_aliastypes->{$_} || {}
$outer_aliastypes->{$_}
Truth table100%2/2
A
A= $outer_aliastypes->{$_}
Aresult
11
00
318 } } qw/selecting restricting grouping ordering/;
319  
320 # see what's left - throw away if not selecting/restricting
321 86 my $may_need_outer_group_by;
322 86 ▶ while (my $j = shift @orig_from) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $j = shift @orig_from) 119 86 205
323 119 my $alias = $j->[0]{-alias};
324  
325 119 ▶ if (
Branch: 2 branches
BranchTrueFalseTotal
if ($outer_select_chain->{$alias}) { } 109 10 119
elsif (grep {$_->{$alias};} @outer_nonselecting_chains) { } 8 2 10
326 $outer_select_chain->{$alias}
327 ) {
328 109 push @outer_from, $j
329 }
330 30 elsif (grep { $_->{$alias} } @outer_nonselecting_chains ) {
331 8 push @outer_from, $j;
332 8 ▶ $may_need_outer_group_by ||= $outer_aliastypes->{multiplying}{$alias} ? 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
$outer_aliastypes->{'multiplying'}{$alias} ? : 6 2 8
Condition66%2/3
$may_need_outer_group_by ||= $outer_aliastypes->{"multiplying"}{$alias} ? 1 : 0
l!l&&r!l&&!r
062
MC/DC50%1/2
$may_need_outer_group_by ||= $outer_aliastypes->{"multiplying"}{$alias} ? 1 : 0
$may_need_outer_group_by $outer_aliastypes->{"multiplying"}{$alias} ? 1 : 0
Truth table66%2/3
A ||= B
A= $may_need_outer_group_byB= $outer_aliastypes->{"multiplying"}{$alias} ? 1 : 0
ABresult
1X1
011
000
333 }
334 }
335  
336 # also throw in a synthetic group_by if a non-selecting multiplier,
337 # to guard against cross-join explosions
338 # the logic is somewhat fragile, but relies on the idea that if a user supplied
339 # a group by on their own - they know what they were doing
340 86 ▶ if ( $may_need_outer_group_by and $attrs->{_grouped_by_distinct} ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($may_need_outer_group_by and $attrs->{"_grouped_by_distinct"}) 2 84 86
Condition100%3/3
$may_need_outer_group_by and $attrs->{"_grouped_by_distinct"}
!ll&&!rl&&r
8042
MC/DC100%2/2
$may_need_outer_group_by and $attrs->{"_grouped_by_distinct"}
$may_need_outer_group_by $attrs->{"_grouped_by_distinct"}
Truth table100%3/3
A and B
A= $may_need_outer_group_byB= $attrs->{"_grouped_by_distinct"}
ABresult
0X0
100
111
341 2 ($outer_attrs->{group_by}, $outer_attrs->{order_by}) = $self->_group_over_selection ({
342 %$outer_attrs,
343 from => \@outer_from,
344 });
345 }
346  
347 # FIXME: The {where} ends up in both the inner and outer query, i.e. *twice*
348 #
349 # This is rather horrific, and while we currently *do* have enough
350 # introspection tooling available to attempt a stab at properly deciding
351 # whether or not to include the where condition on the outside, the
352 # machinery is still too slow to apply it here.
353 # Thus for the time being we do not attempt any sanitation of the where
354 # clause and just pass it through on both sides of the subquery. This *will*
355 # be addressed at a later stage, most likely after folding the SQL generator
356 # into SQLMaker proper
357 #
358 # OTOH it can be seen as a plus: <ash> (notes that this query would make a DBA cry ;)
359 #
360 86 return $outer_attrs;
361 }
362  
363 #
364 # This is probably the ickiest, yet most relied upon part of the codebase:
365 # this is the place where we take arbitrary SQL input and break it into its
366 # constituent parts, making sure we know which *sources* are used in what
367 # *capacity* ( selecting / restricting / grouping / ordering / joining, etc. )
368 # Although the method is pretty horrific, the worst thing that can happen is
369 # for a classification failure, which in turn will result in a vocal exception,
370 # and will lead to a relatively prompt fix.
371 # The code has been slowly improving and is covered with a formiddable battery
372 # of tests, so can be considered "reliably stable" at this point (Oct 2015).
373 #
374 # A note to implementors attempting to "replace" this - keep in mind that while
375 # there are multiple optimization avenues, the actual "scan literal elements"
376 # part *MAY NEVER BE REMOVED*, even if in the future it is limited to only AST
377 # nodes that are deemed opaque (i.e. contain literal expressions). The use and
378 # comprehension of blackbox literals is at this point firmly a user-facing API,
379 # and is one of *the* reasons DBIC remains as flexible as it is.
380 #
381 # In other words, when working on this keep in mind that the following is both
382 # a widespread and *encouraged* way of using DBIC in the wild when push comes
383 # to shove:
384 #
385 # $rs->search( {}, {
386 # select => \[ $random, @stuff],
387 # from => \[ $random, @stuff ],
388 # where => \[ $random, @stuff ],
389 # group_by => \[ $random, @stuff ],
390 # order_by => \[ $random, @stuff ],
391 # } )
392 #
393 # Various incarnations of the above are reflected in many of the tests. If one
394 # gets to fail, or if a user complains: you get to fix it. A stance amounting
395 # to "this is crazy, nobody does that" is not acceptable going forward.
396 #
397 1125 ▶sub _resolve_aliastypes_from_select_args {
Subroutine _resolve_aliastypes_from_select_args: called CC=53 SCAR=40.4
398 1125 my ( $self, $attrs ) = @_;
399  
400 $self->throw_exception ('Unable to analyze custom {from}')
401 1125 ▶ if ref $attrs->{from} ne 'ARRAY';
Branch: 1 branch
BranchTrueFalseTotal
if ref $attrs->{"from"} ne "ARRAY" 0 1125 1125
402  
403 # what we will return
404 1125 my $aliases_by_type;
405  
406 # see what aliases are there to work with
407 # and record who is a multiplier and who is premultiplied
408 my $alias_list;
409 1125 for my $node (@{$attrs->{from}}) {
410  
411 2894 my $j = $node;
412 2894 ▶ $j = $j->[0] if ref $j eq 'ARRAY';
Branch: 1 branch
BranchTrueFalseTotal
if ref $j eq "ARRAY" 1855 1039 2894
413 my $al = $j->{-alias}
414 2894 ▶ or next;
Branch: 1 branch
BranchTrueFalseTotal
my $al = $j->{"-alias"} or next 2886 8 2894
415  
416 2886 $alias_list->{$al} = $j;
417  
418 $aliases_by_type->{multiplying}{$al} ||= { -parents => $j->{-join_path}||[] }
419 # not array == {from} head == can't be multiplying
420 2886 ▶ if ref($node) eq 'ARRAY' and ! $j->{-is_single};
Branch: 1 branch
BranchTrueFalseTotal
if ref $node eq "ARRAY" and not $j->{"-is_single"} 902 1984 2886
Condition71%5/7
ref $node eq "ARRAY" and not $j->{"-is_single"}
!ll&&!rl&&r
1035949902
$aliases_by_type->{"multiplying"}{$al} ||= {"-parents", $j->{"-join_path"} || []}
l!l
0902
$j->{'-join_path'} || []
l!l
9020
MC/DC100%2/2
ref $node eq "ARRAY" and not $j->{"-is_single"}
ref $node eq "ARRAY" not $j->{"-is_single"}
MC/DC0%0/1
$aliases_by_type->{"multiplying"}{$al} ||= {"-parents", $j->{"-join_path"} || []}
$aliases_by_type->{"multiplying"}{$al}
MC/DC0%0/1
$j->{'-join_path'} || []
$j->{'-join_path'}
Truth table100%3/3
A and not(B)
A= ref $node eq "ARRAY"B= not $j->{"-is_single"}
ABresult
0X0
100
111
Truth table50%1/2
A
A= $aliases_by_type->{"multiplying"}{$al}
Aresult
11
00
Truth table50%1/2
A
A= $j->{'-join_path'}
Aresult
11
00
421  
422 $aliases_by_type->{premultiplied}{$al} ||= { -parents => $j->{-join_path}||[] }
423 # parts of the path that are not us but are multiplying
424 837 if grep { $aliases_by_type->{multiplying}{$_} }
425 2688 grep { $_ ne $al }
426 2688 map { values %$_ }
427 2886 ▶ @{ $j->{-join_path}||[] }
Branch: 1 branch
BranchTrueFalseTotal
if grep {$aliases_by_type->{"multiplying"}{$_};} grep({$_ ne $al;} map({values %$_;} @{$j->{"-join_path"} or [];})) 373 2513 2886
Condition66%4/6
$j->{'-join_path'} || []
l!l
18511035
$aliases_by_type->{"premultiplied"}{$al} ||= {"-parents", $j->{"-join_path"} || []}
l!l
0373
$j->{'-join_path'} || []
l!l
3730
MC/DC100%1/1
$j->{'-join_path'} || []
$j->{'-join_path'}
MC/DC0%0/1
$aliases_by_type->{"premultiplied"}{$al} ||= {"-parents", $j->{"-join_path"} || []}
$aliases_by_type->{"premultiplied"}{$al}
MC/DC0%0/1
$j->{'-join_path'} || []
$j->{'-join_path'}
Truth table100%2/2
A
A= $j->{'-join_path'}
Aresult
11
00
Truth table50%1/2
A
A= $aliases_by_type->{"premultiplied"}{$al}
Aresult
11
00
Truth table50%1/2
A
A= $j->{'-join_path'}
Aresult
11
00
428 }
429  
430 # get a column to source/alias map (including unambiguous unqualified ones)
431 1125 my $colinfo = $self->_resolve_column_info ($attrs->{from});
432  
433 # set up a botched SQLMaker
434 1125 my $sql_maker = $self->sql_maker;
435  
436 # these are throw away results, do not pollute the bind stack
437 1125 local $sql_maker->{where_bind};
438 1125 local $sql_maker->{group_bind};
439 1125 local $sql_maker->{having_bind};
440 1125 local $sql_maker->{from_bind};
441  
442 # we can't scan properly without any quoting (\b doesn't cut it
443 # everywhere), so unless there is proper quoting set - use our
444 # own weird impossible character.
445 # Also in the case of no quoting, we need to explicitly disable
446 # name_sep, otherwise sorry nasty legacy syntax like
447 # { 'count(foo.id)' => { '>' => 3 } } will stop working >:(
448 1125 local $sql_maker->{quote_char} = $sql_maker->{quote_char};
449 1125 local $sql_maker->{name_sep} = $sql_maker->{name_sep};
450  
451 1125 ▶ unless (defined $sql_maker->{quote_char} and length $sql_maker->{quote_char}) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $sql_maker->{"quote_char"} and length $sql_maker->{"quote_char"}) 1000 125 1125
Condition66%2/3
defined $sql_maker->{"quote_char"} and length $sql_maker->{"quote_char"}
!ll&&!rl&&r
10000125
MC/DC50%1/2
defined $sql_maker->{"quote_char"} and length $sql_maker->{"quote_char"}
defined $sql_maker->{"quote_char"} length $sql_maker->{"quote_char"}
Truth table66%2/3
A and B
A= defined $sql_maker->{"quote_char"}B= length $sql_maker->{"quote_char"}
ABresult
0X0
100
111
452 1000 $sql_maker->{quote_char} = ["\x00", "\xFF"];
453 # if we don't unset it we screw up retarded but unfortunately working
454 # 'MAX(foo.bar)' => { '>', 3 }
455 1000 $sql_maker->{name_sep} = '';
456 }
457  
458 1125 my ($lquote, $rquote, $sep) = map { quotemeta $_ } ($sql_maker->_quote_chars, $sql_maker->name_sep);
459  
460 # generate sql chunks
461 my $to_scan = {
462 restricting => [
463 ($sql_maker->_recurse_where ($attrs->{where}))[0],
464 $sql_maker->_parse_rs_attrs ({ having => $attrs->{having} }),
465 ],
466 grouping => [
467 $sql_maker->_parse_rs_attrs ({ group_by => $attrs->{group_by} }),
468 ],
469 joining => [
470 $sql_maker->_recurse_from (
471 ref $attrs->{from}[0] eq 'ARRAY' ? $attrs->{from}[0][0] : $attrs->{from}[0],
472 1125 @{$attrs->{from}}[1 .. $#{$attrs->{from}}],
473 ),
474 ],
475 selecting => [
476 5329 map { ($sql_maker->_recurse_fields($_))[0] } @{$attrs->{select}},
477 ],
478 ordering => [
479 1125 ▶ map { $_->[0] } $self->_extract_order_criteria ($attrs->{order_by}, $sql_maker),
Branch: 1 branch
BranchTrueFalseTotal
ref $attrs->{'from'}[0] eq 'ARRAY' ? : 86 1039 1125
480 ],
481 };
482  
483 # throw away empty chunks and all 2-value arrayrefs: the thinking is that these are
484 # bind value specs left in by the sloppy renderer above. It is ok to do this
485 # at this point, since we are going to end up rewriting this crap anyway
486 1125 for my $v (values %$to_scan) {
487 5625 my @nv;
488 5625 for (@$v) {
489 next if (
490 10721 ▶ ! defined $_
Branch: 1 branch
BranchTrueFalseTotal
if not defined $_ or ref $_ eq "ARRAY" and @$_ == 0 || @$_ == 2 459 10262 10721
Condition33%3/9
not defined $_ or ref $_ eq "ARRAY" and @$_ == 0 || @$_ == 2
l!l&&r!l&&!r
459010262
ref $_ eq "ARRAY" and @$_ == 0 || @$_ == 2
!ll&&!rl&&r
1026200
@$_ == 0 or @$_ == 2
l!l&&r!l&&!r
000
MC/DC25%1/4
not defined $_ or ref $_ eq "ARRAY" and @$_ == 0 || @$_ == 2
not defined $_ ref $_ eq "ARRAY" @$_ == 0 @$_ == 2
Truth table40%2/5
not(A) or B and C or D
A= not defined $_B= ref $_ eq "ARRAY"C= @$_ == 0D= @$_ == 2
ABCDresult
1XXX1
011X1
01011
00XX0
01000
491 or
492 (
493 ref $_ eq 'ARRAY'
494 and
495 ( @$_ == 0 or @$_ == 2 )
496 )
497 );
498  
499 10262 ▶ if (ref $_) {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $_) 0 10262 10262
500 0 require Data::Dumper::Concise;
501 0 $self->throw_exception("Unexpected ref in scan-plan: " . Data::Dumper::Concise::Dumper($v) );
502 }
503  
504 10262 push @nv, $_;
505 }
506  
507 5625 $v = \@nv;
508 }
509  
510 # kill all selectors which look like a proper subquery
511 # this is a sucky heuristic *BUT* - if we get it wrong the query will simply
512 # fail to run, so we are relatively safe
513 $to_scan->{selecting} = [ grep {
514 5329 $_ !~ / \A \s* \( \s* SELECT \s+ .+? \s+ FROM \s+ .+? \) \s* \z /xsi
515 1125 ▶ } @{ $to_scan->{selecting} || [] } ];
Condition50%1/2
$to_scan->{'selecting'} || []
l!l
11250
MC/DC0%0/1
$to_scan->{'selecting'} || []
$to_scan->{'selecting'}
Truth table50%1/2
A
A= $to_scan->{'selecting'}
Aresult
11
00
516  
517 # first see if we have any exact matches (qualified or unqualified)
518 1125 for my $type (keys %$to_scan) {
519 5625 for my $piece (@{$to_scan->{$type}}) {
520 10232 ▶ if ($colinfo->{$piece} and my $alias = $colinfo->{$piece}{-source_alias}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($colinfo->{$piece} and my $alias = $colinfo->{$piece}{"-source_alias"}) 670 9562 10232
Condition66%2/3
$colinfo->{$piece} and my $alias = $colinfo->{$piece}{"-source_alias"}
!ll&&!rl&&r
95620670
MC/DC50%1/2
$colinfo->{$piece} and my $alias = $colinfo->{$piece}{"-source_alias"}
$colinfo->{$piece} my $alias = $colinfo->{$piece}{"-source_alias"}
Truth table66%2/3
A and B
A= $colinfo->{$piece}B= my $alias = $colinfo->{$piece}{"-source_alias"}
ABresult
0X0
100
111
521 670 ▶ $aliases_by_type->{$type}{$alias} ||= { -parents => $alias_list->{$alias}{-join_path}||[] };
Condition100%4/4
$aliases_by_type->{$type}{$alias} ||= {"-parents", $alias_list->{$alias}{"-join_path"} || []}
l!l
153517
$alias_list->{$alias}{'-join_path'} || []
l!l
265252
MC/DC100%1/1
$aliases_by_type->{$type}{$alias} ||= {"-parents", $alias_list->{$alias}{"-join_path"} || []}
$aliases_by_type->{$type}{$alias}
MC/DC100%1/1
$alias_list->{$alias}{'-join_path'} || []
$alias_list->{$alias}{'-join_path'}
Truth table100%2/2
A
A= $aliases_by_type->{$type}{$alias}
Aresult
11
00
Truth table100%2/2
A
A= $alias_list->{$alias}{'-join_path'}
Aresult
11
00
522 670 $aliases_by_type->{$type}{$alias}{-seen_columns}{$colinfo->{$piece}{-fq_colname}} = $piece;
523 }
524 }
525 }
526  
527 # now loop through all fully qualified columns and get the corresponding
528 # alias (should work even if they are in scalarrefs)
529 1125 for my $alias (keys %$alias_list) {
530 2886 my $al_re = qr/
531 $lquote $alias $rquote $sep (?: $lquote ([^$rquote]+) $rquote )?
532 |
533 \b $alias \. ([^\s\)\($rquote]+)?
534 /x;
535  
536 2886 for my $type (keys %$to_scan) {
537 14430 for my $piece (@{$to_scan->{$type}}) {
538 28058 ▶ if (my @matches = $piece =~ /$al_re/g) {
Branch: 1 branch
BranchTrueFalseTotal
if (my(@matches) = $piece =~ /$al_re/g) 9019 19039 28058
539 9019 ▶ $aliases_by_type->{$type}{$alias} ||= { -parents => $alias_list->{$alias}{-join_path}||[] };
Condition100%4/4
$aliases_by_type->{$type}{$alias} ||= {"-parents", $alias_list->{$alias}{"-join_path"} || []}
l!l
38795140
$alias_list->{$alias}{'-join_path'} || []
l!l
30532087
MC/DC100%1/1
$aliases_by_type->{$type}{$alias} ||= {"-parents", $alias_list->{$alias}{"-join_path"} || []}
$aliases_by_type->{$type}{$alias}
MC/DC100%1/1
$alias_list->{$alias}{'-join_path'} || []
$alias_list->{$alias}{'-join_path'}
Truth table100%2/2
A
A= $aliases_by_type->{$type}{$alias}
Aresult
11
00
Truth table100%2/2
A
A= $alias_list->{$alias}{'-join_path'}
Aresult
11
00
540 $aliases_by_type->{$type}{$alias}{-seen_columns}{"$alias.$_"} = "$alias.$_"
541 9019 for grep { defined $_ } @matches;
542 }
543 }
544 }
545 }
546  
547 # now loop through unqualified column names, and try to locate them within
548 # the chunks
549 1125 for my $col (keys %$colinfo) {
550 22158 ▶ next if $col =~ / \. /x; # if column is qualified it was caught by the above
Branch: 1 branch
BranchTrueFalseTotal
if $col =~ / \. /x 12682 9476 22158
551  
552 9476 my $col_re = qr/ $lquote ($col) $rquote /x;
553  
554 9476 for my $type (keys %$to_scan) {
555 47380 for my $piece (@{$to_scan->{$type}}) {
556 88205 ▶ if ( my @matches = $piece =~ /$col_re/g) {
Branch: 1 branch
BranchTrueFalseTotal
if (my(@matches) = $piece =~ /$col_re/g) 1563 86642 88205
557 1563 my $alias = $colinfo->{$col}{-source_alias};
558 1563 ▶ $aliases_by_type->{$type}{$alias} ||= { -parents => $alias_list->{$alias}{-join_path}||[] };
Condition100%4/4
$aliases_by_type->{$type}{$alias} ||= {"-parents", $alias_list->{$alias}{"-join_path"} || []}
l!l
1341222
$alias_list->{$alias}{'-join_path'} || []
l!l
39183
MC/DC100%1/1
$aliases_by_type->{$type}{$alias} ||= {"-parents", $alias_list->{$alias}{"-join_path"} || []}
$aliases_by_type->{$type}{$alias}
MC/DC100%1/1
$alias_list->{$alias}{'-join_path'} || []
$alias_list->{$alias}{'-join_path'}
Truth table100%2/2
A
A= $aliases_by_type->{$type}{$alias}
Aresult
11
00
Truth table100%2/2
A
A= $alias_list->{$alias}{'-join_path'}
Aresult
11
00
559 $aliases_by_type->{$type}{$alias}{-seen_columns}{"$alias.$_"} = $_
560 1563 for grep { defined $_ } @matches;
561 }
562 }
563 }
564 }
565  
566 # Add any non-left joins to the restriction list (such joins are indeed restrictions)
567 1125 for my $j (values %$alias_list) {
568 2886 ▶ my $alias = $j->{-alias} or next;
Branch: 1 branch
BranchTrueFalseTotal
my $alias = $j->{"-alias"} or next 2886 0 2886
569 $aliases_by_type->{restricting}{$alias} ||= { -parents => $j->{-join_path}||[] } if (
570 (not $j->{-join_type})
571 or
572 2886 ▶ ($j->{-join_type} !~ /^left (?: \s+ outer)? $/xi)
Branch: 1 branch
BranchTrueFalseTotal
unless $j->{"-join_type"} and $j->{"-join_type"} =~ /^left (?: \s+ outer)? $/xi 1843 1043 2886
Condition100%7/7
$j->{"-join_type"} and $j->{"-join_type"} =~ /^left (?: \s+ outer)? $/xi
!ll&&!rl&&r
184211043
$aliases_by_type->{"restricting"}{$alias} ||= {"-parents", $j->{"-join_path"} || []}
l!l
6321211
$j->{'-join_path'} || []
l!l
644567
MC/DC100%2/2
$j->{"-join_type"} and $j->{"-join_type"} =~ /^left (?: \s+ outer)? $/xi
$j->{"-join_type"} $j->{"-join_type"} =~ /^left (?: \s+ outer)? $/xi
MC/DC100%1/1
$aliases_by_type->{"restricting"}{$alias} ||= {"-parents", $j->{"-join_path"} || []}
$aliases_by_type->{"restricting"}{$alias}
MC/DC100%1/1
$j->{'-join_path'} || []
$j->{'-join_path'}
Truth table100%3/3
A and B
A= $j->{"-join_type"}B= $j->{"-join_type"} =~ /^left (?: \s+ outer)? $/xi
ABresult
0X0
100
111
Truth table100%2/2
A
A= $aliases_by_type->{"restricting"}{$alias}
Aresult
11
00
Truth table100%2/2
A
A= $j->{'-join_path'}
Aresult
11
00
573 );
574 }
575  
576 1125 for (keys %$aliases_by_type) {
577 4529 ▶ delete $aliases_by_type->{$_} unless keys %{$aliases_by_type->{$_}};
Branch: 1 branch
BranchTrueFalseTotal
unless keys %{$$aliases_by_type{$_};} 48 4481 4529
578 }
579  
580 1125 return $aliases_by_type;
581 }
582  
583 # This is the engine behind { distinct => 1 } and the general
584 # complex prefetch grouper
585 110 ▶sub _group_over_selection {
Subroutine _group_over_selection: called CC=29 SCAR=33.8
586 110 my ($self, $attrs) = @_;
587  
588 110 my $colinfos = $self->_resolve_column_info ($attrs->{from});
589  
590 110 my (@group_by, %group_index);
591  
592 # the logic is: if it is a { func => val } we assume an aggregate,
593 # otherwise if \'...' or \[...] we assume the user knows what is
594 # going on thus group over it
595 110 for (@{$attrs->{select}}) {
596 413 ▶ if (! ref($_) or ref ($_) ne 'HASH' ) {
Branch: 1 branch
BranchTrueFalseTotal
if (not ref $_ or ref $_ ne "HASH") 399 14 413
Condition100%3/3
not ref $_ or ref $_ ne "HASH"
l!l&&r!l&&!r
3821714
MC/DC100%2/2
not ref $_ or ref $_ ne "HASH"
not ref $_ ref $_ ne "HASH"
Truth table100%3/3
not(A) or B
A= not ref $_B= ref $_ ne "HASH"
ABresult
1X1
011
000
597 399 push @group_by, $_;
598 399 $group_index{$_}++;
599 399 ▶ if ($colinfos->{$_} and $_ !~ /\./ ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($colinfos->{$_} and not $_ =~ /\./) 0 399 399
Condition66%2/3
$colinfos->{$_} and not $_ =~ /\./
!ll&&!rl&&r
173820
MC/DC0%0/2
$colinfos->{$_} and not $_ =~ /\./
$colinfos->{$_} not $_ =~ /\./
Truth table66%2/3
A and not(B)
A= $colinfos->{$_}B= not $_ =~ /\./
ABresult
0X0
100
111
600 # add a fully qualified version as well
601 0 $group_index{"$colinfos->{$_}{-source_alias}.$_"}++;
602 }
603 }
604 }
605  
606 my @order_by = $self->_extract_order_criteria($attrs->{order_by})
607 110 ▶ or return (\@group_by, $attrs->{order_by});
Branch: 1 branch
BranchTrueFalseTotal
my(@order_by) = $self->_extract_order_criteria($attrs->{"order_by"}) or return \@group_by, $attrs->{"order_by"} 66 44 110
608  
609 # add any order_by parts that are not already present in the group_by
610 # to maintain SQL cross-compatibility and general sanity
611 #
612 # also in case the original selection is *not* unique, or in case part
613 # of the ORDER BY refers to a multiplier - we will need to replace the
614 # skipped order_by elements with their MIN/MAX equivalents as to maintain
615 # the proper overall order without polluting the group criteria (and
616 # possibly changing the outcome entirely)
617  
618 66 my ($leftovers, $sql_maker, @new_order_by, $order_chunks, $aliastypes);
619  
620 66 my $group_already_unique = $self->_columns_comprise_identifying_set($colinfos, \@group_by);
621  
622 66 for my $o_idx (0 .. $#order_by) {
623  
624 # if the chunk is already a min/max function - there is nothing left to touch
625 166 ▶ next if $order_by[$o_idx][0] =~ /^ (?: min | max ) \s* \( .+ \) $/ix;
Branch: 1 branch
BranchTrueFalseTotal
if $order_by[$o_idx][0] =~ /^ (?: min | max ) \s* \( .+ \) $/xi 0 166 166
626  
627 # only consider real columns (for functions the user got to do an explicit group_by)
628 166 my $chunk_ci;
629 166 ▶ if (
Branch: 1 branch
BranchTrueFalseTotal
if (@{$order_by[$o_idx];} != 1 or not $chunk_ci = $$colinfos{$order_by[$o_idx][0]} and $attrs->{"_aliastypes"}) 1 165 166
Condition66%2/3
@{$order_by[$o_idx];} != 1 or not $chunk_ci = $$colinfos{$order_by[$o_idx][0]} and $attrs->{"_aliastypes"}
l!l&&r!l&&!r
01165
MC/DC50%1/2
@{$order_by[$o_idx];} != 1 or not $chunk_ci = $$colinfos{$order_by[$o_idx][0]} and $attrs->{"_aliastypes"}
@{$order_by[$o_idx];} != 1 not $chunk_ci = $$colinfos{$order_by[$o_idx][0]} and $attrs->{"_aliastypes"}
Truth table66%2/3
A or B
A= @{$order_by[$o_idx];} != 1B= not $chunk_ci = $$colinfos{$order_by[$o_idx][0]} and $attrs->{"_aliastypes"}
ABresult
1X1
011
000
630 166 ▶ @{$order_by[$o_idx]} != 1
Condition100%3/3
not $chunk_ci = $$colinfos{$order_by[$o_idx][0]} and $attrs->{"_aliastypes"}
!ll&&!rl&&r
16321
MC/DC100%2/2
not $chunk_ci = $$colinfos{$order_by[$o_idx][0]} and $attrs->{"_aliastypes"}
not $chunk_ci = $$colinfos{$order_by[$o_idx][0]} $attrs->{"_aliastypes"}
Truth table100%3/3
not(A) and B
A= not $chunk_ci = $$colinfos{$order_by[$o_idx][0]}B= $attrs->{"_aliastypes"}
ABresult
0X0
100
111
631 or
632 # only declare an unknown *plain* identifier as "leftover" if we are called with
633 # aliastypes to examine. If there are none - we are still in _resolve_attrs, and
634 # can just assume the user knows what they want
635 ( ! ( $chunk_ci = $colinfos->{$order_by[$o_idx][0]} ) and $attrs->{_aliastypes} )
636 ) {
637 1 push @$leftovers, $order_by[$o_idx][0];
638 }
639  
640 166 ▶ next unless $chunk_ci;
Branch: 1 branch
BranchTrueFalseTotal
unless $chunk_ci 3 163 166
641  
642 # no duplication of group criteria
643 163 ▶ next if $group_index{$chunk_ci->{-fq_colname}};
Branch: 1 branch
BranchTrueFalseTotal
if $group_index{$chunk_ci->{"-fq_colname"}} 88 75 163
644  
645 $aliastypes ||= (
646 $attrs->{_aliastypes}
647 or
648 $self->_resolve_aliastypes_from_select_args({
649 from => $attrs->{from},
650 order_by => $attrs->{order_by},
651 })
652 75 ▶ ) if $group_already_unique;
Branch: 1 branch
BranchTrueFalseTotal
if $group_already_unique 61 14 75
Condition66%4/6
$aliastypes ||= $attrs->{"_aliastypes"} || $self->_resolve_aliastypes_from_select_args({"from", $attrs->{"from"}, "order_by", $attrs->{"order_by"}})
l!l&&r!l&&!r
25360
$attrs->{'_aliastypes'} || $self->_resolve_aliastypes_from_select_args({'from', $attrs->{'from'}, 'order_by', $attrs->{'order_by'}})
l!l&&r!l&&!r
2880
MC/DC0%0/3
$aliastypes ||= $attrs->{"_aliastypes"} || $self->_resolve_aliastypes_from_select_args({"from", $attrs->{"from"}, "order_by", $attrs->{"order_by"}})
$aliastypes $attrs->{'_aliastypes'} $self->_resolve_aliastypes_from_select_args({'from', $attrs->{'from'}, 'order_by', $attrs->{'order_by'}})
Truth table0%0/4
A ||= B || C
A= $aliastypesB= $attrs->{'_aliastypes'}C= $self->_resolve_aliastypes_from_select_args({'from', $attrs->{'from'}, 'order_by', $attrs->{'order_by'}})
ABCresult
1XX1
01X1
0011
0000
653  
654 # check that we are not ordering by a multiplier (if a check is requested at all)
655 75 ▶ if (
Branch: 1 branch
BranchTrueFalseTotal
if ($group_already_unique and not $aliastypes->{'multiplying'}{$chunk_ci->{'-source_alias'}} and not $aliastypes->{'premultiplied'}{$chunk_ci->{'-source_alias'}}) { } 16 59 75
Condition100%6/6
$group_already_unique and not $aliastypes->{"multiplying"}{$chunk_ci->{"-source_alias"}} and not $aliastypes->{"premultiplied"}{$chunk_ci->{"-source_alias"}}
!ll&&!rl&&r
471216
$group_already_unique and not $aliastypes->{"multiplying"}{$chunk_ci->{"-source_alias"}}
!ll&&!rl&&r
143328
MC/DC100%3/3
$group_already_unique and not $aliastypes->{"multiplying"}{$chunk_ci->{"-source_alias"}} and not $aliastypes->{"premultiplied"}{$chunk_ci->{"-source_alias"}}
$group_already_unique not $aliastypes->{"multiplying"}{$chunk_ci->{"-source_alias"}} not $aliastypes->{"premultiplied"}{$chunk_ci->{"-source_alias"}}
Truth table100%4/4
A and not(B) and not(C)
A= $group_already_uniqueB= not $aliastypes->{"multiplying"}{$chunk_ci->{"-source_alias"}}C= not $aliastypes->{"premultiplied"}{$chunk_ci->{"-source_alias"}}
ABCresult
0XX0
10X0
1100
1111
656 $group_already_unique
657 and
658 ! $aliastypes->{multiplying}{$chunk_ci->{-source_alias}}
659 and
660 ! $aliastypes->{premultiplied}{$chunk_ci->{-source_alias}}
661 ) {
662 16 push @group_by, $chunk_ci->{-fq_colname};
663 16 $group_index{$chunk_ci->{-fq_colname}}++
664 }
665 else {
666 # We need to order by external columns without adding them to the group
667 # (eiehter a non-unique selection, or a multi-external)
668 #
669 # This doesn't really make sense in SQL, however from DBICs point
670 # of view is rather valid (e.g. order the leftmost objects by whatever
671 # criteria and get the offset/rows many). There is a way around
672 # this however in SQL - we simply tae the direction of each piece
673 # of the external order and convert them to MIN(X) for ASC or MAX(X)
674 # for DESC, and group_by the root columns. The end result should be
675 # exactly what we expect
676 #
677  
678 # both populated on the first loop over $o_idx
679 59 ▶ $sql_maker ||= $self->sql_maker;
Condition66%2/3
$sql_maker ||= $self->sql_maker
l!l&&r!l&&!r
13460
MC/DC0%0/2
$sql_maker ||= $self->sql_maker
$sql_maker $self->sql_maker
Truth table66%2/3
A ||= B
A= $sql_makerB= $self->sql_maker
ABresult
1X1
011
000
680 $order_chunks ||= [
681 145 ▶ map { ref $_ eq 'ARRAY' ? $_ : [ $_ ] } $sql_maker->_order_by_chunks($attrs->{order_by})
Branch: 1 branch
BranchTrueFalseTotal
ref $_ eq 'ARRAY' ? : 105 40 145
682 59 ▶ ];
Condition100%2/2
$order_chunks ||= [map({ref $_ eq "ARRAY" ? $_ : [$_];} $sql_maker->_order_by_chunks($attrs->{"order_by"}))]
l!l
1346
MC/DC100%1/1
$order_chunks ||= [map({ref $_ eq "ARRAY" ? $_ : [$_];} $sql_maker->_order_by_chunks($attrs->{"order_by"}))]
$order_chunks
Truth table100%2/2
A
A= $order_chunks
Aresult
11
00
683  
684 59 my ($chunk, $is_desc) = $sql_maker->_split_order_chunk($order_chunks->[$o_idx][0]);
685  
686 $new_order_by[$o_idx] = \[
687 sprintf( '%s( %s )%s',
688 $self->_minmax_operator_for_datatype($chunk_ci->{data_type}, $is_desc),
689 $chunk,
690 ($is_desc ? ' DESC' : ''),
691 ),
692 59 ▶ @ {$order_chunks->[$o_idx]} [ 1 .. $#{$order_chunks->[$o_idx]} ]
Branch: 1 branch
BranchTrueFalseTotal
$is_desc ? : 40 19 59
693 ];
694 }
695 }
696  
697 $self->throw_exception ( sprintf
698 'Unable to programatically derive a required group_by from the supplied '
699 . 'order_by criteria. To proceed either add an explicit group_by, or '
700 . 'simplify your order_by to only include plain columns '
701 . '(supplied order_by: %s)',
702 66 ▶ join ', ', map { "'$_'" } @$leftovers,
Branch: 1 branch
BranchTrueFalseTotal
if $leftovers 1 65 66
703 ) if $leftovers;
704  
705 # recreate the untouched order parts
706 65 ▶ if (@new_order_by) {
Branch: 1 branch
BranchTrueFalseTotal
if (@new_order_by) 46 19 65
707 46 ▶ $new_order_by[$_] ||= \ $order_chunks->[$_] for ( 0 .. $#$order_chunks );
Condition100%2/2
$new_order_by[$_] ||= \$order_chunks->[$_]
l!l
5986
MC/DC100%1/1
$new_order_by[$_] ||= \$order_chunks->[$_]
$new_order_by[$_]
Truth table100%2/2
A
A= $new_order_by[$_]
Aresult
11
00
708 }
709  
710 return (
711 \@group_by,
712 65 ▶ (@new_order_by ? \@new_order_by : $attrs->{order_by} ), # same ref as original == unchanged
Branch: 1 branch
BranchTrueFalseTotal
@new_order_by ? : 46 19 65
713 );
714 }
715  
716 57 ▶sub _minmax_operator_for_datatype {
Subroutine _minmax_operator_for_datatype: called CC=2 SCAR=6.9
717 #my ($self, $datatype, $want_max) = @_;
718  
719 57 ▶ $_[2] ? 'MAX' : 'MIN';
Branch: 1 branch
BranchTrueFalseTotal
$_[2] ? : 39 18 57
720 }
721  
722 8114 ▶sub _resolve_ident_sources {
Subroutine _resolve_ident_sources: called CC=9 SCAR=22.5
723 8114 my ($self, $ident) = @_;
724  
725 8114 my $alias2source = {};
726  
727 # the reason this is so contrived is that $ident may be a {from}
728 # structure, specifying multiple tables to join
729 8114 ▶ if ( blessed $ident && $ident->isa("DBIx::Class::ResultSource") ) {
Branch: 2 branches
BranchTrueFalseTotal
if (builtin::blessed($ident) and $ident->isa('DBIx::Class::ResultSource')) { } 0 8114 8114
elsif (ref $ident eq 'ARRAY') { } 8113 1 8114
Condition33%1/3
builtin::blessed($ident) and $ident->isa("DBIx::Class::ResultSource")
!ll&&!rl&&r
811400
MC/DC0%0/2
builtin::blessed($ident) and $ident->isa("DBIx::Class::ResultSource")
builtin::blessed($ident) $ident->isa("DBIx::Class::ResultSource")
Truth table33%1/3
A and B
A= builtin::blessed($ident)B= $ident->isa("DBIx::Class::ResultSource")
ABresult
0X0
100
111
730 # this is compat mode for insert/update/delete which do not deal with aliases
731 0 $alias2source->{me} = $ident;
732 }
733 elsif (ref $ident eq 'ARRAY') {
734  
735 8113 for (@$ident) {
736 11397 my $tabinfo;
737 11397 ▶ if (ref $_ eq 'HASH') {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $_ eq "HASH") 8247 3150 11397
738 8247 $tabinfo = $_;
739 }
740 11397 ▶ if (ref $_ eq 'ARRAY' and ref $_->[0] eq 'HASH') {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $_ eq "ARRAY" and ref $_->[0] eq "HASH") 3150 8247 11397
Condition66%2/3
ref $_ eq "ARRAY" and ref $_->[0] eq "HASH"
!ll&&!rl&&r
824703150
MC/DC50%1/2
ref $_ eq "ARRAY" and ref $_->[0] eq "HASH"
ref $_ eq "ARRAY" ref $_->[0] eq "HASH"
Truth table66%2/3
A and B
A= ref $_ eq "ARRAY"B= ref $_->[0] eq "HASH"
ABresult
0X0
100
111
741 3150 $tabinfo = $_->[0];
742 }
743  
744 $alias2source->{$tabinfo->{-alias}} = $tabinfo->{-rsrc}
745 11397 ▶ if ($tabinfo->{-rsrc});
Branch: 1 branch
BranchTrueFalseTotal
if $tabinfo->{"-rsrc"} 11382 15 11397
746 }
747 }
748  
749 8114 return $alias2source;
750 }
751  
752 # Takes $ident, \@column_names
753 #
754 # returns { $column_name => \%column_info, ... }
755 # also note: this adds -result_source => $rsrc to the column info
756 #
757 # If no columns_names are supplied returns info about *all* columns
758 # for all sources
759 8114 ▶sub _resolve_column_info {
Subroutine _resolve_column_info: called CC=17 SCAR=28.7
760 8114 my ($self, $ident, $colnames) = @_;
761  
762 8114 ▶ return {} if $colnames and ! @$colnames;
Branch: 1 branch
BranchTrueFalseTotal
if $colnames and not @$colnames 0 8114 8114
Condition66%2/3
$colnames and not @$colnames
!ll&&!rl&&r
8084300
MC/DC0%0/2
$colnames and not @$colnames
$colnames not @$colnames
Truth table66%2/3
A and not(B)
A= $colnamesB= not @$colnames
ABresult
0X0
100
111
763  
764 8114 my $alias2src = $self->_resolve_ident_sources($ident);
765  
766 8114 my (%seen_cols, @auto_colnames);
767  
768 # compile a global list of column names, to be able to properly
769 # disambiguate unqualified column names (if at all possible)
770 8114 for my $alias (keys %$alias2src) {
771 11382 my $rsrc = $alias2src->{$alias};
772 11382 for my $colname ($rsrc->columns) {
773 57934 push @{$seen_cols{$colname}}, $alias;
774 57934 ▶ push @auto_colnames, "$alias.$colname" unless $colnames;
Branch: 1 branch
BranchTrueFalseTotal
unless $colnames 57736 198 57934
775 }
776 }
777  
778 $colnames ||= [
779 @auto_colnames,
780 8114 ▶ grep { @{$seen_cols{$_}} == 1 } (keys %seen_cols),
Condition100%2/2
$colnames ||= [@auto_colnames, grep({@{$seen_cols{$_};} == 1;} keys %seen_cols)]
l!l
308084
MC/DC100%1/1
$colnames ||= [@auto_colnames, grep({@{$seen_cols{$_};} == 1;} keys %seen_cols)]
$colnames
Truth table100%2/2
A
A= $colnames
Aresult
11
00
781 ];
782  
783 8114 my (%return, $colinfos);
784 8114 foreach my $col (@$colnames) {
785 109646 my ($source_alias, $colname) = $col =~ m/^ (?: ([^\.]+) \. )? (.+) $/x;
786  
787 # if the column was seen exactly once - we know which rsrc it came from
788 $source_alias ||= $seen_cols{$colname}[0]
789 109646 ▶ if ($seen_cols{$colname} and @{$seen_cols{$colname}} == 1);
Branch: 1 branch
BranchTrueFalseTotal
if $seen_cols{$colname} and @{$seen_cols{$colname};} == 1 103721 5925 109646
Condition83%5/6
$seen_cols{$colname} and @{$seen_cols{$colname};} == 1
!ll&&!rl&&r
185907103721
$source_alias ||= $seen_cols{$colname}[0]
l!l&&r!l&&!r
51839518820
MC/DC100%2/2
$seen_cols{$colname} and @{$seen_cols{$colname};} == 1
$seen_cols{$colname} @{$seen_cols{$colname};} == 1
MC/DC0%0/2
$source_alias ||= $seen_cols{$colname}[0]
$source_alias $seen_cols{$colname}[0]
Truth table100%3/3
A and B
A= $seen_cols{$colname}B= @{$seen_cols{$colname};} == 1
ABresult
0X0
100
111
Truth table66%2/3
A ||= B
A= $source_aliasB= $seen_cols{$colname}[0]
ABresult
1X1
011
000
790  
791 109646 ▶ next unless $source_alias;
Branch: 1 branch
BranchTrueFalseTotal
unless $source_alias 18 109628 109646
792  
793 109628 ▶ my $rsrc = $alias2src->{$source_alias}
Branch: 1 branch
BranchTrueFalseTotal
my $rsrc = $alias2src->{$source_alias} or next 109628 0 109628
794 or next;
795  
796 $return{$col} = {
797 %{
798 109628 ▶ ( $colinfos->{$source_alias} ||= $rsrc->columns_info )->{$colname}
Branch: 1 branch
BranchTrueFalseTotal
$col eq $colname ? : 51882 57746 109628
Condition50%3/6
+($colinfos->{$source_alias} ||= $rsrc->columns_info)->{$colname} || $self->throw_exception("No such column '${colname}' on source " . $rsrc->source_name)
l!l&&r!l&&!r
10962800
$colinfos->{$source_alias} ||= $rsrc->columns_info
l!l&&r!l&&!r
98269113590
MC/DC0%0/2
+($colinfos->{$source_alias} ||= $rsrc->columns_info)->{$colname} || $self->throw_exception("No such column '${colname}' on source " . $rsrc->source_name)
+($colinfos->{$source_alias} ||= $rsrc->columns_info)->{$colname} $self->throw_exception("No such column '${colname}' on source " . $rsrc->source_name)
MC/DC0%0/2
$colinfos->{$source_alias} ||= $rsrc->columns_info
$colinfos->{$source_alias} $rsrc->columns_info
Truth table33%1/3
A || B
A= +($colinfos->{$source_alias} ||= $rsrc->columns_info)->{$colname}B= $self->throw_exception("No such column '${colname}' on source " . $rsrc->source_name)
ABresult
1X1
011
000
Truth table66%2/3
A ||= B
A= $colinfos->{$source_alias}B= $rsrc->columns_info
ABresult
1X1
011
000
799 ||
800 $self->throw_exception(
801 "No such column '$colname' on source " . $rsrc->source_name
802 );
803 },
804 -result_source => $rsrc,
805 -source_alias => $source_alias,
806 -fq_colname => $col eq $colname ? "$source_alias.$col" : $col,
807 -colname => $colname,
808 };
809  
810 109628 ▶ $return{"$source_alias.$colname"} = $return{$col} if $col eq $colname;
Branch: 1 branch
BranchTrueFalseTotal
if $col eq $colname 51882 57746 109628
811 }
812  
813 8114 return \%return;
814 }
815  
816 # The DBIC relationship chaining implementation is pretty simple - every
817 # new related_relationship is pushed onto the {from} stack, and the {select}
818 # window simply slides further in. This means that when we count somewhere
819 # in the middle, we got to make sure that everything in the join chain is an
820 # actual inner join, otherwise the count will come back with unpredictable
821 # results (a resultset may be generated with _some_ rows regardless of if
822 # the relation which the $rs currently selects has rows or not). E.g.
823 # $artist_rs->cds->count - normally generates:
824 # SELECT COUNT( * ) FROM artist me LEFT JOIN cd cds ON cds.artist = me.artistid
825 # which actually returns the number of artists * (number of cds || 1)
826 #
827 # So what we do here is crawl {from}, determine if the current alias is at
828 # the top of the stack, and if not - make sure the chain is inner-joined down
829 # to the root.
830 #
831 216 ▶sub _inner_join_to_node {
Subroutine _inner_join_to_node: called CC=5 SCAR=16.1
832 216 my ($self, $from, $alias) = @_;
833  
834 216 my $switch_branch = $self->_find_join_path_to_node($from, $alias);
835  
836 216 ▶ return $from unless @{$switch_branch||[]};
Branch: 1 branch
BranchTrueFalseTotal
unless @{$switch_branch or [];} 0 216 216
Condition50%1/2
$switch_branch || []
l!l
2160
MC/DC0%0/1
$switch_branch || []
$switch_branch
Truth table50%1/2
A
A= $switch_branch
Aresult
11
00
837  
838 # So it looks like we will have to switch some stuff around.
839 # local() is useless here as we will be leaving the scope
840 # anyway, and deep cloning is just too fucking expensive
841 # So replace the first hashref in the node arrayref manually
842 216 my @new_from = ($from->[0]);
843 216 my $sw_idx = { map { (values %$_), 1 } @$switch_branch }; #there's one k/v per join-path
844  
845 216 for my $j (@{$from}[1 .. $#$from]) {
846 277 my $jalias = $j->[0]{-alias};
847  
848 277 ▶ if ($sw_idx->{$jalias}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($sw_idx->{$jalias}) { } 247 30 277
849 247 my %attrs = %{$j->[0]};
850 247 delete $attrs{-join_type};
851 push @new_from, [
852 \%attrs,
853 247 @{$j}[ 1 .. $#$j ],
854 ];
855 }
856 else {
857 30 push @new_from, $j;
858 }
859 }
860  
861 216 return \@new_from;
862 }
863  
864 259 ▶sub _find_join_path_to_node {
Subroutine _find_join_path_to_node: called CC=8 SCAR=23.7
865 259 my ($self, $from, $target_alias) = @_;
866  
867 # subqueries and other oddness are naturally not supported
868 return undef if (
869 ref $from ne 'ARRAY'
870 ||
871 ref $from->[0] ne 'HASH'
872 ||
873 ! defined $from->[0]{-alias}
874 259 ▶ );
Branch: 1 branch
BranchTrueFalseTotal
if ref $from ne "ARRAY" or ref $from->[0] ne "HASH" or not defined $from->[0]{"-alias"} 0 259 259
Condition33%2/6
ref $from ne "ARRAY" or ref $from->[0] ne "HASH" or not defined $from->[0]{"-alias"}
l!l&&r!l&&!r
00259
ref $from ne "ARRAY" or ref $from->[0] ne "HASH"
l!l&&r!l&&!r
00259
MC/DC0%0/3
ref $from ne "ARRAY" or ref $from->[0] ne "HASH" or not defined $from->[0]{"-alias"}
ref $from ne "ARRAY" ref $from->[0] ne "HASH" not defined $from->[0]{"-alias"}
Truth table25%1/4
A or B or not(C)
A= ref $from ne "ARRAY"B= ref $from->[0] ne "HASH"C= not defined $from->[0]{"-alias"}
ABCresult
1XX1
01X1
0011
0000
875  
876 # no path - the head is the alias
877 259 ▶ return [] if $from->[0]{-alias} eq $target_alias;
Branch: 1 branch
BranchTrueFalseTotal
if $from->[0]{"-alias"} eq $target_alias 41 218 259
878  
879 218 for my $i (1 .. $#$from) {
880 270 ▶ return $from->[$i][0]{-join_path} if ( ($from->[$i][0]{-alias}||'') eq $target_alias );
Branch: 1 branch
BranchTrueFalseTotal
if ($from->[$i][0]{"-alias"} || "") eq $target_alias 218 52 270
Condition50%1/2
$from->[$i][0]{'-alias'} || ''
l!l
2700
MC/DC0%0/1
$from->[$i][0]{'-alias'} || ''
$from->[$i][0]{'-alias'}
Truth table50%1/2
A
A= $from->[$i][0]{'-alias'}
Aresult
11
00
881 }
882  
883 # something else went quite wrong
884 0 return undef;
885 }
886  
887 2043 ▶sub _extract_order_criteria {
Subroutine _extract_order_criteria: called CC=2 SCAR=6.9
888 2043 my ($self, $order_by, $sql_maker) = @_;
889  
890 2043 ▶ my $parser = sub {
Subroutine __ANON__: called CC=6 SCAR=17.9
891 2043 my ($sql_maker, $order_by, $orig_quote_chars) = @_;
892  
893 2043 ▶ return scalar $sql_maker->_order_by_chunks ($order_by)
Branch: 1 branch
BranchTrueFalseTotal
unless wantarray 22 2021 2043
894 unless wantarray;
895  
896 2021 ▶ my ($lq, $rq, $sep) = map { quotemeta($_) } (
Branch: 1 branch
BranchTrueFalseTotal
$orig_quote_chars ? : 896 1125 2021
897 ($orig_quote_chars ? @$orig_quote_chars : $sql_maker->_quote_chars),
898 $sql_maker->name_sep
899 );
900  
901 2021 my @chunks;
902 2021 for ($sql_maker->_order_by_chunks ($order_by) ) {
903 1253 ▶ my $chunk = ref $_ ? [ @$_ ] : [ $_ ];
Branch: 1 branch
BranchTrueFalseTotal
ref $_ ? : 683 570 1253
904 1253 ($chunk->[0]) = $sql_maker->_split_order_chunk($chunk->[0]);
905  
906 # order criteria may have come back pre-quoted (literals and whatnot)
907 # this is fragile, but the best we can currently do
908 1253 ▶ $chunk->[0] =~ s/^ $lq (.+?) $rq $sep $lq (.+?) $rq $/"$1.$2"/xe
Branch: 1 branch
BranchTrueFalseTotal
$chunk->[0] =~ s/^ $lq (.+?) $rq $sep $lq (.+?) $rq $/"$1.$2";/ex or $chunk->[0] =~ s/^ $lq (.+) $rq $/$1/x 395 858 1253
909 or $chunk->[0] =~ s/^ $lq (.+) $rq $/$1/x;
910  
911 1253 push @chunks, $chunk;
912 }
913  
914 2021 return @chunks;
915 2043 };
916  
917 2043 ▶ if ($sql_maker) {
Branch: 1 branch
BranchTrueFalseTotal
if ($sql_maker) { } 1125 918 2043
918 1125 return $parser->($sql_maker, $order_by);
919 }
920 else {
921 918 $sql_maker = $self->sql_maker;
922  
923 # pass these in to deal with literals coming from
924 # the user or the deep guts of prefetch
925 918 my $orig_quote_chars = [$sql_maker->_quote_chars];
926  
927 918 local $sql_maker->{quote_char};
928 918 return $parser->($sql_maker, $order_by, $orig_quote_chars);
929 }
930 }
931  
932 30 ▶sub _order_by_is_stable {
Subroutine _order_by_is_stable: called CC=4 SCAR=14.0
933 30 my ($self, $ident, $order_by, $where) = @_;
934  
935 my @cols = (
936 50 ▶ ( map { $_->[0] } $self->_extract_order_criteria($order_by) ),
Branch: 1 branch
BranchTrueFalseTotal
$where ? : 27 3 30
937 30 ▶ ( $where ? keys %{ $self->_extract_fixed_condition_columns($where) } : () ),
Branch: 1 branch
BranchTrueFalseTotal
my(@cols) = (map({$_->[0];} $self->_extract_order_criteria($order_by)), $where ? keys %{$self->_extract_fixed_condition_columns($where);} : ()) or return 0 30 0 30
938 ) or return 0;
939  
940 30 my $colinfo = $self->_resolve_column_info($ident, \@cols);
941  
942 30 ▶ return keys %$colinfo
Branch: 1 branch
BranchTrueFalseTotal
keys %$colinfo ? : 30 0 30
943 ? $self->_columns_comprise_identifying_set( $colinfo, \@cols )
944 : 0
945 ;
946 }
947  
948 96 ▶sub _columns_comprise_identifying_set {
Subroutine _columns_comprise_identifying_set: called CC=4 SCAR=13.9
949 96 my ($self, $colinfo, $columns) = @_;
950  
951 96 my $cols_per_src;
952 $cols_per_src -> {$_->{-source_alias}} -> {$_->{-colname}} = $_
953 96 for grep { defined $_ } @{$colinfo}{@$columns};
954  
955 96 for (values %$cols_per_src) {
956 89 my $src = (values %$_)[0]->{-result_source};
957 89 ▶ return 1 if $src->_identifying_column_set($_);
Branch: 1 branch
BranchTrueFalseTotal
if $src->_identifying_column_set($_) 77 12 89
958 }
959  
960 19 return 0;
961 }
962  
963 # this is almost similar to _order_by_is_stable, except it takes
964 # a single rsrc, and will succeed only if the first portion of the order
965 # by is stable.
966 # returns that portion as a colinfo hashref on success
967 43 ▶sub _extract_colinfo_of_stable_main_source_order_by_portion {
Subroutine _extract_colinfo_of_stable_main_source_order_by_portion: called CC=12 SCAR=25.0
968 43 my ($self, $attrs) = @_;
969  
970 43 my $nodes = $self->_find_join_path_to_node($attrs->{from}, $attrs->{alias});
971  
972 43 ▶ return unless defined $nodes;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $nodes 0 43 43
973  
974 my @ord_cols = map
975 124 { $_->[0] }
976 43 ( $self->_extract_order_criteria($attrs->{order_by}) )
977 ;
978 43 ▶ return unless @ord_cols;
Branch: 1 branch
BranchTrueFalseTotal
unless @ord_cols 0 43 43
979  
980 45 my $valid_aliases = { map { $_ => 1 } (
981 $attrs->{from}[0]{-alias},
982 43 map { values %$_ } @$nodes,
983 ) };
984  
985 43 my $colinfos = $self->_resolve_column_info($attrs->{from});
986  
987 43 my ($colinfos_to_return, $seen_main_src_cols);
988  
989 43 for my $col (@ord_cols) {
990 # if order criteria is unresolvable - there is nothing we can do
991 111 ▶ my $colinfo = $colinfos->{$col} or last;
Branch: 1 branch
BranchTrueFalseTotal
my $colinfo = $colinfos->{$col} or last 94 17 111
992  
993 # if we reached the end of the allowed aliases - also nothing we can do
994 94 ▶ last unless $valid_aliases->{$colinfo->{-source_alias}};
Branch: 1 branch
BranchTrueFalseTotal
unless $$valid_aliases{$colinfo->{"-source_alias"}} 8 86 94
995  
996 86 $colinfos_to_return->{$col} = $colinfo;
997  
998 $seen_main_src_cols->{$colinfo->{-colname}} = 1
999 86 ▶ if $colinfo->{-source_alias} eq $attrs->{alias};
Branch: 1 branch
BranchTrueFalseTotal
if $colinfo->{"-source_alias"} eq $attrs->{"alias"} 85 1 86
1000 }
1001  
1002 # FIXME the condition may be singling out things on its own, so we
1003 # conceivable could come back wi "stable-ordered by nothing"
1004 # not confient enough in the parser yet, so punt for the time being
1005 43 ▶ return unless $seen_main_src_cols;
Branch: 1 branch
BranchTrueFalseTotal
unless $seen_main_src_cols 8 35 43
1006  
1007 my $main_src_fixed_cols_from_cond = [ $attrs->{where}
1008 ? (
1009 map
1010 {
1011 ( $colinfos->{$_} and $colinfos->{$_}{-source_alias} eq $attrs->{alias} )
1012 ? $colinfos->{$_}{-colname}
1013 : ()
1014 26 ▶ }
Branch: 1 branch
BranchTrueFalseTotal
$colinfos->{$_} && $colinfos->{$_}{'-source_alias'} eq $attrs->{'alias'} ? : 25 1 26
Condition66%2/3
$colinfos->{$_} and $colinfos->{$_}{"-source_alias"} eq $attrs->{"alias"}
!ll&&!rl&&r
0125
MC/DC50%1/2
$colinfos->{$_} and $colinfos->{$_}{"-source_alias"} eq $attrs->{"alias"}
$colinfos->{$_} $colinfos->{$_}{"-source_alias"} eq $attrs->{"alias"}
Truth table66%2/3
A and B
A= $colinfos->{$_}B= $colinfos->{$_}{"-source_alias"} eq $attrs->{"alias"}
ABresult
0X0
100
111
1015 35 ▶ keys %{ $self->_extract_fixed_condition_columns($attrs->{where}) }
Branch: 1 branch
BranchTrueFalseTotal
$attrs->{'where'} ? : 19 16 35
1016 )
1017 : ()
1018 ];
1019  
1020 return $attrs->{result_source}->_identifying_column_set([
1021 35 ▶ keys %$seen_main_src_cols,
Branch: 1 branch
BranchTrueFalseTotal
$attrs->{'result_source'}->_identifying_column_set([keys %$seen_main_src_cols, @$main_src_fixed_cols_from_cond]) ? : 35 0 35
1022 @$main_src_fixed_cols_from_cond,
1023 ]) ? $colinfos_to_return : ();
1024 }
1025  
1026 # Attempts to flatten a passed in SQLAC condition as much as possible towards
1027 # a plain hashref, *without* altering its semantics. Required by
1028 # create/populate being able to extract definitive conditions from preexisting
1029 # resultset {where} stacks
1030 #
1031 # FIXME - while relatively robust, this is still imperfect, one of the first
1032 # things to tackle when we get access to a formalized AST. Note that this code
1033 # is covered by a *ridiculous* amount of tests, so starting with porting this
1034 # code would be a rather good exercise
1035 30108 ▶sub _collapse_cond {
Subroutine _collapse_cond: called CC=69 SCAR=42.9
1036 30108 my ($self, $where, $where_is_anded_array) = @_;
1037  
1038 30108 my $fin;
1039  
1040 30108 ▶ if (! $where) {
Branch: 3 branches
BranchTrueFalseTotal
if (not $where) { } 142 29966 30108
elsif ($where_is_anded_array or ref $where eq 'HASH') { } 26189 3777 29966
elsif (ref $where eq 'ARRAY') { } 3417 360 3777
1041 142 return;
1042 }
1043 ▶ elsif ($where_is_anded_array or ref $where eq 'HASH') {
Condition100%3/3
$where_is_anded_array or ref $where eq "HASH"
l!l&&r!l&&!r
4500216893777
MC/DC100%2/2
$where_is_anded_array or ref $where eq "HASH"
$where_is_anded_array ref $where eq "HASH"
Truth table100%3/3
A or B
A= $where_is_anded_arrayB= ref $where eq "HASH"
ABresult
1X1
011
000
1044  
1045 26189 my @pairs;
1046  
1047 26189 ▶ my @pieces = $where_is_anded_array ? @$where : $where;
Branch: 1 branch
BranchTrueFalseTotal
$where_is_anded_array ? : 4500 21689 26189
1048 26189 ▶ while (@pieces) {
Branch: 1 branch
BranchTrueFalseTotal
if (@pieces) 30688 26111 56799
1049 30688 my $chunk = shift @pieces;
1050  
1051 30688 ▶ if (ref $chunk eq 'HASH') {
Branch: 3 branches
BranchTrueFalseTotal
if (ref $chunk eq 'HASH') { } 29561 1127 30688
elsif (ref $chunk eq 'ARRAY') { } 502 625 1127
elsif (not length ref $chunk) { } 443 182 625
1052 29561 for (sort keys %$chunk) {
1053  
1054 # Match SQLAC 1.79 behavior
1055 33798 ▶ if ($_ eq '') {
Branch: 1 branch
BranchTrueFalseTotal
if ($_ eq "") 128 33670 33798
1056 128 ▶ is_literal_value($chunk->{$_})
Branch: 1 branch
BranchTrueFalseTotal
&is_literal_value($chunk->{$_}) ? : 60 68 128
1057 ? carp 'Hash-pairs consisting of an empty string with a literal are deprecated, use -and => [ $literal ] instead'
1058 : $self->throw_exception("Supplying an empty left hand side argument is not supported in hash-pairs")
1059 ;
1060 }
1061  
1062 33730 push @pairs, $_ => $chunk->{$_};
1063 }
1064 }
1065 elsif (ref $chunk eq 'ARRAY') {
1066 502 ▶ push @pairs, -or => $chunk
Branch: 1 branch
BranchTrueFalseTotal
if @$chunk 447 55 502
1067 if @$chunk;
1068 }
1069 elsif ( ! length ref $chunk) {
1070  
1071 # Match SQLAC 1.79 behavior
1072 443 ▶ $self->throw_exception("Supplying an empty left hand side argument is not supported in array-pairs")
Branch: 1 branch
BranchTrueFalseTotal
if $where_is_anded_array and !defined($chunk) || $chunk eq "" 10 433 443
Condition83%5/6
$where_is_anded_array and !defined($chunk) || $chunk eq ""
!ll&&!rl&&r
043310
not defined $chunk or $chunk eq ""
l!l&&r!l&&!r
55433
MC/DC66%2/3
$where_is_anded_array and !defined($chunk) || $chunk eq ""
$where_is_anded_array not defined $chunk $chunk eq ""
Truth table75%3/4
A and not(B) or C
A= $where_is_anded_arrayB= not defined $chunkC= $chunk eq ""
ABCresult
0XX0
1000
11X1
1011
1073 if $where_is_anded_array and (! defined $chunk or $chunk eq '');
1074  
1075 433 push @pairs, $chunk, shift @pieces;
1076 }
1077 else {
1078 182 push @pairs, '', $chunk;
1079 }
1080 }
1081  
1082 26111 ▶ return unless @pairs;
Branch: 1 branch
BranchTrueFalseTotal
unless @pairs 307 25804 26111
1083  
1084 25804 ▶ my @conds = $self->_collapse_cond_unroll_pairs(\@pairs)
Branch: 1 branch
BranchTrueFalseTotal
my(@conds) = $self->_collapse_cond_unroll_pairs(\@pairs) or return 25254 212 25466
1085 or return;
1086  
1087 # Consolidate various @conds back into something more compact
1088 25254 for my $c (@conds) {
1089 34305 ▶ if (ref $c ne 'HASH') {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $c ne 'HASH') { } 0 34305 34305
1090 0 push @{$fin->{-and}}, $c;
1091 }
1092 else {
1093 34305 for my $col (sort keys %$c) {
1094  
1095 # consolidate all -and nodes
1096 40226 ▶ if ($col =~ /^\-and$/i) {
Branch: 3 branches
BranchTrueFalseTotal
if ($col =~ /^\-and$/i) { } 621 39605 40226
elsif ($col =~ /^\-/) { } 1657 37948 39605
elsif (exists $fin->{$col}) { } 1626 36322 37948
1097 621 ▶ push @{$fin->{-and}},
Branch: 1 branch
BranchTrueFalseTotal
ref $c->{$col} eq 'ARRAY' ? : 621 0 621
1098 621 ▶ ref $c->{$col} eq 'ARRAY' ? @{$c->{$col}}
Branch: 1 branch
BranchTrueFalseTotal
ref $c->{$col} eq 'HASH' ? : 0 0 0
1099 0 : ref $c->{$col} eq 'HASH' ? %{$c->{$col}}
1100 621 : { $col => $c->{$col} }
1101 ;
1102 }
1103 elsif ($col =~ /^\-/) {
1104 1657 push @{$fin->{-and}}, { $col => $c->{$col} };
1105 }
1106 elsif (exists $fin->{$col}) {
1107 $fin->{$col} = [ -and => map {
1108 (ref $_ eq 'ARRAY' and ($_->[0]||'') =~ /^\-and$/i )
1109 3252 ▶ ? @{$_}[1..$#$_]
Branch: 1 branch
BranchTrueFalseTotal
ref $_ eq 'ARRAY' && ($_->[0] || '') =~ /^\-and$/i ? : 88 3164 3252
Condition100%5/5
ref $_ eq "ARRAY" and ($_->[0] || "") =~ /^\-and$/i
!ll&&!rl&&r
31461888
$_->[0] || ''
l!l
8818
MC/DC100%2/2
ref $_ eq "ARRAY" and ($_->[0] || "") =~ /^\-and$/i
ref $_ eq "ARRAY" $_->[0]
Truth table100%3/3
A and B
A= ref $_ eq "ARRAY"B= $_->[0]
ABresult
0X0
100
111
1110 : $_
1111 ;
1112 1626 } ($fin->{$col}, $c->{$col}) ];
1113 }
1114 else {
1115 36322 $fin->{$col} = $c->{$col};
1116 }
1117 }
1118 }
1119 }
1120 }
1121 elsif (ref $where eq 'ARRAY') {
1122 # we are always at top-level here, it is safe to dump empty *standalone* pieces
1123 3417 my $fin_idx;
1124  
1125 3417 ▶ for (my $i = 0; $i <= $#$where; $i++ ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($i <= $where->$#*) 5690 3083 8773
1126  
1127 # Match SQLAC 1.79 behavior
1128 5690 ▶ $self->throw_exception(
Branch: 1 branch
BranchTrueFalseTotal
unless defined $where->[$i] and length $where->[$i] 156 5534 5690
Condition100%3/3
defined $where->[$i] and length $where->[$i]
!ll&&!rl&&r
68885534
MC/DC100%2/2
defined $where->[$i] and length $where->[$i]
defined $where->[$i] length $where->[$i]
Truth table100%3/3
A and B
A= defined $where->[$i]B= length $where->[$i]
ABresult
0X0
100
111
1129 "Supplying an empty left hand side argument is not supported in array-pairs"
1130 ) if (! defined $where->[$i] or ! length $where->[$i]);
1131  
1132 5534 ▶ my $logic_mod = lc ( ($where->[$i] =~ /^(\-(?:and|or))$/i)[0] || '' );
Condition100%2/2
($where->[$i] =~ /^(\-(?:and|or))$/i)[0] || ''
l!l
11564378
MC/DC100%1/1
($where->[$i] =~ /^(\-(?:and|or))$/i)[0] || ''
($where->[$i] =~ /^(\-(?:and|or))$/i)[0]
Truth table100%2/2
A
A= ($where->[$i] =~ /^(\-(?:and|or))$/i)[0]
Aresult
11
00
1133  
1134 5534 ▶ if ($logic_mod) {
Branch: 2 branches
BranchTrueFalseTotal
if ($logic_mod) { } 1156 4378 5534
elsif (not length ref $where->[$i]) { } 3013 1365 4378
1135 1156 $i++;
1136 1156 ▶ $self->throw_exception("Unsupported top-level op/arg pair: [ $logic_mod => $where->[$i] ]")
Branch: 1 branch
BranchTrueFalseTotal
unless ref $where->[$i] eq "HASH" or ref $where->[$i] eq "ARRAY" 0 1156 1156
Condition66%2/3
ref $where->[$i] eq "HASH" or ref $where->[$i] eq "ARRAY"
l!l&&r!l&&!r
8652910
MC/DC0%0/2
ref $where->[$i] eq "HASH" or ref $where->[$i] eq "ARRAY"
ref $where->[$i] eq "HASH" ref $where->[$i] eq "ARRAY"
Truth table66%2/3
A or B
A= ref $where->[$i] eq "HASH"B= ref $where->[$i] eq "ARRAY"
ABresult
1X1
011
000
1137 unless ref $where->[$i] eq 'HASH' or ref $where->[$i] eq 'ARRAY';
1138  
1139 1156 ▶ my $sub_elt = $self->_collapse_cond({ $logic_mod => $where->[$i] })
Branch: 1 branch
BranchTrueFalseTotal
my $sub_elt = $self->_collapse_cond({$logic_mod, $where->[$i]}) or next 921 85 1006
1140 or next;
1141  
1142 921 my @keys = keys %$sub_elt;
1143 921 ▶ if ( @keys == 1 and $keys[0] !~ /^\-/ ) {
Branch: 1 branch
BranchTrueFalseTotal
if (@keys == 1 and not $keys[0] =~ /^\-/) { } 372 549 921
Condition100%3/3
@keys == 1 and not $keys[0] =~ /^\-/
!ll&&!rl&&r
206343372
MC/DC100%2/2
@keys == 1 and not $keys[0] =~ /^\-/
@keys == 1 not $keys[0] =~ /^\-/
Truth table100%3/3
A and not(B)
A= @keys == 1B= not $keys[0] =~ /^\-/
ABresult
0X0
100
111
1144 372 $fin_idx->{ "COL_$keys[0]_" . serialize $sub_elt } = $sub_elt;
1145 }
1146 else {
1147 549 $fin_idx->{ "SER_" . serialize $sub_elt } = $sub_elt;
1148 }
1149 }
1150 elsif (! length ref $where->[$i] ) {
1151 3013 ▶ my $sub_elt = $self->_collapse_cond({ @{$where}[$i, $i+1] })
Branch: 1 branch
BranchTrueFalseTotal
my $sub_elt = $self->_collapse_cond({@{$where;}[$i, $i + 1]}) or next 3012 1 3013
1152 or next;
1153  
1154 3012 $fin_idx->{ "COL_$where->[$i]_" . serialize $sub_elt } = $sub_elt;
1155 3012 $i++;
1156 }
1157 else {
1158 1365 ▶ $fin_idx->{ "SER_" . serialize $where->[$i] } = $self->_collapse_cond( $where->[$i] ) || next;
Condition100%2/2
$self->_collapse_cond($where->[$i]) || (next)
l!l
762575
MC/DC100%1/1
$self->_collapse_cond($where->[$i]) || (next)
$self->_collapse_cond($where->[$i])
Truth table100%2/2
A
A= $self->_collapse_cond($where->[$i])
Aresult
11
00
1159 }
1160 }
1161  
1162 3083 ▶ if (! $fin_idx) {
Branch: 2 branches
BranchTrueFalseTotal
if (not $fin_idx) { } 553 2530 3083
elsif (keys %$fin_idx == 1) { } 1371 1159 2530
1163 553 return;
1164 }
1165 elsif ( keys %$fin_idx == 1 ) {
1166 1371 $fin = (values %$fin_idx)[0];
1167 }
1168 else {
1169 1159 my @or;
1170  
1171 # at this point everything is at most one level deep - unroll if needed
1172 1159 for (sort keys %$fin_idx) {
1173 3268 ▶ if ( ref $fin_idx->{$_} eq 'HASH' and keys %{$fin_idx->{$_}} == 1 ) {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $fin_idx->{$_} eq 'HASH' and keys %{$$fin_idx{$_};} == 1) { } 3252 16 3268
Condition66%2/3
ref $fin_idx->{$_} eq "HASH" and keys %{$$fin_idx{$_};} == 1
!ll&&!rl&&r
0163252
MC/DC50%1/2
ref $fin_idx->{$_} eq "HASH" and keys %{$$fin_idx{$_};} == 1
ref $fin_idx->{$_} eq "HASH" keys %{$$fin_idx{$_};} == 1
Truth table66%2/3
A and B
A= ref $fin_idx->{$_} eq "HASH"B= keys %{$$fin_idx{$_};} == 1
ABresult
0X0
100
111
1174 3252 my ($l, $r) = %{$fin_idx->{$_}};
1175  
1176 3252 ▶ if (
Branch: 2 branches
BranchTrueFalseTotal
if (ref $r eq 'ARRAY' and @$r == 1 && $l =~ /^\-and$/i || $l =~ /^\-or$/i) { } 122 3130 3252
elsif (ref $r eq 'HASH' and keys %$r == 1 and $l =~ /^\-(?:and|or)$/i) { } 0 3130 3130
Condition66%6/9
ref $r eq "ARRAY" and @$r == 1 && $l =~ /^\-and$/i || $l =~ /^\-or$/i
!ll&&!rl&&r
31300122
@$r == 1 and $l =~ /^\-and$/i or $l =~ /^\-or$/i
l!l&&r!l&&!r
108140
@$r == 1 and $l =~ /^\-and$/i
!ll&&!rl&&r
140108
MC/DC25%1/4
ref $r eq "ARRAY" and @$r == 1 && $l =~ /^\-and$/i || $l =~ /^\-or$/i
ref $r eq "ARRAY" @$r == 1 $l =~ /^\-and$/i $l =~ /^\-or$/i
Truth table50%3/6
A and B and C or D
A= ref $r eq "ARRAY"B= @$r == 1C= $l =~ /^\-and$/iD= $l =~ /^\-or$/i
ABCDresult
0XXX0
10X00
11000
111X1
10X11
11011
1177 ref $r eq 'ARRAY'
1178 and
1179 (
1180 ( @$r == 1 and $l =~ /^\-and$/i )
1181 or
1182 $l =~ /^\-or$/i
1183 )
1184 ) {
1185 122 push @or, @$r
1186 }
1187  
1188 ▶ elsif (
Condition66%4/6
ref $r eq "HASH" and keys %$r == 1 and $l =~ /^\-(?:and|or)$/i
!ll&&!rl&&r
25046260
ref $r eq "HASH" and keys %$r == 1
!ll&&!rl&&r
25040626
MC/DC0%0/3
ref $r eq "HASH" and keys %$r == 1 and $l =~ /^\-(?:and|or)$/i
ref $r eq "HASH" keys %$r == 1 $l =~ /^\-(?:and|or)$/i
Truth table50%2/4
A and B and C
A= ref $r eq "HASH"B= keys %$r == 1C= $l =~ /^\-(?:and|or)$/i
ABCresult
0XX0
10X0
1100
1111
1189 ref $r eq 'HASH'
1190 and
1191 keys %$r == 1
1192 and
1193 $l =~ /^\-(?:and|or)$/i
1194 ) {
1195 0 push @or, %$r;
1196 }
1197  
1198 else {
1199 3130 push @or, $l, $r;
1200 }
1201 }
1202 else {
1203 16 push @or, $fin_idx->{$_};
1204 }
1205 }
1206  
1207 1159 $fin->{-or} = \@or;
1208 }
1209 }
1210 else {
1211 # not a hash not an array
1212 360 $fin = { -and => [ $where ] };
1213 }
1214  
1215 # unroll single-element -and's
1216 28144 ▶ while (
Branch: 1 branch
BranchTrueFalseTotal
if ($fin->{"-and"} and @{$fin->{"-and"};} < 2) 2144 27383 29527
Condition100%3/3
$fin->{"-and"} and @{$fin->{"-and"};} < 2
!ll&&!rl&&r
270153682144
MC/DC100%2/2
$fin->{"-and"} and @{$fin->{"-and"};} < 2
$fin->{"-and"} @{$fin->{"-and"};} < 2
Truth table100%3/3
A and B
A= $fin->{"-and"}B= @{$fin->{"-and"};} < 2
ABresult
0X0
100
111
1217 $fin->{-and}
1218 and
1219 2512 @{$fin->{-and}} < 2
1220 ) {
1221 2144 my $and = delete $fin->{-and};
1222 2144 ▶ last if @$and == 0;
Branch: 1 branch
BranchTrueFalseTotal
if @$and == 0 0 2144 2144
1223  
1224 # at this point we have @$and == 1
1225 2144 ▶ if (
Branch: 1 branch
BranchTrueFalseTotal
if (ref $and->[0] eq 'HASH' and not grep({exists $fin->{$_};} keys %{$$and[0];})) { } 1383 761 2144
Condition66%2/3
ref $and->[0] eq "HASH" and not grep({exists $fin->{$_};} keys %{$$and[0];})
!ll&&!rl&&r
76101383
MC/DC50%1/2
ref $and->[0] eq "HASH" and not grep({exists $fin->{$_};} keys %{$$and[0];})
ref $and->[0] eq "HASH" not grep({exists $fin->{$_};} keys %{$$and[0];})
Truth table66%2/3
A and not(B)
A= ref $and->[0] eq "HASH"B= not grep({exists $fin->{$_};} keys %{$$and[0];})
ABresult
0X0
100
111
1226 ref $and->[0] eq 'HASH'
1227 and
1228 1383 ! grep { exists $fin->{$_} } keys %{$and->[0]}
1229 ) {
1230 $fin = {
1231 1383 %$fin, %{$and->[0]}
1232 };
1233 }
1234 else {
1235 761 $fin->{-and} = $and;
1236 761 last;
1237 }
1238 }
1239  
1240 # compress same-column conds found in $fin
1241 28144 for my $col ( grep { $_ !~ /^\-/ } keys %$fin ) {
1242 37654 ▶ next unless ref $fin->{$col} eq 'ARRAY' and ($fin->{$col}[0]||'') =~ /^\-and$/i;
Branch: 1 branch
BranchTrueFalseTotal
unless ref $fin->{$col} eq "ARRAY" and ($fin->{$col}[0] || "") =~ /^\-and$/i 34960 2694 37654
Condition100%5/5
ref $fin->{$col} eq "ARRAY" and ($fin->{$col}[0] || "") =~ /^\-and$/i
!ll&&!rl&&r
348271332694
$fin->{$col}[0] || ''
l!l
276364
MC/DC100%2/2
ref $fin->{$col} eq "ARRAY" and ($fin->{$col}[0] || "") =~ /^\-and$/i
ref $fin->{$col} eq "ARRAY" $fin->{$col}[0]
Truth table100%3/3
A and B
A= ref $fin->{$col} eq "ARRAY"B= $fin->{$col}[0]
ABresult
0X0
100
111
1243 my $val_bag = { map {
1244 5522 ▶ (! defined $_ ) ? ( UNDEF => undef )
Branch: 2 branches
BranchTrueFalseTotal
!defined($_) ? : 185 5337 5522
!length(ref $_) || &is_plain_value($_) ? : 958 4379 5337
Condition66%2/3
not length ref $_ or &is_plain_value($_)
l!l&&r!l&&!r
95804379
MC/DC50%1/2
not length ref $_ or &is_plain_value($_)
not length ref $_ &is_plain_value($_)
Truth table66%2/3
not(A) or B
A= not length ref $_B= &is_plain_value($_)
ABresult
1X1
011
000
1245 : ( ! length ref $_ or is_plain_value $_ ) ? ( "VAL_$_" => $_ )
1246 : ( ( 'SER_' . serialize $_ ) => $_ )
1247 2694 } @{$fin->{$col}}[1 .. $#{$fin->{$col}}] };
1248  
1249 2694 ▶ if (keys %$val_bag == 1 ) {
Branch: 1 branch
BranchTrueFalseTotal
if (keys %$val_bag == 1) { } 356 2338 2694
1250 356 ($fin->{$col}) = values %$val_bag;
1251 }
1252 else {
1253 2338 $fin->{$col} = [ -and => map { $val_bag->{$_} } sort keys %$val_bag ];
1254 }
1255 }
1256  
1257 28144 ▶ return keys %$fin ? $fin : ();
Branch: 1 branch
BranchTrueFalseTotal
keys %$fin ? : 28144 0 28144
1258 }
1259  
1260 26570 ▶sub _collapse_cond_unroll_pairs {
Subroutine _collapse_cond_unroll_pairs: called CC=45 SCAR=38.5
1261 26570 my ($self, $pairs) = @_;
1262  
1263 26570 my @conds;
1264  
1265 26570 ▶ while (@$pairs) {
Branch: 1 branch
BranchTrueFalseTotal
if (@$pairs) 35865 26232 62097
1266 35865 my ($lhs, $rhs) = splice @$pairs, 0, 2;
1267  
1268 35865 ▶ if ($lhs eq '') {
Branch: 3 branches
BranchTrueFalseTotal
if ($lhs eq '') { } 242 35623 35865
elsif ($lhs =~ /^\-and$/i) { } 5311 30312 35623
elsif ($lhs =~ /^\-or$/i) { } 2287 28025 30312
1269 242 push @conds, $self->_collapse_cond($rhs);
1270 }
1271 elsif ( $lhs =~ /^\-and$/i ) {
1272 5311 push @conds, $self->_collapse_cond($rhs, (ref $rhs eq 'ARRAY'));
1273 }
1274 elsif ( $lhs =~ /^\-or$/i ) {
1275 push @conds, $self->_collapse_cond(
1276 2287 ▶ (ref $rhs eq 'HASH') ? [ map { $_ => $rhs->{$_} } sort keys %$rhs ] : $rhs
Branch: 1 branch
BranchTrueFalseTotal
ref $rhs eq 'HASH' ? : 305 1982 2287
1277 );
1278 }
1279 else {
1280 28025 ▶ if (ref $rhs eq 'HASH' and ! keys %$rhs) {
Branch: 6 branches
BranchTrueFalseTotal
if (ref $rhs eq 'HASH' and not keys %$rhs) { } 6 28019 28025
elsif (ref $rhs eq 'HASH' and keys %$rhs == 1 and exists $rhs->{'-ident'}) { } 322 27697 28019
elsif (ref $rhs eq 'HASH' and keys %$rhs == 1 and exists $rhs->{'-value'} and !length(ref $rhs->{'-value'}) || defined builtin::blessed($rhs->{'-value'}) && &is_plain_value($rhs->{'-value'})) { } 33 27664 27697
elsif (ref $rhs eq 'HASH' and keys %$rhs == 1 and exists $rhs->{'='}) { } 1463 26201 27664
elsif (ref $rhs eq 'ARRAY') { } 293 25908 26201
elsif (ref $rhs eq 'HASH' and (my($subop) = keys %$rhs) == 1 and ref((values %$rhs)[0]) eq 'HASH' and keys %{(values %$rhs)[0];} == 1 and exists +(values %$rhs)[0]->{'-value'} and !length(ref +(values %$rhs)[0]->{'-value'}) || defined builtin::blessed(+(values %$rhs)[0]->{'-value'}) && &is_plain_value(+(values %$rhs)[0]->{'-value'})) { } 7 25901 25908
Condition100%3/3
ref $rhs eq "HASH" and not keys %$rhs
!ll&&!rl&&r
2231057096
MC/DC100%2/2
ref $rhs eq "HASH" and not keys %$rhs
ref $rhs eq "HASH" not keys %$rhs
Truth table100%3/3
A and not(B)
A= ref $rhs eq "HASH"B= not keys %$rhs
ABresult
0X0
100
111
1281 # FIXME - SQLAC seems to be doing... nothing...?
1282 }
1283 # normalize top level -ident, for saner extract_fixed_condition_columns code
1284 ▶ elsif (ref $rhs eq 'HASH' and keys %$rhs == 1 and exists $rhs->{-ident}) {
Condition100%6/6
ref $rhs eq "HASH" and keys %$rhs == 1 and exists $rhs->{"-ident"}
!ll&&!rl&&r
223325365322
ref $rhs eq "HASH" and keys %$rhs == 1
!ll&&!rl&&r
22310225687
MC/DC100%3/3
ref $rhs eq "HASH" and keys %$rhs == 1 and exists $rhs->{"-ident"}
ref $rhs eq "HASH" keys %$rhs == 1 exists $rhs->{"-ident"}
Truth table100%4/4
A and B and C
A= ref $rhs eq "HASH"B= keys %$rhs == 1C= exists $rhs->{"-ident"}
ABCresult
0XX0
10X0
1100
1111
1285 322 push @conds, { $lhs => { '=', $rhs } };
1286 }
1287 # can't simply use is_plain_value result, as we need to
1288 # preserve the -value marker where necessary (non-blessed ref)
1289 ▶ elsif (
Condition80%12/15
ref $rhs eq "HASH" and keys %$rhs == 1 and exists $rhs->{"-value"} and !length(ref $rhs->{"-value"}) || defined builtin::blessed($rhs->{"-value"}) && &is_plain_value($rhs->{"-value"})
!ll&&!rl&&r
276461833
ref $rhs eq "HASH" and keys %$rhs == 1 and exists $rhs->{"-value"}
!ll&&!rl&&r
22332531451
ref $rhs eq "HASH" and keys %$rhs == 1
!ll&&!rl&&r
22310225365
not length ref $rhs->{"-value"} or defined builtin::blessed($rhs->{"-value"}) and &is_plain_value($rhs->{"-value"})
l!l&&r!l&&!r
33018
defined builtin::blessed($rhs->{"-value"}) and &is_plain_value($rhs->{"-value"})
!ll&&!rl&&r
1800
MC/DC66%4/6
ref $rhs eq "HASH" and keys %$rhs == 1 and exists $rhs->{"-value"} and !length(ref $rhs->{"-value"}) || defined builtin::blessed($rhs->{"-value"}) && &is_plain_value($rhs->{"-value"})
ref $rhs eq "HASH" keys %$rhs == 1 exists $rhs->{"-value"} not length ref $rhs->{"-value"} defined builtin::blessed($rhs->{"-value"}) &is_plain_value($rhs->{"-value"})
Truth table71%5/7
A and B and C and not(D) or E and F
A= ref $rhs eq "HASH"B= keys %$rhs == 1C= exists $rhs->{"-value"}D= not length ref $rhs->{"-value"}E= defined builtin::blessed($rhs->{"-value"})F= &is_plain_value($rhs->{"-value"})
ABCDEFresult
0XXXXX0
10XXXX0
110XXX0
11100X0
1110100
1111XX1
1110111
1290 ref $rhs eq 'HASH'
1291 and
1292 keys %$rhs == 1
1293 and
1294 exists $rhs->{-value}
1295 and
1296 (
1297 ! length ref( $rhs->{-value} )
1298 or
1299 (
1300 defined( blessed $rhs->{-value} )
1301 and
1302 is_plain_value $rhs->{-value}
1303 )
1304 )
1305 ) {
1306 33 push @conds, { $lhs => $rhs->{-value} };
1307 }
1308 ▶ elsif (ref $rhs eq 'HASH' and keys %$rhs == 1 and exists $rhs->{'='}) {
Condition100%6/6
ref $rhs eq "HASH" and keys %$rhs == 1 and exists $rhs->{"="}
!ll&&!rl&&r
2233238691463
ref $rhs eq "HASH" and keys %$rhs == 1
!ll&&!rl&&r
22310225332
MC/DC100%3/3
ref $rhs eq "HASH" and keys %$rhs == 1 and exists $rhs->{"="}
ref $rhs eq "HASH" keys %$rhs == 1 exists $rhs->{"="}
Truth table100%4/4
A and B and C
A= ref $rhs eq "HASH"B= keys %$rhs == 1C= exists $rhs->{"="}
ABCresult
0XX0
10X0
1100
1111
1309 1463 ▶ if ( length ref $rhs->{'='} and is_literal_value $rhs->{'='} ) {
Branch: 1 branch
BranchTrueFalseTotal
if (length ref $rhs->{'='} and &is_literal_value($rhs->{'='})) { } 697 766 1463
Condition100%3/3
length ref $rhs->{"="} and &is_literal_value($rhs->{"="})
!ll&&!rl&&r
471295697
MC/DC100%2/2
length ref $rhs->{"="} and &is_literal_value($rhs->{"="})
length ref $rhs->{"="} &is_literal_value($rhs->{"="})
Truth table100%3/3
A and B
A= length ref $rhs->{"="}B= &is_literal_value($rhs->{"="})
ABresult
0X0
100
111
1310 697 push @conds, { $lhs => $rhs };
1311 }
1312 else {
1313 766 for my $p ($self->_collapse_cond_unroll_pairs([ $lhs => $rhs->{'='} ])) {
1314  
1315 # extra sanity check
1316 771 ▶ if (keys %$p > 1) {
Branch: 1 branch
BranchTrueFalseTotal
if (keys %$p > 1) 0 771 771
1317 0 require Data::Dumper::Concise;
1318 0 local $Data::Dumper::Deepcopy = 1;
1319 $self->throw_exception(
1320 "Internal error: unexpected collapse unroll:"
1321 0 . Data::Dumper::Concise::Dumper { in => { $lhs => $rhs }, out => $p }
1322 );
1323 }
1324  
1325 771 my ($l, $r) = %$p;
1326  
1327 push @conds, (
1328 ! length ref $r
1329 or
1330 # the unroller recursion may return a '=' prepended value already
1331 293 ▶ ref $r eq 'HASH' and keys %$rhs == 1 and exists $rhs->{'='}
Branch: 1 branch
BranchTrueFalseTotal
!length(ref $r) || ref $r eq 'HASH' && keys %$rhs == 1 && exists $rhs->{'='} || &is_plain_value($r) ? : 751 20 771
Condition83%10/12
not length ref $r or ref $r eq "HASH" and keys %$rhs == 1 and exists $rhs->{"="} or &is_plain_value($r)
l!l&&r!l&&!r
7391220
not length ref $r or ref $r eq "HASH" and keys %$rhs == 1 and exists $rhs->{"="}
l!l&&r!l&&!r
49924032
ref $r eq "HASH" and keys %$rhs == 1 and exists $rhs->{"="}
!ll&&!rl&&r
320240
ref $r eq "HASH" and keys %$rhs == 1
!ll&&!rl&&r
320240
MC/DC60%3/5
not length ref $r or ref $r eq "HASH" and keys %$rhs == 1 and exists $rhs->{"="} or &is_plain_value($r)
not length ref $r ref $r eq "HASH" keys %$rhs == 1 exists $rhs->{"="} &is_plain_value($r)
Truth table50%4/8
not(A) or B and C and D or E
A= not length ref $rB= ref $r eq "HASH"C= keys %$rhs == 1D= exists $rhs->{"="}E= &is_plain_value($r)
ABCDEresult
1XXXX1
0111X1
00XX11
010X11
011011
00XX00
010X00
011000
1332 or
1333 is_plain_value($r)
1334 )
1335 ? { $l => $r }
1336 : { $l => { '=' => $r } }
1337 ;
1338 }
1339 }
1340 }
1341 elsif (ref $rhs eq 'ARRAY') {
1342 # some of these conditionals encounter multi-values - roll them out using
1343 # an unshift, which will cause extra looping in the while{} above
1344 60 ▶ if (! @$rhs ) {
Branch: 3 branches
BranchTrueFalseTotal
if (not @$rhs) { } 60 233 293
elsif (($rhs->[0] || '') =~ /^\-(?:and|or)$/i) { } 174 59 233
elsif (@$rhs == 1) { } 15 44 59
1345 174 push @conds, { $lhs => [] };
1346 }
1347 ▶ elsif ( ($rhs->[0]||'') =~ /^\-(?:and|or)$/i ) {
Condition100%2/2
$rhs->[0] || ''
l!l
2285
MC/DC100%1/1
$rhs->[0] || ''
$rhs->[0]
Truth table100%2/2
A
A= $rhs->[0]
Aresult
11
00
1348 174 ▶ $self->throw_exception("Value modifier not followed by any values: $lhs => [ $rhs->[0] ] ")
Branch: 1 branch
BranchTrueFalseTotal
if @$rhs == 1 0 174 174
1349 if @$rhs == 1;
1350  
1351 164 ▶ if( $rhs->[0] =~ /^\-and$/i ) {
Branch: 2 branches
BranchTrueFalseTotal
if ($rhs->[0] =~ /^\-and$/i) { } 164 10 174
elsif (@$rhs == 2) { } 5 5 10
1352 357 unshift @$pairs, map { $lhs => $_ } @{$rhs}[1..$#$rhs];
1353 }
1354 # if not an AND then it's an OR
1355 elsif(@$rhs == 2) {
1356 5 unshift @$pairs, $lhs => $rhs->[1];
1357 }
1358 else {
1359 5 push @conds, { $lhs => [ @{$rhs}[1..$#$rhs] ] };
1360 }
1361 }
1362 elsif (@$rhs == 1) {
1363 44 unshift @$pairs, $lhs => $rhs->[0];
1364 }
1365 else {
1366 61 push @conds, { $lhs => $rhs };
1367 }
1368 }
1369 # unroll func + { -value => ... }
1370 # can't simply use is_plain_value result, as we need to
1371 # preserve the -value marker where necessary (non-blessed ref)
1372 ▶ elsif (
Condition93%14/15
ref $rhs eq "HASH" and (my($subop) = keys %$rhs) == 1 and ref((values %$rhs)[0]) eq "HASH" and keys %{(values %$rhs)[0];} == 1 and exists +(values %$rhs)[0]->{"-value"} and !length(ref +(values %$rhs)[0]->{"-value"}) || defined builtin::blessed(+(values %$rhs)[0]->{"-value"}) && &is_plain_value(+(values %$rhs)[0]->{"-value"})
!ll&&!rl&&r
25865367
ref $rhs eq "HASH" and (my($subop) = keys %$rhs) == 1 and ref((values %$rhs)[0]) eq "HASH" and keys %{(values %$rhs)[0];} == 1 and exists +(values %$rhs)[0]->{"-value"}
!ll&&!rl&&r
258471843
ref $rhs eq "HASH" and (my($subop) = keys %$rhs) == 1 and ref((values %$rhs)[0]) eq "HASH" and keys %{(values %$rhs)[0];} == 1
!ll&&!rl&&r
25847061
ref $rhs eq "HASH" and (my($subop) = keys %$rhs) == 1 and ref((values %$rhs)[0]) eq "HASH"
!ll&&!rl&&r
22039380861
ref $rhs eq "HASH" and (my($subop) = keys %$rhs) == 1
!ll&&!rl&&r
22017223869
MC/DC83%5/6
ref $rhs eq "HASH" and (my($subop) = keys %$rhs) == 1 and ref((values %$rhs)[0]) eq "HASH" and keys %{(values %$rhs)[0];} == 1 and exists +(values %$rhs)[0]->{"-value"} and !length(ref +(values %$rhs)[0]->{"-value"}) || defined builtin::blessed(+(values %$rhs)[0]->{"-value"}) && &is_plain_value(+(values %$rhs)[0]->{"-value"})
ref $rhs eq "HASH" (my($subop) = keys %$rhs) == 1 ref((values %$rhs)[0]) eq "HASH" keys %{(values %$rhs)[0];} == 1 exists +(values %$rhs)[0]->{"-value"} !length(ref +(values %$rhs)[0]->{"-value"}) || defined builtin::blessed(+(values %$rhs)[0]->{"-value"}) && &is_plain_value(+(values %$rhs)[0]->{"-value"})
Truth table85%6/7
A and B and C and D and E and F
A= ref $rhs eq "HASH"B= (my($subop) = keys %$rhs) == 1C= ref((values %$rhs)[0]) eq "HASH"D= keys %{(values %$rhs)[0];} == 1E= exists +(values %$rhs)[0]->{"-value"}F= !length(ref +(values %$rhs)[0]->{"-value"}) || defined builtin::blessed(+(values %$rhs)[0]->{"-value"}) && &is_plain_value(+(values %$rhs)[0]->{"-value"})
ABCDEFresult
0XXXXX0
10XXXX0
110XXX0
1110XX0
11110X0
1111100
1111111
1373 ref $rhs eq 'HASH'
1374 and
1375 ( my ($subop) = keys %$rhs ) == 1
1376 and
1377 ref( (values %$rhs)[0] ) eq 'HASH'
1378 and
1379 7 ▶ keys %{ (values %$rhs)[0] } == 1
Condition50%3/6
not length ref +(values %$rhs)[0]->{"-value"} or defined builtin::blessed(+(values %$rhs)[0]->{"-value"}) and &is_plain_value(+(values %$rhs)[0]->{"-value"})
l!l&&r!l&&!r
7036
defined builtin::blessed(+(values %$rhs)[0]->{"-value"}) and &is_plain_value(+(values %$rhs)[0]->{"-value"})
!ll&&!rl&&r
3600
MC/DC0%0/3
not length ref +(values %$rhs)[0]->{"-value"} or defined builtin::blessed(+(values %$rhs)[0]->{"-value"}) and &is_plain_value(+(values %$rhs)[0]->{"-value"})
not length ref +(values %$rhs)[0]->{"-value"} defined builtin::blessed(+(values %$rhs)[0]->{"-value"}) &is_plain_value(+(values %$rhs)[0]->{"-value"})
Truth table0%0/4
not(A) or B and C
A= not length ref +(values %$rhs)[0]->{"-value"}B= defined builtin::blessed(+(values %$rhs)[0]->{"-value"})C= &is_plain_value(+(values %$rhs)[0]->{"-value"})
ABCresult
1XX1
0111
00X0
0100
1380 and
1381 exists( (values %$rhs)[0]->{-value} )
1382 and
1383 (
1384 ! length ref( (values %$rhs)[0]->{-value} )
1385 or
1386 (
1387 defined( blessed( (values %$rhs)[0]->{-value} ) )
1388 and
1389 is_plain_value( (values %$rhs)[0]->{-value} )
1390 )
1391 )
1392 ) {
1393 25901 push @conds, { $lhs => { $subop => (values %$rhs)[0]->{-value} } };
1394 }
1395 else {
1396 26232 push @conds, { $lhs => $rhs };
1397 }
1398 }
1399 }
1400  
1401 0 return @conds;
1402 }
1403  
1404 # Analyzes a given condition and attempts to extract all columns
1405 # with a definitive fixed-condition criteria. Returns a hashref
1406 # of k/v pairs suitable to be passed to set_columns(), with a
1407 # MAJOR CAVEAT - multi-value (contradictory) equalities are still
1408 # represented as a reference to the UNRESOVABLE_CONDITION constant
1409 # The reason we do this is that some codepaths only care about the
1410 # codition being stable, as opposed to actually making sense
1411 #
1412 # The normal mode is used to figure out if a resultset is constrained
1413 # to a column which is part of a unique constraint, which in turn
1414 # allows us to better predict how ordering will behave etc.
1415 #
1416 # With the optional "consider_nulls" boolean argument, the function
1417 # is instead used to infer inambiguous values from conditions
1418 # (e.g. the inheritance of resultset conditions on new_result)
1419 #
1420 11419 ▶sub _extract_fixed_condition_columns {
Subroutine _extract_fixed_condition_columns: called CC=28 SCAR=33.5
1421 11419 my ($self, $where, $consider_nulls) = @_;
1422 11419 my $where_hash = $self->_collapse_cond($_[1]);
1423  
1424 11419 my $res = {};
1425 11419 my ($c, $v);
1426 11419 for $c (keys %$where_hash) {
1427 12666 my $vals;
1428  
1429 12666 ▶ if (!defined ($v = $where_hash->{$c}) ) {
Branch: 4 branches
BranchTrueFalseTotal
if (not defined($v = $where_hash->{$c})) { } 242 12424 12666
elsif (ref $v eq 'HASH' and keys %$v == 1) { } 482 11942 12424
elsif (not length ref $v or &is_plain_value($v)) { } 11180 762 11942
elsif (ref $v eq 'ARRAY' and ($v->[0] || '') eq '-and') { } 81 765 846
1430 242 ▶ $vals->{UNDEF} = $v if $consider_nulls
Branch: 1 branch
BranchTrueFalseTotal
if $consider_nulls 108 134 242
1431 }
1432 ▶ elsif (
Condition100%3/3
ref $v eq "HASH" and keys %$v == 1
!ll&&!rl&&r
1192022482
MC/DC100%2/2
ref $v eq "HASH" and keys %$v == 1
ref $v eq "HASH" keys %$v == 1
Truth table100%3/3
A and B
A= ref $v eq "HASH"B= keys %$v == 1
ABresult
0X0
100
111
1433 ref $v eq 'HASH'
1434 and
1435 keys %$v == 1
1436 ) {
1437 482 ▶ if (exists $v->{-value}) {
Branch: 2 branches
BranchTrueFalseTotal
if (exists $v->{'-value'}) { } 12 470 482
elsif (length ref $v->{'='} and ref $v->{'='} eq 'HASH' && keys %{$$v{'='};} == 1 && exists $v->{'='}{'-ident'} || &is_literal_value($v->{'='})) { } 374 187 561
1438 12 ▶ if (defined $v->{-value}) {
Branch: 2 branches
BranchTrueFalseTotal
if (defined $v->{'-value'}) { } 12 0 12
elsif ($consider_nulls) { } 0 0 0
1439 $vals->{"VAL_$v->{-value}"} = $v->{-value}
1440 12 }
1441 elsif( $consider_nulls ) {
1442 0 $vals->{UNDEF} = $v->{-value};
1443 }
1444 }
1445 # do not need to check for plain values - _collapse_cond did it for us
1446 ▶ elsif(
Condition83%10/12
length ref $v->{"="} and ref $v->{"="} eq "HASH" && keys %{$$v{"="};} == 1 && exists $v->{"="}{"-ident"} || &is_literal_value($v->{"="})
!ll&&!rl&&r
915374
ref $v->{"="} eq "HASH" and keys %{$$v{"="};} == 1 and exists $v->{"="}{"-ident"} or &is_literal_value($v->{"="})
l!l&&r!l&&!r
892855
ref $v->{"="} eq "HASH" and keys %{$$v{"="};} == 1 and exists $v->{"="}{"-ident"}
!ll&&!rl&&r
290089
ref $v->{"="} eq "HASH" and keys %{$$v{"="};} == 1
!ll&&!rl&&r
290089
MC/DC60%3/5
length ref $v->{"="} and ref $v->{"="} eq "HASH" && keys %{$$v{"="};} == 1 && exists $v->{"="}{"-ident"} || &is_literal_value($v->{"="})
length ref $v->{"="} ref $v->{"="} eq "HASH" keys %{$$v{"="};} == 1 exists $v->{"="}{"-ident"} &is_literal_value($v->{"="})
Truth table50%4/8
A and B and C and D or E
A= length ref $v->{"="}B= ref $v->{"="} eq "HASH"C= keys %{$$v{"="};} == 1D= exists $v->{"="}{"-ident"}E= &is_literal_value($v->{"="})
ABCDEresult
0XXXX0
10XX00
110X00
111000
1111X1
10XX11
110X11
111011
1447 length ref $v->{'='}
1448 and
1449 (
1450 89 ( ref $v->{'='} eq 'HASH' and keys %{$v->{'='}} == 1 and exists $v->{'='}{-ident} )
1451 or
1452 is_literal_value($v->{'='})
1453 )
1454 ) {
1455 374 $vals->{ 'SER_' . serialize $v->{'='} } = $v->{'='};
1456 }
1457 }
1458 ▶ elsif (
Condition100%3/3
not length ref $v or &is_plain_value($v)
l!l&&r!l&&!r
1115822762
MC/DC100%2/2
not length ref $v or &is_plain_value($v)
not length ref $v &is_plain_value($v)
Truth table100%3/3
not(A) or B
A= not length ref $vB= &is_plain_value($v)
ABresult
1X1
011
000
1459 ! length ref $v
1460 or
1461 is_plain_value ($v)
1462 ) {
1463 11180 $vals->{"VAL_$v"} = $v;
1464 }
1465 ▶ elsif (ref $v eq 'ARRAY' and ($v->[0]||'') eq '-and') {
Condition100%5/5
ref $v eq "ARRAY" and ($v->[0] || "") eq "-and"
!ll&&!rl&&r
8459781
$v->[0] || ''
l!l
312366
MC/DC100%2/2
ref $v eq "ARRAY" and ($v->[0] || "") eq "-and"
ref $v eq "ARRAY" $v->[0]
Truth table100%3/3
A and B
A= ref $v eq "ARRAY"B= $v->[0]
ABresult
0X0
100
111
1466 81 for ( @{$v}[1..$#$v] ) {
1467 186 my $subval = $self->_extract_fixed_condition_columns({ $c => $_ }, 'consider nulls'); # always fish nulls out on recursion
1468 186 ▶ next unless exists $subval->{$c}; # didn't find anything
Branch: 1 branch
BranchTrueFalseTotal
unless exists $subval->{$c} 51 135 186
1469 $vals->{
1470 ! defined $subval->{$c} ? 'UNDEF'
1471 : ( ! length ref $subval->{$c} or is_plain_value $subval->{$c} ) ? "VAL_$subval->{$c}"
1472 : ( 'SER_' . serialize $subval->{$c} )
1473 135 ▶ } = $subval->{$c};
Branch: 2 branches
BranchTrueFalseTotal
!defined($subval->{$c}) ? : 22 113 135
!length(ref $subval->{$c}) || &is_plain_value($subval->{$c}) ? : 79 34 113
Condition66%2/3
not length ref $subval->{$c} or &is_plain_value($subval->{$c})
l!l&&r!l&&!r
79034
MC/DC50%1/2
not length ref $subval->{$c} or &is_plain_value($subval->{$c})
not length ref $subval->{$c} &is_plain_value($subval->{$c})
Truth table66%2/3
not(A) or B
A= not length ref $subval->{$c}B= &is_plain_value($subval->{$c})
ABresult
1X1
011
000
1474 }
1475 }
1476  
1477 12666 ▶ if (keys %$vals == 1) {
Branch: 2 branches
BranchTrueFalseTotal
if (keys %$vals == 1) { } 11701 965 12666
elsif (keys %$vals > 1) { } 54 911 965
1478 ($res->{$c}) = (values %$vals)
1479 11701 ▶ unless !$consider_nulls and exists $vals->{UNDEF};
Branch: 1 branch
BranchTrueFalseTotal
unless not $consider_nulls and exists $vals->{"UNDEF"} 11696 5 11701
Condition100%3/3
not $consider_nulls and exists $vals->{"UNDEF"}
!ll&&!rl&&r
727544215
MC/DC100%2/2
not $consider_nulls and exists $vals->{"UNDEF"}
not $consider_nulls exists $vals->{"UNDEF"}
Truth table100%3/3
not(A) and B
A= not $consider_nullsB= exists $vals->{"UNDEF"}
ABresult
0X0
100
111
1480 }
1481 elsif (keys %$vals > 1) {
1482 54 $res->{$c} = UNRESOLVABLE_CONDITION;
1483 }
1484 }
1485  
1486 11419 $res;
1487 }
1488  
1489 266 1;
« DBIx/Class/Storage/DBI/SQLite.pm ↑ Summary DBIx/Class/ResultSet.pm »