EV/QueryExecutor.pm

filter: Statementstmt 100% 240 / 240 Branchbran 85.7% 96 / 112 Conditioncond 75.7% 100 / 132 MC/DCmcdc 53.6% 37 / 69 Subroutinesub 100% 43 / 43 Podpod 100% 6 / 6 totaltotal 86.7% 522 / 602 CC 105 SCAR 19.0
CC
105
Cov
90%
_handle_code
15.4
_server_sqlstate
15.3
execute
10.0
CRAP 6.7
« EV/Storage.pm ↑ Summary EV/Future.pm »
1 package DBIO::MySQL::EV::QueryExecutor;
2 # ABSTRACT: Query execution wrapper for DBIO MySQL async storage
3  
4 60 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
5 60 ▶use warnings;
Subroutine BEGIN: called CC=1 SCAR=0.0
6  
7 60 our $VERSION = '0.900007';
8  
9 60 ▶use Scalar::Util ();
Subroutine BEGIN: called CC=1 SCAR=0.0
10 60 ▶use DBIO::Exception ();
Subroutine BEGIN: called CC=1 SCAR=0.0
11 60 ▶use DBIO::Exception::Server ();
Subroutine BEGIN: called CC=1 SCAR=0.0
12 60 ▶use DBIO::MySQL::EV::Future;
Subroutine BEGIN: called CC=1 SCAR=0.0
13  
14  
15 # Per connection (refaddr of the handle), the settling of one of its Futures
16 # that runs right now (_drain) -- the innermost one when they nest:
17 # { active => 1 } while it runs. What it calls is a then chain or a txn_do
18 # coderef, which holds the connection's transaction until it returns
19 # (_waits_for_callback, karr k53). Not EV::MariaDB's callback_depth: those
20 # callbacks only prepare, execute, close and hand the answer on (karr k51).
21 60 my %FRAME;
22  
23 # Per connection, how often it was forgotten (forget): the settling of a
24 # statement that was answered before its handle was forgotten leaves the counts
25 # alone, they belong to the next handle at that address.
26 my %GEN;
27  
28 # Per connection (refaddr of the handle), the number of statements dispatched
29 # on it whose Future has not settled: counted up once EV::MariaDB has taken the
30 # statement, down where the Future is settled. A count that is never taken
31 # down -- a handle that goes away without calling back, or a forked child,
32 # where the callbacks return at once -- reads as work in flight, which errs on
33 # the side of waiting.
34 60 my %IN_FLIGHT;
35  
36 # Per connection, how many of those are exclusive operations (prepare, execute,
37 # close_stmt): a statement with bind values or a CALL. While one is in flight
38 # EV::MariaDB refuses a query (karr k81).
39 60 my %EXCL;
40  
41 # Per connection, the statements that wait for every statement in flight on it
42 # to settle (execute_when_idle): coderefs, oldest first, each started once the
43 # count above is back at zero: { future => the Future the caller waits on,
44 # run => the coderef that starts it }. They hold the handle weakly; forget
45 # fails the futures.
46 60 my %AFTER;
47  
48 # The executor traces nothing: it is no storage. The statement trace is the
49 # core's (DBIO::Storage::Async/_debug_query, ADR 0025), called by
50 # DBIO::MySQL::EV::Storage once per statement.
51 172 ▶sub new {
Subroutine new: called CC=2 SCAR=6.9
Pod documented
52 172 my ($class, %args) = @_;
53 bless {
54 future_class => $args{future_class} // 'DBIO::MySQL::EV::Future',
55 error_masker => $args{error_masker},
56 172 ▶ }, $class;
Condition100%2/2
$args{"future_class"} // "DBIO::MySQL::EV::Future"
l!l
14428
MC/DC100%1/1
$args{"future_class"} // "DBIO::MySQL::EV::Future"
$args{"future_class"}
Truth table100%2/2
A
A= $args{"future_class"}
Aresult
11
00
57 }
58  
59  
60  
61 705 ▶sub execute {
Subroutine execute: called CC=10 SCAR=23.1
Pod documented
62 705 my ($self, $mdb, $sql, $bind) = @_;
63 705 ▶ $bind //= [];
Condition50%1/2
$bind //= []
l!l
7050
MC/DC0%0/1
$bind //= []
$bind
Truth table50%1/2
A
A= $bind
Aresult
11
00
64  
65 705 my $f = $self->{future_class}->new;
66 705 my $pid = $$;
67 705 my $key = Scalar::Util::refaddr($mdb);
68 705 ▶ my $exclusive = (@$bind || _is_call($sql)) ? 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
@$bind || _is_call($sql) ? : 301 404 705
Condition100%3/3
@$bind or _is_call($sql)
l!l&&r!l&&!r
2947404
MC/DC100%2/2
@$bind or _is_call($sql)
@$bind _is_call($sql)
Truth table100%3/3
A or B
A= @$bindB= _is_call($sql)
ABresult
1X1
011
000
69 705 my $settle = _settle_cb($f, $pid, $key, $exclusive);
70  
71 # EV::MariaDB::query($sql, $cb) does NOT accept bind values — passes a
72 # bind arrayref to it is silently dropped. When the SQL has placeholders
73 # we MUST route through prepare + execute; otherwise the bind values
74 # never reach the server and the query fails with a SQL syntax error on
75 # the '?' placeholders (or, worse, runs with whatever the previous
76 # prepared statement's binds were — silent corruption). Empty binds
77 # stay on the cheap query() path.
78 #
79 # A CALL without bind values goes the same way (karr k84). EV::MariaDB's
80 # query() calls back with the first result set and reads the rest of the
81 # answer -- the closing OK of the CALL, further result sets -- only after the
82 # callback returned, with nothing on the handle that says so; a statement
83 # with bind values that follows on the connection is then refused. Prepared
84 # and executed, the whole answer is read before the callback runs.
85 #
86 # An error text is masked (ADR 0075 of the core) by $mask, built here from
87 # the bound values and the statement; a dispatch EV::MariaDB refuses dies
88 # with its text masked as well.
89 705 my $mask = _error_mask($self->{error_masker}, $bind, $sql);
90 {
91 705 local $@;
92 705 my $dispatched = eval {
93 705 ▶ if (@$bind || _is_call($sql)) {
Branch: 1 branch
BranchTrueFalseTotal
if (@$bind or _is_call($sql)) { } 301 404 705
Condition100%3/3
@$bind or _is_call($sql)
l!l&&r!l&&!r
2947404
MC/DC100%2/2
@$bind or _is_call($sql)
@$bind _is_call($sql)
Truth table100%3/3
A or B
A= @$bindB= _is_call($sql)
ABresult
1X1
011
000
94 301 $mdb->prepare($sql, _prepared_cb($mdb, $bind, $settle, $pid, $mask));
95 }
96 else {
97 404 $mdb->query($sql, _queried_cb($mdb, $settle, $pid, $mask));
98 }
99 694 1;
100 };
101 705 ▶ unless ($dispatched) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($dispatched) 11 694 705
102 11 my $died = $@;
103 11 die _masked($mask, $died, _handle_code($mdb, $died));
104 }
105 }
106  
107 # Dispatched -- a croak above never gets here. A handle that called back
108 # before it returned has settled the Future already and left the count at
109 # -1, so both sides drop the entry at zero.
110 694 ▶ delete $IN_FLIGHT{$key} unless ++$IN_FLIGHT{$key};
Branch: 1 branch
BranchTrueFalseTotal
unless ++$IN_FLIGHT{$key} 1 693 694
111 694 ▶ delete $EXCL{$key} if $exclusive && !++$EXCL{$key};
Branch: 1 branch
BranchTrueFalseTotal
if $exclusive and not ++$EXCL{$key} 0 694 694
Condition66%2/3
$exclusive and not ++$EXCL{$key}
!ll&&!rl&&r
4002940
MC/DC0%0/2
$exclusive and not ++$EXCL{$key}
$exclusive not ++$EXCL{$key}
Truth table66%2/3
A and not(B)
A= $exclusiveB= not ++$EXCL{$key}
ABresult
0X0
100
111
112  
113 694 return $f;
114 }
115  
116  
117 279 ▶sub reset_connection {
Subroutine reset_connection: called CC=3 SCAR=11.1
Pod documented
118 279 my ($self, $mdb) = @_;
119  
120 279 my $f = $self->{future_class}->new;
121 279 my $pid = $$;
122 279 my $key = Scalar::Util::refaddr($mdb);
123 279 my $settle = _settle_cb($f, $pid, $key, 1);
124  
125 279 my $mask = _error_mask($self->{error_masker}, [], undef);
126 279 $mdb->reset_connection(_reset_cb($mdb, $settle, $mask));
127  
128 277 ▶ delete $IN_FLIGHT{$key} unless ++$IN_FLIGHT{$key};
Branch: 1 branch
BranchTrueFalseTotal
unless ++$IN_FLIGHT{$key} 0 277 277
129 277 ▶ delete $EXCL{$key} if !++$EXCL{$key};
Branch: 1 branch
BranchTrueFalseTotal
unless ++$EXCL{$key} 0 277 277
130  
131 277 return $f;
132 }
133  
134  
135 50 ▶sub execute_when_idle {
Subroutine execute_when_idle: called CC=2 SCAR=6.9
Pod documented
136 50 my ($self, $mdb, $sql, $bind, $timeout) = @_;
137  
138 50 my $key = Scalar::Util::refaddr($mdb);
139 50 ▶ return $self->execute($mdb, $sql, $bind) unless $IN_FLIGHT{$key};
Branch: 1 branch
BranchTrueFalseTotal
unless $IN_FLIGHT{$key} 14 36 50
140 36 return $self->_enqueue($mdb, $sql, $bind, $timeout);
141 }
142  
143  
144 283 ▶sub execute_after_exclusive {
Subroutine execute_after_exclusive: called CC=4 SCAR=14.0
Pod documented
145 283 my ($self, $mdb, $sql, $bind) = @_;
146 283 my $key = Scalar::Util::refaddr($mdb);
147 283 ▶ return $self->execute($mdb, $sql, $bind) unless $EXCL{$key} || ($AFTER{$key} && $IN_FLIGHT{$key});
Branch: 1 branch
BranchTrueFalseTotal
unless $EXCL{$key} or $AFTER{$key} and $IN_FLIGHT{$key} 281 2 283
Condition66%4/6
$EXCL{$key} or $AFTER{$key} and $IN_FLIGHT{$key}
l!l&&r!l&&!r
20281
$AFTER{$key} and $IN_FLIGHT{$key}
!ll&&!rl&&r
27920
MC/DC33%1/3
$EXCL{$key} or $AFTER{$key} and $IN_FLIGHT{$key}
$EXCL{$key} $AFTER{$key} $IN_FLIGHT{$key}
Truth table75%3/4
A or B and C
A= $EXCL{$key}B= $AFTER{$key}C= $IN_FLIGHT{$key}
ABCresult
1XX1
0111
00X0
0100
148 2 return $self->_enqueue($mdb, $sql, $bind);
149 }
150  
151 # Queue a statement behind the ones in flight on $mdb. With a $timeout (seconds,
152 # a positive number) its Future fails with a DBIO::Exception naming the wait
153 # when the statement has not been started by then (karr k81).
154 38 ▶sub _enqueue {
Subroutine _enqueue: called CC=3 SCAR=11.0
155 38 my ($self, $mdb, $sql, $bind, $timeout) = @_;
156 38 my $key = Scalar::Util::refaddr($mdb);
157  
158 38 my $outer = $self->{future_class}->new;
159 38 my $timer;
160 38 ▶ if ($timeout && $timeout > 0) {
Branch: 1 branch
BranchTrueFalseTotal
if ($timeout and $timeout > 0) 13 25 38
Condition66%2/3
$timeout and $timeout > 0
!ll&&!rl&&r
25013
MC/DC50%1/2
$timeout and $timeout > 0
$timeout $timeout > 0
Truth table66%2/3
A and B
A= $timeoutB= $timeout > 0
ABresult
0X0
100
111
161 13 Scalar::Util::weaken(my $weak_outer = $outer);
162 13 EV::now_update(); # a timer counts from the loop's last "now", maybe long ago
163 3 ▶ $timer = EV::timer($timeout, 0, sub {
Subroutine __ANON__: called CC=3 SCAR=11.2
164 3 undef $timer;
165 3 ▶ my $f = $weak_outer or return;
Branch: 1 branch
BranchTrueFalseTotal
my $f = $weak_outer or return 3 0 3
166 3 ▶ return if $f->is_ready;
Branch: 1 branch
BranchTrueFalseTotal
if $f->is_ready 0 3 3
167 3 local $@;
168 3 eval { DBIO::Exception->throw(
169 "statement not sent: the statement in flight on the connection did not answer within ${timeout}s", 0) };
170 3 $f->fail($@);
171 13 });
172 13 ▶ $outer->on_ready(sub { undef $timer });
Subroutine __ANON__: called CC=1 SCAR=0.0
173 }
174 38 Scalar::Util::weaken(my $weak_mdb = $mdb);
175 38 ▶ push @{ $AFTER{$key} }, { future => $outer, run => sub {
Subroutine __ANON__: called CC=5 SCAR=16.2
176 25 undef $timer;
177 25 ▶ return if $outer->is_ready;
Branch: 1 branch
BranchTrueFalseTotal
if $outer->is_ready 4 21 25
178 21 ▶ my $handle = $weak_mdb
Branch: 1 branch
BranchTrueFalseTotal
my $handle = $weak_mdb or return $outer->fail("connection is gone before the statement could be sent") 21 0 21
179 or return $outer->fail('connection is gone before the statement could be sent');
180 21 my $inner;
181 {
182 21 local $@;
183 21 ▶ unless (eval { $inner = $self->execute($handle, $sql, $bind); 1 }) {
Branch: 1 branch
BranchTrueFalseTotal
unless (eval { do { $inner = $self->execute($handle, $sql, $bind); 1 } }) 4 17 21
184 4 ▶ return $outer->fail($@ || 'statement could not be sent');
Condition50%1/2
$@ || 'statement could not be sent'
l!l
40
MC/DC0%0/1
$@ || 'statement could not be sent'
$@
Truth table50%1/2
A
A= $@
Aresult
11
00
185 }
186 }
187 17 ▶ $inner->on_done(sub { $outer->done(@_) unless $outer->is_ready });
Subroutine __ANON__: called CC=2 SCAR=7.2
Branch: 1 branch
BranchTrueFalseTotal
unless $outer->is_ready 16 0 16
188 17 ▶ $inner->on_fail(sub { $outer->fail(@_) unless $outer->is_ready });
Subroutine __ANON__: called CC=2 SCAR=7.2
Branch: 1 branch
BranchTrueFalseTotal
unless $outer->is_ready 1 0 1
189 17 return;
190 38 } };
191 38 return $outer;
192 }
193  
194 # Start the statements that wait on $key, for as long as nothing is in flight
195 # on it. One that was dispatched is in flight itself, and the one behind it
196 # starts when that one settles. One that sent nothing -- its Future was
197 # cancelled while it waited, its handle is gone, EV::MariaDB refused it --
198 # leaves nothing in flight, and no settling would ever come back here for the
199 # ones behind it: so the next one is started right away, until one is in flight
200 # or none is left.
201 951 ▶sub _start_next {
Subroutine _start_next: called CC=5 SCAR=16.1
202 951 my ($key) = @_;
203 951 ▶ until ($IN_FLIGHT{$key}) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($IN_FLIGHT{$key}) 417 559 976
204 417 ▶ my $queue = $AFTER{$key} or return;
Branch: 1 branch
BranchTrueFalseTotal
my $queue = $AFTER{$key} or return 25 392 417
205 25 my $next = shift @$queue;
206 25 ▶ delete $AFTER{$key} unless @$queue;
Branch: 1 branch
BranchTrueFalseTotal
unless @$queue 16 9 25
207 25 ▶ $next->{run}->() if $next;
Branch: 1 branch
BranchTrueFalseTotal
if $next 25 0 25
208 }
209 559 return;
210 }
211  
212  
213 80 ▶sub _waits_for_callback {
Subroutine _waits_for_callback: called CC=3 SCAR=11.0
214 80 my ($class, $mdb) = @_;
215 80 my $key = Scalar::Util::refaddr($mdb);
216 80 ▶ return $FRAME{$key} && !$IN_FLIGHT{$key} ? 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
$FRAME{$key} && !$IN_FLIGHT{$key} ? : 8 72 80
Condition100%3/3
$FRAME{$key} and not $IN_FLIGHT{$key}
!ll&&!rl&&r
47258
MC/DC100%2/2
$FRAME{$key} and not $IN_FLIGHT{$key}
$FRAME{$key} not $IN_FLIGHT{$key}
Truth table100%3/3
A and not(B)
A= $FRAME{$key}B= not $IN_FLIGHT{$key}
ABresult
0X0
100
111
217 }
218  
219  
220 284 ▶sub forget {
Subroutine forget: called CC=2 SCAR=6.9
Pod documented
221 284 my ($class, $mdb) = @_;
222 284 ▶ return unless defined $mdb;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $mdb 1 283 284
223 283 my $key = Scalar::Util::refaddr($mdb);
224 283 delete $FRAME{$key};
225 283 delete $IN_FLIGHT{$key};
226 283 delete $EXCL{$key};
227 283 $GEN{$key}++;
228 283 $class->_fail_waiting($mdb);
229 283 return;
230 }
231  
232  
233 559 ▶sub _fail_waiting {
Subroutine _fail_waiting: called CC=5 SCAR=16.1
234 559 my ($class, $mdb) = @_;
235 559 ▶ return unless defined $mdb;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $mdb 0 559 559
236 559 my $waiting = delete $AFTER{ Scalar::Util::refaddr($mdb) };
237 559 ▶ for my $w (@{ $waiting || [] }) {
Condition100%2/2
$waiting || []
l!l
10549
MC/DC100%1/1
$waiting || []
$waiting
Truth table100%2/2
A
A= $waiting
Aresult
11
00
238 13 my $f = $w->{future};
239 13 ▶ next if $f->is_ready;
Branch: 1 branch
BranchTrueFalseTotal
if $f->is_ready 3 10 13
240 10 local $@;
241 10 eval { DBIO::Exception->throw('connection torn down, statement not sent', 0) };
242 10 $f->fail($@);
243 }
244 559 return;
245 }
246  
247 # The callbacks below are named subs, not closures inside execute(): each
248 # closes over exactly what it is handed. The bind arrayref reaches the prepare
249 # callback, which hands it to execute -- the dispatch where its lifetime ends
250 # (ADR 0044) -- and no later callback holds it.
251 #
252 # Each returns at once outside $pid, the process that called execute(): in a
253 # forked child they run when the pool's fork guard finishes the child's copy of
254 # the handle (karr k46), and what they would do next -- close, settle, release,
255 # the caller's chain -- is the parent's.
256  
257 # Settles $f with an EV::MariaDB result ($rows, $err). Runs at most once: a
258 # close_stmt that croaked after calling back must not settle twice.
259 984 ▶sub _settle_cb {
Subroutine _settle_cb: called CC=1 SCAR=0.0
260 984 my ($f, $pid, $key, $exclusive) = @_;
261 984 my $settled;
262 955 ▶ return sub {
Subroutine __ANON__: called CC=4 SCAR=13.9
263 955 my ($rows, $err) = @_;
264 955 ▶ return if $$ != $pid;
Branch: 1 branch
BranchTrueFalseTotal
if $$ != $pid 0 955 955
265 955 ▶ return if $settled++;
Branch: 1 branch
BranchTrueFalseTotal
if $settled++ 1 954 955
266 # The Future settles from an idle watcher of the loop, not from inside this
267 # callback of the handle (karr k51): what its callbacks run -- a then, the
268 # coderef of a txn_do -- is outside every callback of the handle, so a
269 # statement it sends goes out at once and a blocking wait for it can end.
270 954 ▶ my $gen = $GEN{$key} // 0;
Condition100%2/2
$GEN{$key} // 0
l!l
7947
MC/DC100%1/1
$GEN{$key} // 0
$GEN{$key}
Truth table100%2/2
A
A= $GEN{$key}
Aresult
11
00
271 952 ▶ _defer($pid, $key, sub {
Subroutine __ANON__: called CC=8 SCAR=20.8
272 # Before the Future is settled: what that runs sees the statement answered.
273 952 ▶ if (($GEN{$key} // 0) == $gen) {
Branch: 1 branch
BranchTrueFalseTotal
if (($GEN{$key} // 0) == $gen) 950 2 952
Condition100%2/2
$GEN{$key} // 0
l!l
9943
MC/DC100%1/1
$GEN{$key} // 0
$GEN{$key}
Truth table100%2/2
A
A= $GEN{$key}
Aresult
11
00
274 950 ▶ delete $IN_FLIGHT{$key} unless --$IN_FLIGHT{$key};
Branch: 1 branch
BranchTrueFalseTotal
unless --$IN_FLIGHT{$key} 909 41 950
275 950 ▶ delete $EXCL{$key} if $exclusive && !--$EXCL{$key};
Branch: 1 branch
BranchTrueFalseTotal
if $exclusive and not --$EXCL{$key} 531 419 950
Condition100%3/3
$exclusive and not --$EXCL{$key}
!ll&&!rl&&r
38831531
MC/DC100%2/2
$exclusive and not --$EXCL{$key}
$exclusive not --$EXCL{$key}
Truth table100%3/3
A and not(B)
A= $exclusiveB= not --$EXCL{$key}
ABresult
0X0
100
111
276 }
277 952 ▶ if ($err) {
Branch: 1 branch
BranchTrueFalseTotal
if ($err) { } 74 878 952
278 74 $f->fail($err);
279 } else {
280 878 ▶ $f->done(ref $rows eq 'ARRAY' ? @$rows : $rows);
Branch: 1 branch
BranchTrueFalseTotal
ref $rows eq 'ARRAY' ? : 404 474 878
281 }
282 # What waits for the connection to have nothing in flight starts now
283 # (execute_when_idle), after what the settling above ran.
284 951 _start_next($key);
285 954 });
286 954 return;
287 984 };
288 }
289  
290 # The settlings the idle watcher has still to run, oldest first:
291 # [ $pid, $key, $code ]. One watcher for all connections, so Futures settle in
292 # the order the handles answered.
293 60 my @DEFERRED;
294 60 my $IDLE;
295  
296 # Queue $code, to run from the loop's idle watcher. It runs as a callback of
297 # connection $key (the frame k53 asks about): a transaction's coderef, run by
298 # the settling of its BEGIN, holds its connection until it returns.
299 954 ▶sub _defer {
Subroutine _defer: called CC=2 SCAR=7.0
300 954 my ($pid, $key, $code) = @_;
301 954 push @DEFERRED, [ $pid, $key, $code ];
302 954 ▶ $IDLE ||= EV::idle_ns(\&_drain);
Condition66%2/3
$IDLE ||= &EV::idle_ns(\&DBIO::MySQL::EV::QueryExecutor::_drain)
l!l&&r!l&&!r
933210
MC/DC0%0/2
$IDLE ||= &EV::idle_ns(\&DBIO::MySQL::EV::QueryExecutor::_drain)
$IDLE &EV::idle_ns(\&DBIO::MySQL::EV::QueryExecutor::_drain)
Truth table66%2/3
A ||= B
A= $IDLEB= &EV::idle_ns(\&DBIO::MySQL::EV::QueryExecutor::_drain)
ABresult
1X1
011
000
303 954 $IDLE->start;
304 954 return;
305 }
306  
307 # The idle watcher. Entries taken one at a time and before they run, so a
308 # blocking wait inside one of them -- a nested EV::run, which runs this watcher
309 # again -- carries on with the ones behind it and none runs twice. An entry
310 # that dies is warned about, like EV::MariaDB does for its callbacks, and does
311 # not stop the ones behind it. Entries of another process (a forked child
312 # inherits the parent's) are dropped: the parent runs them.
313 935 ▶sub _drain {
Subroutine _drain: called CC=6 SCAR=18.2
314 935 ▶ while (my $entry = shift @DEFERRED) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $entry = shift @DEFERRED) 952 935 1887
315 952 my ($pid, $key, $code) = @$entry;
316 952 ▶ next if $$ != $pid;
Branch: 1 branch
BranchTrueFalseTotal
if $$ != $pid 0 952 952
317 952 my $frame = {};
318 952 local $frame->{active} = 1;
319 952 local $FRAME{$key} = $frame;
320 952 local $@;
321 952 ▶ eval { $code->(); 1 } or warn "DBIO::MySQL::EV: exception in callback: $@";
Branch: 1 branch
BranchTrueFalseTotal
eval { do { &$code(); 1 } } or warn "DBIO::MySQL::EV: exception in callback: $@" 951 1 952
322 }
323 935 ▶ $IDLE->stop if $IDLE && !@DEFERRED;
Branch: 1 branch
BranchTrueFalseTotal
if $IDLE and not @DEFERRED 935 0 935
Condition33%1/3
$IDLE and not @DEFERRED
!ll&&!rl&&r
00935
MC/DC0%0/2
$IDLE and not @DEFERRED
$IDLE not @DEFERRED
Truth table33%1/3
A and not(B)
A= $IDLEB= not @DEFERRED
ABresult
0X0
100
111
324 935 return;
325 }
326  
327 301 ▶sub _prepared_cb {
Subroutine _prepared_cb: called CC=1 SCAR=0.0
328 301 my ($mdb, $bind, $settle, $pid, $mask) = @_;
329 294 ▶ return sub {
Subroutine __ANON__: called CC=7 SCAR=19.8
330 294 my ($stmt, $perr) = @_;
331 294 ▶ return if $$ != $pid;
Branch: 1 branch
BranchTrueFalseTotal
if $$ != $pid 0 294 294
332 # No statement id, nothing to close.
333 294 ▶ return $settle->(undef, _server_error($mdb, $perr, $mask) || 'prepare failed') if $perr || !defined $stmt;
Branch: 1 branch
BranchTrueFalseTotal
if $perr or not defined $stmt 14 280 294
Condition60%3/5
$perr or not defined $stmt
l!l&&r!l&&!r
140280
_server_error($mdb, $perr, $mask) || 'prepare failed'
l!l
140
MC/DC50%1/2
$perr or not defined $stmt
$perr not defined $stmt
MC/DC0%0/1
_server_error($mdb, $perr, $mask) || 'prepare failed'
_server_error($mdb, $perr, $mask)
Truth table66%2/3
A or not(B)
A= $perrB= not defined $stmt
ABresult
1X1
011
000
Truth table50%1/2
A
A= _server_error($mdb, $perr, $mask)
Aresult
11
00
334 280 local $@;
335 280 ▶ unless (eval { $mdb->execute($stmt, $bind, _executed_cb($mdb, $stmt, $settle, $pid, $mask)); 1 }) {
Branch: 1 branch
BranchTrueFalseTotal
unless (eval { do { $mdb->execute($stmt, $bind, _executed_cb($mdb, $stmt, $settle, $pid, $mask)); 1 } }) 7 273 280
336 7 ▶ my $died = $@ || 'execute failed';
Condition50%1/2
$@ || 'execute failed'
l!l
70
MC/DC0%0/1
$@ || 'execute failed'
$@
Truth table50%1/2
A
A= $@
Aresult
11
00
337 7 _close_and_settle($mdb, $stmt, $settle, undef, _masked($mask, $died, _handle_code($mdb, $died)));
338 }
339 280 return;
340 301 };
341 }
342  
343 280 ▶sub _executed_cb {
Subroutine _executed_cb: called CC=1 SCAR=0.0
344 280 my ($mdb, $stmt, $settle, $pid, $mask) = @_;
345 273 ▶ return sub {
Subroutine __ANON__: called CC=2 SCAR=7.0
346 273 my ($rows, $err) = @_;
347 273 ▶ return if $$ != $pid;
Branch: 1 branch
BranchTrueFalseTotal
if $$ != $pid 0 273 273
348 # Read before the close: it is the execute's error the handle holds now.
349 273 _close_and_settle($mdb, $stmt, $settle, $rows, _server_error($mdb, $err, $mask));
350 273 return;
351 280 };
352 }
353  
354 404 ▶sub _queried_cb {
Subroutine _queried_cb: called CC=1 SCAR=0.0
355 404 my ($mdb, $settle, $pid, $mask) = @_;
356 390 ▶ return sub {
Subroutine __ANON__: called CC=2 SCAR=7.1
357 390 my ($rows, $err) = @_;
358 390 ▶ return if $$ != $pid;
Branch: 1 branch
BranchTrueFalseTotal
if $$ != $pid 0 390 390
359 390 return $settle->($rows, _server_error($mdb, $err, $mask));
360 404 };
361 }
362  
363 279 ▶sub _reset_cb {
Subroutine _reset_cb: called CC=1 SCAR=0.0
364 279 my ($mdb, $settle, $mask) = @_;
365 270 ▶ return sub {
Subroutine __ANON__: called CC=2 SCAR=6.9
366 270 my ($ok, $err) = @_;
367 270 ▶ $settle->($err ? (undef, _masked($mask, $err, _handle_code($mdb, $err))) : (1, undef));
Branch: 1 branch
BranchTrueFalseTotal
$err ? : 6 264 270
368 279 };
369 }
370  
371 # The mask of one statement: a coderef text -> text with the values out, or
372 # undef without a masker. It holds a copy of the bound values that can be found
373 # in a text (defined, not a reference, four characters or more, as strings) and
374 # the statement -- never the caller's bind arrayref (ADR 0044).
375 984 ▶sub _error_mask {
Subroutine _error_mask: called CC=5 SCAR=16.2
376 984 my ($masker, $bind, $sql) = @_;
377 984 ▶ return unless $masker;
Branch: 1 branch
BranchTrueFalseTotal
unless $masker 89 895 984
378 895 ▶ my @values = map { "$_" } grep { defined && !ref && length >= 4 } @{ $bind || [] };
Condition75%6/8
defined $_ && !ref($_) && length $_ >= 4
!ll&&!rl&&r
1221410
defined $_ and not ref $_
!ll&&!rl&&r
10631
$bind || []
l!l
8950
MC/DC66%2/3
defined $_ && !ref($_) && length $_ >= 4
defined $_ not ref $_ length $_ >= 4
MC/DC0%0/1
$bind || []
$bind
Truth table75%3/4
A and not(B) && C
A= defined $_B= not ref $_C= length $_ >= 4
ABCresult
0XX0
10X0
1100
1111
Truth table50%1/2
A
A= $bind
Aresult
11
00
379 895 ▶ return sub { $masker->($_[0], \@values, $sql, $_[1]) };
Subroutine __ANON__: called CC=1 SCAR=0.0
380 }
381  
382 # An error text through the mask, with the server's error number when there is
383 # one; an object, undef and an empty text as they are.
384 92 ▶sub _masked {
Subroutine _masked: called CC=5 SCAR=16.2
385 92 my ($mask, $err, $code) = @_;
386 92 ▶ return $err unless $mask && defined $err && !ref $err && length $err;
Branch: 1 branch
BranchTrueFalseTotal
unless $mask and defined $err and not ref $err and length $err 14 78 92
Condition77%7/9
$mask and defined $err and not ref $err and length $err
!ll&&!rl&&r
14078
$mask and defined $err and not ref $err
!ll&&!rl&&r
13178
$mask and defined $err
!ll&&!rl&&r
13079
MC/DC50%2/4
$mask and defined $err and not ref $err and length $err
$mask defined $err not ref $err length $err
Truth table60%3/5
A and B and not(C) and D
A= $maskB= defined $errC= not ref $errD= length $err
ABCDresult
0XXX0
10XX0
110X0
11100
11111
387 78 return $mask->($err, $code);
388 }
389  
390  
391 209 ▶sub _handle_code {
Subroutine _handle_code: called CC=15 SCAR=27.4
392 209 my ($mdb, $text) = @_;
393 209 ▶ return unless defined $text && !ref $text && length $text;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $text and not ref $text and length $text 94 115 209
Condition83%5/6
defined $text and not ref $text and length $text
!ll&&!rl&&r
940115
defined $text and not ref $text
!ll&&!rl&&r
931115
MC/DC66%2/3
defined $text and not ref $text and length $text
defined $text not ref $text length $text
Truth table75%3/4
A and not(B) and C
A= defined $textB= not ref $textC= length $text
ABCresult
0XX0
10X0
1100
1111
394 115 ▶ return unless Scalar::Util::blessed($mdb)
Branch: 1 branch
BranchTrueFalseTotal
unless builtin::blessed($mdb) and $mdb->can("error_number") and $mdb->can("error_message") 60 55 115
Condition83%5/6
builtin::blessed($mdb) and $mdb->can("error_number") and $mdb->can("error_message")
!ll&&!rl&&r
60055
builtin::blessed($mdb) and $mdb->can("error_number")
!ll&&!rl&&r
65455
MC/DC66%2/3
builtin::blessed($mdb) and $mdb->can("error_number") and $mdb->can("error_message")
builtin::blessed($mdb) $mdb->can("error_number") $mdb->can("error_message")
Truth table75%3/4
A and B and C
A= builtin::blessed($mdb)B= $mdb->can("error_number")C= $mdb->can("error_message")
ABCresult
0XX0
10X0
1100
1111
395 && $mdb->can('error_number') && $mdb->can('error_message');
396 55 my ($number, $message) = do { local $@; eval { ($mdb->error_number, $mdb->error_message) } };
397 55 ▶ return unless defined $number && $number =~ /\A[0-9]+\z/
Branch: 1 branch
BranchTrueFalseTotal
unless defined $number and $number =~ /\A[0-9]+\z/ and $number >= 1000 && $number < 2000 || $number >= 3000 9 46 55
Condition75%9/12
defined $number and $number =~ /\A[0-9]+\z/ and $number >= 1000 && $number < 2000 || $number >= 3000
!ll&&!rl&&r
0946
defined $number and $number =~ /\A[0-9]+\z/
!ll&&!rl&&r
0055
$number >= 1000 and $number < 2000 or $number >= 3000
l!l&&r!l&&!r
4519
$number >= 1000 and $number < 2000
!ll&&!rl&&r
5545
MC/DC60%3/5
defined $number and $number =~ /\A[0-9]+\z/ and $number >= 1000 && $number < 2000 || $number >= 3000
defined $number $number =~ /\A[0-9]+\z/ $number >= 1000 $number < 2000 $number >= 3000
Truth table57%4/7
A and B and C and D or E
A= defined $numberB= $number =~ /\A[0-9]+\z/C= $number >= 1000D= $number < 2000E= $number >= 3000
ABCDEresult
0XXXX0
10XXX0
110X00
111000
1111X1
110X11
111011
398 && ($number >= 1000 && $number < 2000 || $number >= 3000);
399 46 ▶ return unless defined $message && length $message && index($text, $message) >= 0;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $message and length $message and index($text, $message) != -1 5 41 46
Condition83%5/6
defined $message and length $message and index($text, $message) != -1
!ll&&!rl&&r
3241
defined $message and length $message
!ll&&!rl&&r
3043
MC/DC66%2/3
defined $message and length $message and index($text, $message) != -1
defined $message length $message index($text, $message) != -1
Truth table75%3/4
A and B and C
A= defined $messageB= length $messageC= index($text, $message) != -1
ABCresult
0XX0
10X0
1100
1111
400 41 return $number + 0;
401 }
402  
403  
404 685 ▶sub _server_error {
Subroutine _server_error: called CC=5 SCAR=16.1
405 685 my ($mdb, $err, $mask) = @_;
406 685 ▶ return $err if ref $err or not defined $err or not length $err;
Branch: 1 branch
BranchTrueFalseTotal
if ref $err or not defined $err or not length $err 617 68 685
Condition83%5/6
ref $err or not defined $err or not length $err
l!l&&r!l&&!r
617068
ref $err or not defined $err
l!l&&r!l&&!r
161668
MC/DC66%2/3
ref $err or not defined $err or not length $err
ref $err not defined $err not length $err
Truth table75%3/4
A or not(B) or not(C)
A= ref $errB= not defined $errC= not length $err
ABCresult
1XX1
01X1
0011
0000
407 68 my $code = _handle_code($mdb, $err);
408 68 ▶ my $state = _server_sqlstate($mdb, $err)
Branch: 1 branch
BranchTrueFalseTotal
my $state = _server_sqlstate($mdb, $err) or return _masked($mask, $err, $code) 23 45 68
409 or return _masked($mask, $err, $code);
410 23 return DBIO::Exception::Server->new(message => _masked($mask, $err, $code), sqlstate => $state);
411 }
412  
413 # The SQLSTATE of the handle when $err is a refusal by the server, else undef.
414 68 ▶sub _server_sqlstate {
Subroutine _server_sqlstate: called CC=14 SCAR=27.3
415 68 my ($mdb, $err) = @_;
416 68 ▶ return unless Scalar::Util::blessed($mdb)
Branch: 1 branch
BranchTrueFalseTotal
unless builtin::blessed($mdb) and $mdb->can("sqlstate") and $mdb->can("error_number") and $mdb->can("error_message") 37 31 68
Condition66%6/9
builtin::blessed($mdb) and $mdb->can("sqlstate") and $mdb->can("error_number") and $mdb->can("error_message")
!ll&&!rl&&r
37031
builtin::blessed($mdb) and $mdb->can("sqlstate") and $mdb->can("error_number")
!ll&&!rl&&r
37031
builtin::blessed($mdb) and $mdb->can("sqlstate")
!ll&&!rl&&r
03731
MC/DC25%1/4
builtin::blessed($mdb) and $mdb->can("sqlstate") and $mdb->can("error_number") and $mdb->can("error_message")
builtin::blessed($mdb) $mdb->can("sqlstate") $mdb->can("error_number") $mdb->can("error_message")
Truth table40%2/5
A and B and C and D
A= builtin::blessed($mdb)B= $mdb->can("sqlstate")C= $mdb->can("error_number")D= $mdb->can("error_message")
ABCDresult
0XXX0
10XX0
110X0
11100
11111
417 && $mdb->can('sqlstate') && $mdb->can('error_number') && $mdb->can('error_message');
418 31 my ($state, $number, $message) = eval { ($mdb->sqlstate, $mdb->error_number, $mdb->error_message) };
419 31 ▶ return unless defined $state && $state =~ /\A[0-9A-Z]{5}\z/ && $state ne '00000';
Branch: 1 branch
BranchTrueFalseTotal
unless defined $state and $state =~ /\A[0-9A-Z]{5}\z/ and $state ne "00000" 1 30 31
Condition50%3/6
defined $state and $state =~ /\A[0-9A-Z]{5}\z/ and $state ne "00000"
!ll&&!rl&&r
0130
defined $state and $state =~ /\A[0-9A-Z]{5}\z/
!ll&&!rl&&r
0031
MC/DC33%1/3
defined $state and $state =~ /\A[0-9A-Z]{5}\z/ and $state ne "00000"
defined $state $state =~ /\A[0-9A-Z]{5}\z/ $state ne "00000"
Truth table50%2/4
A and B and C
A= defined $stateB= $state =~ /\A[0-9A-Z]{5}\z/C= $state ne "00000"
ABCresult
0XX0
10X0
1100
1111
420 30 ▶ return unless defined $number && ($number >= 1000 && $number < 2000 || $number >= 3000);
Branch: 1 branch
BranchTrueFalseTotal
unless defined $number and $number >= 1000 && $number < 2000 || $number >= 3000 6 24 30
Condition88%8/9
defined $number and $number >= 1000 && $number < 2000 || $number >= 3000
!ll&&!rl&&r
0624
$number >= 1000 and $number < 2000 or $number >= 3000
l!l&&r!l&&!r
2316
$number >= 1000 and $number < 2000
!ll&&!rl&&r
2523
MC/DC75%3/4
defined $number and $number >= 1000 && $number < 2000 || $number >= 3000
defined $number $number >= 1000 $number < 2000 $number >= 3000
Truth table66%4/6
A and B and C or D
A= defined $numberB= $number >= 1000C= $number < 2000D= $number >= 3000
ABCDresult
0XXX0
10X00
11000
111X1
10X11
11011
421 24 ▶ return unless defined $message && $message eq $err;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $message and $message eq $err 1 23 24
Condition66%2/3
defined $message and $message eq $err
!ll&&!rl&&r
0123
MC/DC50%1/2
defined $message and $message eq $err
defined $message $message eq $err
Truth table66%2/3
A and B
A= defined $messageB= $message eq $err
ABresult
0X0
100
111
422 23 return $state;
423 }
424  
425 # Close the statement, then settle with the execute's outcome. The close's own
426 # result does not change that outcome; a close that croaks settles at once.
427 280 ▶sub _close_and_settle {
Subroutine _close_and_settle: called CC=2 SCAR=6.9
428 280 my ($mdb, $stmt, $settle, $rows, $err) = @_;
429 280 my $closing;
430 {
431 280 local $@;
432 280 ▶ $closing = eval { $mdb->close_stmt($stmt, sub { $settle->($rows, $err) }); 1 };
Subroutine __ANON__: called CC=1 SCAR=0.0
433 }
434 280 ▶ $settle->($rows, $err) unless $closing;
Branch: 1 branch
BranchTrueFalseTotal
unless $closing 2 278 280
435 280 return;
436 }
437  
438 # True for a statement that begins with CALL, behind leading whitespace and
439 # comments (-- and # to the end of the line, /* ... */), in any case.
440 822 ▶sub _is_call {
Subroutine _is_call: called CC=3 SCAR=11.1
441 822 my ($sql) = @_;
442 822 ▶ return defined $sql && $sql =~ m{\A(?:\s+|--[ \t][^\n]*(?:\n|\z)|\#[^\n]*(?:\n|\z)|/\*.*?\*/)*CALL\b}is ? 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
defined $sql && $sql =~ m[\A(?:\s+|--[ \t][^\n]*(?:\n|\z)|\#[^\n]*(?:\n|\z)|/\*.*?\*/)*CALL\b]is ? : 14 808 822
Condition66%2/3
defined $sql and $sql =~ m[\A(?:\s+|--[ \t][^\n]*(?:\n|\z)|\#[^\n]*(?:\n|\z)|/\*.*?\*/)*CALL\b]is
!ll&&!rl&&r
080814
MC/DC50%1/2
defined $sql and $sql =~ m[\A(?:\s+|--[ \t][^\n]*(?:\n|\z)|\#[^\n]*(?:\n|\z)|/\*.*?\*/)*CALL\b]is
defined $sql $sql =~ m[\A(?:\s+|--[ \t][^\n]*(?:\n|\z)|\#[^\n]*(?:\n|\z)|/\*.*?\*/)*CALL\b]is
Truth table66%2/3
A and B
A= defined $sqlB= $sql =~ m[\A(?:\s+|--[ \t][^\n]*(?:\n|\z)|\#[^\n]*(?:\n|\z)|/\*.*?\*/)*CALL\b]is
ABresult
0X0
100
111
443 }
444  
445 60 1;
446  
447 __END__
« EV/Storage.pm ↑ Summary EV/Future.pm »