blib/lib/DBIO/SQLMaker.pm

filter: Statementstmt 98.0% 98 / 100 Branchbran 86.7% 59 / 68 Conditioncond 67.7% 42 / 62 MC/DCmcdc 48.3% 15 / 31 Subroutinesub 100% 20 / 20 Podpod 33.3% 1 / 3 totaltotal 82.7% 235 / 284 CC 58 SCAR 25.7
CC
58
Cov
87%
_expand_op_andor
27.5
_assert_operator_name
11.6
__unwrap_redundant_paren
7.0
CRAP 13.1
« blib/lib/DBIO/Introspect/DBI.pm ↑ Summary blib/lib/DBIO/Carp.pm »
1 package DBIO::SQLMaker;
2 # ABSTRACT: An SQL::Abstract-based SQL maker class
3  
4 192 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
5 192 ▶use warnings;
Subroutine BEGIN: called CC=1 SCAR=0.0
6  
7 192 our $VERSION = '0.900007';
8  
9 192 our $CONTRACT_VERSION = '1.3';
10  
11 192 ▶use base qw(
Subroutine BEGIN: called CC=1 SCAR=0.0
12 DBIO::SQLMaker::ClassicExtensions
13 SQL::Abstract
14 192 );
15  
16 192 ▶use DBIO::Exception ();
Subroutine BEGIN: called CC=1 SCAR=0.0
17  
18 2 ▶sub contract_version { $CONTRACT_VERSION }
Subroutine contract_version: called CC=1 SCAR=0.0
Pod undocumented
19  
20 # NOTE THE LACK OF mro SPECIFICATION
21 # This is deliberate to ensure things will continue to work
22 # with ( usually ) untagged custom darkpan subclasses
23  
24 922 ▶sub new {
Subroutine new: called CC=3 SCAR=11.5
Pod documented
25 922 my $self = shift;
26 0 ▶ my %opts = (ref $_[0] eq 'HASH') ? %{$_[0]} : @_;
Branch: 1 branch
BranchTrueFalseTotal
ref $_[0] eq 'HASH' ? : 0 922 922
27  
28 # Reproduce the SQL::Abstract behaviour it only wires up for classes that
29 # ->isa('DBIx::Class::SQLMaker'). The DBIO rename of the SQLMaker hierarchy
30 # no longer trips that gate, so without this, select() emitted a bare
31 # 'WHERE cond' instead of the canonical 'WHERE ( cond )' that DBIx::Class
32 # produced. Routing select's WHERE through where() restores the parens, and
33 # disabling the old special-op system makes every DBIO driver express its
34 # operators through the new expand_op mechanism (see DBIO::PostgreSQL and
35 # DBIO::Oracle SQLMakers) -- the two go together.
36 922 $opts{warn_once_on_nest} = 1;
37 922 $opts{disable_old_special_ops} = 1;
38 # an arrayref is a value (an array data type), never literal SQL
39 922 $opts{array_datatypes} = 1;
40 2472 ▶ $opts{render_clause}{'select.where'} ||= sub {
Subroutine __ANON__: called CC=3 SCAR=11.1
41 2472 my ($sql, @bind) = $_[0]->where($_[2]);
42 2472 s/\A\s+//, s/\s+\Z// for $sql;
43 # where() wraps its result in a single 'WHERE ( ... )' layer. When the
44 # top-level WHERE node is an -and/-or, SQL::Abstract's _render_op_andor
45 # has already wrapped the condition in its own '( ... )', so where()'s
46 # wrapper produces a redundant second layer: 'WHERE ( ( ... ) )'. Collapse
47 # that one redundant layer back to the canonical 'WHERE ( ... )'. Only the
48 # outer pair added by where() is touched; the already-wrapped condition and
49 # every nested group are left exactly as rendered (see ADR 0004).
50 2472 ▶ $sql = "$1 " . __unwrap_redundant_paren($2)
Branch: 1 branch
BranchTrueFalseTotal
if $sql =~ /\A(WHERE)\s+(\(.*\))\z/is 2472 0 2472
51 if $sql =~ /\A(WHERE)\s+(\(.*\))\z/si;
52 2472 return [ $sql, @bind ];
53 922 ▶ };
Condition33%1/3
$opts{"render_clause"}{"select.where"} ||= sub { my($sql, @bind) = $_[0]->where($_[2]); s/\A\s+//, s/\s+\Z// foreach ($sql); $sql = "$1 " . __unwrap_redundant_paren($2) if $sql =~ /\A(WHERE)\s+(\(.*\))\z/is; return [$sql, @bind]; }
l!l&&r!l&&!r
09220
MC/DC0%0/2
$opts{"render_clause"}{"select.where"} ||= sub { my($sql, @bind) = $_[0]->where($_[2]); s/\A\s+//, s/\s+\Z// foreach ($sql); $sql = "$1 " . __unwrap_redundant_paren($2) if $sql =~ /\A(WHERE)\s+(\(.*\))\z/is; return [$sql, @bind]; }
$opts{"render_clause"}{"select.where"} sub { my($sql, @bind) = $_[0]->where($_[2]); s/\A\s+//, s/\s+\Z// foreach ($sql); $sql = "$1 " . __unwrap_redundant_paren($2) if $sql =~ /\A(WHERE)\s+(\(.*\))\z/is; return [$sql, @bind]; }
Truth table33%1/3
A ||= B
A= $opts{"render_clause"}{"select.where"}B= sub { my($sql, @bind) = $_[0]->where($_[2]); s/\A\s+//, s/\s+\Z// foreach ($sql); $sql = "$1 " . __unwrap_redundant_paren($2) if $sql =~ /\A(WHERE)\s+(\(.*\))\z/is; return [$sql, @bind]; }
ABresult
1X1
011
000
54  
55 922 return $self->next::method(\%opts);
56 }
57  
58 # The operator of a condition, { column => { OPERATOR => value } }, is checked
59 # at its raw name, before SQL::Abstract cuts a prefix off it (see
60 # "operator_words"). A word is an entry of that list (case does not matter,
61 # '_' equals ' ', a leading '-' is allowed); a symbol consists of the symbol
62 # characters alone and holds no comment opener. The same rule holds for the
63 # first element of -op => [ OP, ... ]; a numeric suffix (-like_1) is cut off
64 # as SQL::Abstract does and the name without it is checked.
65 87 ▶sub operator_words {
Subroutine operator_words: called CC=1 SCAR=0.0
Pod undocumented
66 return (
67 87 'like', 'not like', 'ilike', 'not ilike',
68 'in', 'not in', 'between', 'not between', 'is', 'is not',
69 'similar to', 'not similar to',
70 'regexp', 'not regexp', 'rlike', 'not rlike',
71 # the operators SQL::Abstract knows as special operators
72 'ident', 'value', 'nest', 'bind', 'and', 'or',
73 # core's own marker of the upsert condition ("attempted" in ADR 0036)
74 'attempted',
75 );
76 }
77  
78 1465 ▶sub _operator_word_set {
Subroutine _operator_word_set: called CC=2 SCAR=6.9
79 1465 my $self = shift;
80 return $self->{_dbio_operator_word_set} ||= {
81 1465 ▶ map { __normalize_operator_word($_) => 1 } $self->operator_words
Condition100%2/2
$self->{"_dbio_operator_word_set"} ||= {map({__normalize_operator_word($_), 1;} $self->operator_words)}
l!l
137887
MC/DC100%1/1
$self->{"_dbio_operator_word_set"} ||= {map({__normalize_operator_word($_), 1;} $self->operator_words)}
$self->{"_dbio_operator_word_set"}
Truth table100%2/2
A
A= $self->{"_dbio_operator_word_set"}
Aresult
11
00
82 };
83 }
84  
85 3467 ▶sub __normalize_operator_word {
Subroutine __normalize_operator_word: called CC=1 SCAR=0.0
86 3467 my $w = lc $_[0];
87 3467 $w =~ s/\A-(?=.)//s;
88 3467 $w =~ s/[_ ]+/ /g;
89 3467 return $w;
90 }
91  
92 12707 ▶sub _assert_operator_name {
Subroutine _assert_operator_name: called CC=10 SCAR=24.5
93 12707 my ($self, $raw) = @_;
94  
95 12707 ▶ if (defined $raw and ! ref $raw) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $raw and not ref $raw) 12707 0 12707
Condition33%1/3
defined $raw and not ref $raw
!ll&&!rl&&r
0012707
MC/DC0%0/2
defined $raw and not ref $raw
defined $raw not ref $raw
Truth table33%1/3
A and not(B)
A= defined $rawB= not ref $raw
ABresult
0X0
100
111
96 12707 ▶ return if $raw =~ m{\A[-+*/<>=~!@#%^&|`?]+\z}
Branch: 1 branch
BranchTrueFalseTotal
if $raw =~ m[\A[-+*/<>=~!\@#%^&|`?]+\z] and not $raw =~ m[--|/\*] 11228 1479 12707
Condition100%3/3
$raw =~ m[\A[-+*/<>=~!\@#%^&|`?]+\z] and not $raw =~ m[--|/\*]
!ll&&!rl&&r
1475411228
MC/DC100%2/2
$raw =~ m[\A[-+*/<>=~!\@#%^&|`?]+\z] and not $raw =~ m[--|/\*]
$raw =~ m[\A[-+*/<>=~!\@#%^&|`?]+\z] not $raw =~ m[--|/\*]
Truth table100%3/3
A and not(B)
A= $raw =~ m[\A[-+*/<>=~!\@#%^&|`?]+\z]B= not $raw =~ m[--|/\*]
ABresult
0X0
100
111
97 and $raw !~ m{--|/\*};
98  
99 # a numeric suffix is cut off by SQL::Abstract (-like_1, -like1); the
100 # word without it is the name that is checked
101 1479 (my $word = $raw) =~ s/ _? \d+ \z//x;
102 return if $word =~ /\A-?[A-Za-z][A-Za-z_ ]*\z/
103 1479 ▶ and $self->_operator_word_set->{ __normalize_operator_word($word) };
Branch: 1 branch
BranchTrueFalseTotal
if $word =~ /\A-?[A-Za-z][A-Za-z_ ]*\z/ and $self->_operator_word_set->{__normalize_operator_word($word)} 1459 20 1479
Condition100%3/3
$word =~ /\A-?[A-Za-z][A-Za-z_ ]*\z/ and $self->_operator_word_set->{__normalize_operator_word($word)}
!ll&&!rl&&r
1461459
MC/DC100%2/2
$word =~ /\A-?[A-Za-z][A-Za-z_ ]*\z/ and $self->_operator_word_set->{__normalize_operator_word($word)}
$word =~ /\A-?[A-Za-z][A-Za-z_ ]*\z/ $self->_operator_word_set->{__normalize_operator_word($word)}
Truth table100%3/3
A and B
A= $word =~ /\A-?[A-Za-z][A-Za-z_ ]*\z/B= $self->_operator_word_set->{__normalize_operator_word($word)}
ABresult
0X0
100
111
104 }
105  
106 20 ▶ DBIO::Exception->throw( sprintf (
Branch: 2 branches
BranchTrueFalseTotal
defined $raw ? : 20 0 20
ref $raw ? : 0 20 20
Condition33%1/3
ref $self || $self
l!l&&r!l&&!r
2000
MC/DC0%0/2
ref $self || $self
ref $self $self
Truth table33%1/3
A || B
A= ref $selfB= $self
ABresult
1X1
011
000
107 "'%s' is not an operator of a condition: an operator is a symbol of the "
108 . "characters + - * / < > = ~ ! @ # %% ^ & | ` ? (without '--' and '/*') "
109 . "or a word of the list of %s->operator_words",
110 ( defined $raw ? ( ref $raw ? DBIO::Util::refdesc($raw) : $raw ) : 'undef' ),
111 ref $self || $self,
112 ));
113 }
114  
115 # -op => [ OP, ... ] in a raw condition: the same rule, at the raw name. The
116 # names the generator itself renders (is_null, not, ',', ...) are the keys of
117 # its render_op and expand_op tables; they pass.
118 3359 ▶sub _expand_op {
Subroutine _expand_op: called CC=6 SCAR=19.3
119 3359 my ($self, undef, $args) = @_;
120 3359 ▶ my $op = ref $args eq 'ARRAY' ? $args->[0] : undef;
Branch: 1 branch
BranchTrueFalseTotal
ref $args eq 'ARRAY' ? : 3359 0 3359
121 $self->_assert_operator_name($op)
122 unless defined $op and ! ref $op
123 3359 ▶ and ( $self->{render_op}{$op} or $self->{expand_op}{$op} );
Branch: 1 branch
BranchTrueFalseTotal
unless defined $op and not ref $op and $self->{"render_op"}{$op} || $self->{"expand_op"}{$op} 2909 450 3359
Condition55%5/9
defined $op and not ref $op and $self->{"render_op"}{$op} || $self->{"expand_op"}{$op}
!ll&&!rl&&r
02909450
defined $op and not ref $op
!ll&&!rl&&r
003359
$self->{"render_op"}{$op} or $self->{"expand_op"}{$op}
l!l&&r!l&&!r
45002909
MC/DC25%1/4
defined $op and not ref $op and $self->{"render_op"}{$op} || $self->{"expand_op"}{$op}
defined $op not ref $op $self->{"render_op"}{$op} $self->{"expand_op"}{$op}
Truth table40%2/5
A and not(B) and C or D
A= defined $opB= not ref $opC= $self->{"render_op"}{$op}D= $self->{"expand_op"}{$op}
ABCDresult
0XXX0
10XX0
11000
111X1
11011
124 3355 return shift->next::method(@_);
125 }
126  
127 9737 ▶sub _expand_hashtriple {
Subroutine _expand_hashtriple: called CC=1 SCAR=0.0
128 9737 $_[0]->_assert_operator_name($_[2]);
129 9725 return shift->next::method(@_);
130 }
131  
132 # The truth value of a condition (see "search" in DBIO::ResultSet). Every node
133 # of a condition is TRUE, FALSE or SQL; SELECT, UPDATE and DELETE build their
134 # WHERE through the same three clause hooks below, so they read it alike.
135 27213 ▶sub __literal_is {
Subroutine __literal_is: called CC=7 SCAR=19.5
136 27213 my ($node, $sql) = @_;
137 return (
138 ref $node eq 'HASH' and keys %$node == 1
139 4160 and ref $node->{-literal} eq 'ARRAY' and @{ $node->{-literal} } == 1
140 27213 ▶ and defined $node->{-literal}[0] and $node->{-literal}[0] eq $sql
Branch: 1 branch
BranchTrueFalseTotal
ref $node eq 'HASH' && keys %$node == 1 && ref $node->{'-literal'} eq 'ARRAY' && @{$node->{'-literal'};} == 1 && defined $node->{'-literal'}[0] && $node->{'-literal'}[0] eq $sql ? : 1177 26036 27213
Condition93%14/15
ref $node eq "HASH" and keys %$node == 1 and ref $node->{"-literal"} eq "ARRAY" and @{$node->{"-literal"};} == 1 and defined $node->{"-literal"}[0] and $node->{"-literal"}[0] eq $sql
!ll&&!rl&&r
2400020361177
ref $node eq "HASH" and keys %$node == 1 and ref $node->{"-literal"} eq "ARRAY" and @{$node->{"-literal"};} == 1 and defined $node->{"-literal"}[0]
!ll&&!rl&&r
231538473213
ref $node eq "HASH" and keys %$node == 1 and ref $node->{"-literal"} eq "ARRAY" and @{$node->{"-literal"};} == 1
!ll&&!rl&&r
230531004060
ref $node eq "HASH" and keys %$node == 1 and ref $node->{"-literal"} eq "ARRAY"
!ll&&!rl&&r
42230114160
ref $node eq "HASH" and keys %$node == 1
!ll&&!rl&&r
42027171
MC/DC83%5/6
ref $node eq "HASH" and keys %$node == 1 and ref $node->{"-literal"} eq "ARRAY" and @{$node->{"-literal"};} == 1 and defined $node->{"-literal"}[0] and $node->{"-literal"}[0] eq $sql
ref $node eq "HASH" keys %$node == 1 ref $node->{"-literal"} eq "ARRAY" @{$node->{"-literal"};} == 1 defined $node->{"-literal"}[0] $node->{"-literal"}[0] eq $sql
Truth table85%6/7
A and B and C and D and E and F
A= ref $node eq "HASH"B= keys %$node == 1C= ref $node->{"-literal"} eq "ARRAY"D= @{$node->{"-literal"};} == 1E= defined $node->{"-literal"}[0]F= $node->{"-literal"}[0] eq $sql
ABCDEFresult
0XXXXX0
10XXXX0
110XXX0
1110XX0
11110X0
1111100
1111111
141 ) ? 1 : 0;
142 }
143  
144 5150 ▶sub _expand_op_andor {
Subroutine _expand_op_andor: called CC=26 SCAR=33.1
145 5150 my ($self, $logop, $v, $k) = @_;
146  
147 5150 ▶ if (! defined $k) {
Branch: 1 branch
BranchTrueFalseTotal
unless (defined $k) 4935 215 5150
148 # an empty group: -and is TRUE, -or (and [] as a whole) is FALSE
149 4935 ▶ if (ref $v eq 'HASH' ? ! %$v : ref $v eq 'ARRAY' ? ! @$v : 0) {
Branch: 3 branches
BranchTrueFalseTotal
if (ref $v eq "HASH" ? !%$v : (ref $v eq "ARRAY" ? !@$v : 0)) 172 4763 4935
ref $v eq 'HASH' ? : 1488 3447 4935
ref $v eq 'ARRAY' ? : 3447 0 3447
150 172 ▶ return $logop eq 'or' ? $self->sqlfalse : $self->sqltrue;
Branch: 1 branch
BranchTrueFalseTotal
$logop eq 'or' ? : 130 42 172
151 }
152  
153 # an empty member of a list is a truth value of its own: {} is TRUE, [] is
154 # FALSE (a bare key takes the element after it as its value, so skip both)
155 4763 ▶ if (ref $v eq 'ARRAY') {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $v eq "ARRAY") 3291 1472 4763
156 3291 my @members = @$v;
157 3291 my @out;
158 3291 ▶ while (@members) {
Branch: 1 branch
BranchTrueFalseTotal
if (@members) 6002 3291 9293
159 6002 my $m = shift @members;
160 6002 ▶ if (! ref $m) {
Branch: 3 branches
BranchTrueFalseTotal
if (not ref $m) { } 3329 2673 6002
elsif (ref $m eq 'HASH' and not %$m) { } 310 2363 2673
elsif (ref $m eq 'ARRAY' and not @$m) { } 298 2065 2363
161 3329 ▶ push @out, $m, (@members ? shift @members : ());
Branch: 1 branch
BranchTrueFalseTotal
@members ? : 3305 24 3329
162 }
163 ▶ elsif (ref $m eq 'HASH' and ! %$m) {
Condition100%3/3
ref $m eq "HASH" and not %$m
!ll&&!rl&&r
7381625310
MC/DC100%2/2
ref $m eq "HASH" and not %$m
ref $m eq "HASH" not %$m
Truth table100%3/3
A and not(B)
A= ref $m eq "HASH"B= not %$m
ABresult
0X0
100
111
164 310 push @out, $self->sqltrue;
165 }
166 ▶ elsif (ref $m eq 'ARRAY' and ! @$m) {
Condition100%3/3
ref $m eq "ARRAY" and not @$m
!ll&&!rl&&r
1835230298
MC/DC100%2/2
ref $m eq "ARRAY" and not @$m
ref $m eq "ARRAY" not @$m
Truth table100%3/3
A and not(B)
A= ref $m eq "ARRAY"B= not @$m
ABresult
0X0
100
111
167 298 push @out, $self->sqlfalse;
168 }
169 else {
170 2065 push @out, $m;
171 }
172 }
173 3291 $v = \@out;
174 }
175 }
176  
177 4978 my $aqt = $self->SUPER::_expand_op_andor($logop, $v, $k);
178  
179 # fold: a group with a FALSE member is FALSE (and), with a TRUE member TRUE (or);
180 # the neutral members (TRUE in an and, FALSE in an or) drop out
181 return $aqt unless (
182 ref $aqt eq 'HASH' and keys %$aqt == 1 and ref $aqt->{-op} eq 'ARRAY'
183 4978 ▶ and $aqt->{-op}[0] eq $logop and ($logop eq 'and' or $logop eq 'or')
Branch: 1 branch
BranchTrueFalseTotal
unless ref $aqt eq "HASH" and keys %$aqt == 1 and ref $aqt->{"-op"} eq "ARRAY" and $aqt->{"-op"}[0] eq $logop and $logop eq "and" || $logop eq "or" 0 4978 4978
Condition40%6/15
ref $aqt eq "HASH" and keys %$aqt == 1 and ref $aqt->{"-op"} eq "ARRAY" and $aqt->{"-op"}[0] eq $logop and $logop eq "and" || $logop eq "or"
!ll&&!rl&&r
004978
ref $aqt eq "HASH" and keys %$aqt == 1 and ref $aqt->{"-op"} eq "ARRAY" and $aqt->{"-op"}[0] eq $logop
!ll&&!rl&&r
004978
ref $aqt eq "HASH" and keys %$aqt == 1 and ref $aqt->{"-op"} eq "ARRAY"
!ll&&!rl&&r
004978
ref $aqt eq "HASH" and keys %$aqt == 1
!ll&&!rl&&r
004978
$logop eq "and" or $logop eq "or"
l!l&&r!l&&!r
266923090
MC/DC0%0/6
ref $aqt eq "HASH" and keys %$aqt == 1 and ref $aqt->{"-op"} eq "ARRAY" and $aqt->{"-op"}[0] eq $logop and $logop eq "and" || $logop eq "or"
ref $aqt eq "HASH" keys %$aqt == 1 ref $aqt->{"-op"} eq "ARRAY" $aqt->{"-op"}[0] eq $logop $logop eq "and" $logop eq "or"
Truth table28%2/7
A and B and C and D and E or F
A= ref $aqt eq "HASH"B= keys %$aqt == 1C= ref $aqt->{"-op"} eq "ARRAY"D= $aqt->{"-op"}[0] eq $logopE= $logop eq "and"F= $logop eq "or"
ABCDEFresult
0XXXXX0
10XXXX0
110XXX0
1110XX0
1111000
11111X1
1111011
184 );
185  
186 4978 my ($op, @members) = @{ $aqt->{-op} };
187 my ($neutral, $dominant) = $logop eq 'and'
188 ? ($self->{sqltrue}, $self->{sqlfalse})
189 : ($self->{sqlfalse}, $self->{sqltrue})
190 4978 ▶ ;
Branch: 1 branch
BranchTrueFalseTotal
$logop eq 'and' ? : 2669 2309 4978
191  
192 return $logop eq 'and' ? $self->sqlfalse : $self->sqltrue
193 4978 ▶ if grep { __literal_is($_, $dominant) } @members;
Branch: 2 branches
BranchTrueFalseTotal
if grep {__literal_is($_, $dominant);} @members 534 4444 4978
$logop eq 'and' ? : 148 386 534
194  
195 4444 my @kept = grep { ! __literal_is($_, $neutral) } @members;
196 4444 ▶ return $aqt if @kept == @members;
Branch: 1 branch
BranchTrueFalseTotal
if @kept == @members 4142 302 4444
197  
198 302 ▶ return $logop eq 'and' ? $self->sqltrue : $self->sqlfalse unless @kept;
Branch: 2 branches
BranchTrueFalseTotal
unless @kept 206 96 302
$logop eq 'and' ? : 88 118 206
199 96 return { -op => [ $op, @kept ] };
200 }
201  
202 # a WHERE that is TRUE is no restriction: it renders as nothing
203 9639 ▶sub _where_truth {
Subroutine _where_truth: called CC=2 SCAR=6.9
204 9639 my ($self, $key, $aqt) = @_;
205 9639 ▶ return ($key, __literal_is($aqt, $self->{sqltrue}) ? undef : $aqt);
Branch: 1 branch
BranchTrueFalseTotal
__literal_is($aqt, $self->{'sqltrue'}) ? : 210 9429 9639
206 }
207  
208 8157 ▶sub _expand_select_clause_where {
Subroutine _expand_select_clause_where: called CC=1 SCAR=0.0
209 8157 my $self = shift;
210 8157 return $self->_where_truth($self->SUPER::_expand_select_clause_where(@_));
211 }
212  
213 173 ▶sub _expand_update_clause_where {
Subroutine _expand_update_clause_where: called CC=1 SCAR=0.0
214 173 my $self = shift;
215 173 return $self->_where_truth($self->SUPER::_expand_update_clause_where(@_));
216 }
217  
218 1331 ▶sub _expand_delete_clause_where {
Subroutine _expand_delete_clause_where: called CC=1 SCAR=0.0
219 1331 my $self = shift;
220 1331 return $self->_where_truth($self->SUPER::_expand_delete_clause_where(@_));
221 }
222  
223 # Given the 'WHERE ( <inner> )' block that where() added (passed in with its
224 # own surrounding parens), return the canonical single-layer 'inner'. If the
225 # content between where()'s parens is itself exactly one balanced parenthesised
226 # group spanning the whole content (the -and/-or case), the redundant pair is
227 # dropped; otherwise the block is returned unchanged. Balance counting (not a
228 # naive ^\( .. \)$ match) is required so a content like '( a ) OR ( b )' -- two
229 # sibling groups -- is NOT mistaken for one wrapping layer.
230 2472 ▶sub __unwrap_redundant_paren {
Subroutine __unwrap_redundant_paren: called CC=7 SCAR=19.5
231 2472 my ($block) = @_;
232 # $block always looks like '( <content> )' here.
233 2472 my $content = $block;
234 2472 $content =~ s/\A\(\s*//;
235 2472 $content =~ s/\s*\)\z//;
236 2472 ▶ return $block unless $content =~ /\A\(/; # nothing to unwrap
Branch: 1 branch
BranchTrueFalseTotal
unless $content =~ /\A\(/ 2243 229 2472
237  
238 # Walk $content; find the position that closes the leading '('. If it is the
239 # final character, the leading '(' and trailing ')' are a single matched pair
240 # spanning everything, i.e. a redundant wrapping layer -> drop it.
241 229 my $depth = 0;
242 229 my @chars = split //, $content;
243 229 for my $i (0 .. $#chars) {
244 11398 my $c = $chars[$i];
245 11398 ▶ $depth++ if $c eq '(';
Branch: 1 branch
BranchTrueFalseTotal
if $c eq "(" 343 11055 11398
246 11398 ▶ $depth-- if $c eq ')';
Branch: 1 branch
BranchTrueFalseTotal
if $c eq ")" 343 11055 11398
247 11398 ▶ if ($depth == 0) {
Branch: 1 branch
BranchTrueFalseTotal
if ($depth == 0) 229 11169 11398
248 229 ▶ return $i == $#chars ? $content : $block;
Branch: 1 branch
BranchTrueFalseTotal
$i == $#chars ? : 229 0 229
249 }
250 }
251 0 return $block;
252 }
253  
254 192 1;
255  
256 __END__
« blib/lib/DBIO/Introspect/DBI.pm ↑ Summary blib/lib/DBIO/Carp.pm »