blib/lib/DBIO/Storage/DBI.pm

filter: Statementstmt 87.9% 1105 / 1256 Branchbran 79.0% 561 / 710 Conditioncond 68.9% 375 / 544 MC/DCmcdc 45.8% 138 / 301 Subroutinesub 84.2% 177 / 210 Podpod 88.5% 31 / 35 totaltotal 78.1% 2387 / 3056 CC 631 SCAR 27.5
CC
631
Cov
81%
_dbh_columns_info_for
156.0
insert
82.2
_run_connection_actions
33.6
CRAP 15.6
« blib/lib/DBIO/Storage/BlockRunner.pm ↑ Summary blib/lib/DBIO/Generate/Style/Vanilla.pm »
1 package DBIO::Storage::DBI;
2 # ABSTRACT: DBI storage handler
3 # -*- mode: cperl; cperl-indent-level: 2 -*-
4  
5 344 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
6 344 ▶use warnings;
Subroutine BEGIN: called CC=1 SCAR=0.0
7  
8 344 our $VERSION = '0.900007';
9  
10 344 ▶use base qw/DBIO::Storage::QueryRewrite DBIO::Storage::DBI::Capabilities DBIO::Storage::DBI::DataTypeClassifier DBIO::Storage::DBI::AccessBroker DBIO::Storage/;
Subroutine BEGIN: called CC=1 SCAR=0.0
11 344 ▶use mro 'c3';
Subroutine BEGIN: called CC=1 SCAR=0.0
12  
13 344 ▶use DBIO::Carp;
Subroutine BEGIN: called CC=1 SCAR=0.0
14 344 ▶use Scalar::Util qw/refaddr weaken reftype blessed/;
Subroutine BEGIN: called CC=1 SCAR=0.0
15 344 ▶use Context::Preserve 'preserve_context';
Subroutine BEGIN: called CC=1 SCAR=0.0
16 344 ▶use Try::Tiny;
Subroutine BEGIN: called CC=1 SCAR=0.0
17 344 ▶use Devel::GlobalDestruction;
Subroutine BEGIN: called CC=1 SCAR=0.0
18 344 ▶use DBIO::Util qw(is_plain_value is_literal_value scope_guard mask_connect_secrets mask_statement_secrets mask_statement_fingerprint mask_bound_values);
Subroutine BEGIN: called CC=1 SCAR=0.0
19 344 ▶use DBIO::Util qw(quote_sub perlstring serialize dump_value sigwarn_silencer is_windows is_dev_release old_mro help_url);
Subroutine BEGIN: called CC=1 SCAR=0.0
20 344 ▶use DBIO::Skills;
Subroutine BEGIN: called CC=1 SCAR=0.0
21 344 ▶use DBIO::Deploy::Base ();
Subroutine BEGIN: called CC=1 SCAR=0.0
22 344 ▶use DBIO::Storage::Composed;
Subroutine BEGIN: called CC=1 SCAR=0.0
23 344 ▶use DBIO::Exception::Server ();
Subroutine BEGIN: called CC=1 SCAR=0.0
24 344 ▶use namespace::clean;
Subroutine BEGIN: called CC=1 SCAR=0.0
25  
26 # default cursor class, overridable in connect_info attributes
27 344 __PACKAGE__->cursor_class('DBIO::Storage::DBI::Cursor');
28  
29 344 __PACKAGE__->mk_group_accessors('inherited' => qw/
30 sql_quote_char sql_name_sep
31 /);
32  
33 # Class-level hook to redact bind values before they are interpolated into
34 # the trace output. The default shows every value as it is, except the bind
35 # of a column with encode_column: its bind attributes carry redact => 1 and
36 # the value shows as '***'.
37 # Install a custom coderef on the storage class:
38 #
39 # __PACKAGE__->redact_bind_value(sub {
40 # my ($colname, $value, $bindattrs) = @_;
41 # return defined $colname && $colname eq 'password' ? '***' : $value;
42 # });
43 #
44 # The coderef receives the column name (or undef if no column metadata is
45 # attached to the bind slot), the raw bind value and the bind attribute hash
46 # (or undef), and must return the value to interpolate into the trace. The
47 # original bind value passed to the database is *not* modified - only the
48 # trace string is.
49 45 ▶__PACKAGE__->mk_classdata('redact_bind_value' => sub {
Subroutine __ANON__: called CC=3 SCAR=11.0
50 45 ▶ return ( ref $_[2] eq 'HASH' && $_[2]{redact} ) ? '***' : $_[1];
Branch: 1 branch
BranchTrueFalseTotal
ref $_[2] eq 'HASH' && $_[2]{'redact'} ? : 6 39 45
Condition100%3/3
ref $_[2] eq "HASH" and $_[2]{"redact"}
!ll&&!rl&&r
5346
MC/DC100%2/2
ref $_[2] eq "HASH" and $_[2]{"redact"}
ref $_[2] eq "HASH" $_[2]{"redact"}
Truth table100%3/3
A and B
A= ref $_[2] eq "HASH"B= $_[2]{"redact"}
ABresult
0X0
100
111
51 344 });
52  
53 344 __PACKAGE__->mk_group_accessors('component_class' => qw/sql_maker_class datetime_parser_type/);
54  
55 344 __PACKAGE__->sql_maker_class('DBIO::SQLMaker');
56 344 __PACKAGE__->datetime_parser_type('DateTime::Format::MySQL'); # historic default
57  
58 # Identifier quoting is ON by default (security hardening). Concrete drivers
59 # override sql_quote_char with their RDBMS-native quote; the bare base storage
60 # falls back to the ANSI SQL standard double quote so the default-on path never
61 # has to warn about a missing quote_char.
62 344 __PACKAGE__->sql_quote_char('"');
63 344 __PACKAGE__->sql_name_sep('.');
64  
65 344 __PACKAGE__->mk_group_accessors('simple' => qw/
66 _connect_info _dbio_connect_attributes _driver_determined
67 _declared_storage_class
68 _dbh _dbh_details _conn_pid _sql_maker _sql_maker_opts _dbh_autocommit
69 _perform_autoinc_retrieval _autoinc_supplied_for_op _async_mode
70 _async_context_owner_token _server_messages _parent_storage
71 /);
72  
73 # Async mode registry (ADR 0030): maps a connect-time mode name to the embedded
74 # backend class that answers the six *_async methods for an instance connected
75 # with { async => $mode }. Generic modes (e.g. 'forked', 'future_io') register
76 # on a base class and are inherited by every driver; native modes (e.g. 'ev')
77 # are registered by the concrete driver storage class, so the same logical mode
78 # name resolves to a DB-specific backend. Lookup walks the instance's MRO, so a
79 # driver registration shadows/extends the generic ones. 'immediate' is the
80 # in-process degrade mode (no event loop, no embedded backend): it maps to the
81 # immediate Future class. It is the sole permitted non-DBIO::Storage::Async
82 # target; every other lazy-loaded target must satisfy that backend contract.
83 # Core registers only 'immediate' -- 'forked'/'future_io'/'ev' come from their
84 # add-on/driver dists, never auto-wired here.
85 344 my %_async_mode_registry;
86 344 __PACKAGE__->register_async_mode( immediate => 'DBIO::Future::Immediate' );
87  
88 # the values for these accessors are picked out (and deleted) from
89 # the attribute hashref passed to connect_info. The names live once
90 # on DBIO::Storage and are consumed by both this sync path and the async strip
91 # (DBIO::Storage::Async), so the two lists can never drift.
92 #
93 # Only the *base* set can be registered here -- this runs at compile
94 # time, on this class. A driver that adds a storage option overrides
95 # _dbio_storage_option_names and registers the accessor for its own name in its
96 # own class body; _normalize_connect_info asks the live storage for the list,
97 # so the added name is routed to that accessor instead of leaking to DBI.
98 __PACKAGE__->mk_group_accessors('simple' =>
99 344 map { __PACKAGE__->_dbio_storage_option_accessor($_) }
100 __PACKAGE__->_dbio_storage_option_names
101 );
102  
103  
104 # Capability detection lives in DBIO::Storage::DBI::Capabilities (mixin).
105  
106 # Each of these methods need _determine_driver called before itself
107 # in order to function reliably. We also need to separate accessors
108 # from plain old method calls, since an accessor called as a setter
109 # does *not* need the driver determination loop fired (and in fact
110 # can produce hard to find bugs, like e.g. losing on_connect_*
111 # semantics on fresh connections)
112 #
113 # The construct below is simply a parameterized around()
114 344 my $storage_accessor_idx = { map { $_ => 1 } qw(
115 sqlt_type
116 datetime_parser_type
117  
118 sql_maker
119 cursor_class
120 )};
121 344 for my $meth (keys %$storage_accessor_idx, qw(
122 deployment_statements
123  
124 build_datetime_parser
125 datetime_date_carries_time
126  
127 txn_begin
128  
129 insert
130 update
131 delete
132 select
133 select_single
134  
135 _insert_bulk
136  
137 with_deferred_fk_checks
138  
139 get_use_dbms_capability
140 get_dbms_capability
141  
142 _exists_value_sql
143 _set_operation_keyword
144  
145 _random_function
146 _explain_query
147  
148 _server_info
149 _get_server_version
150 )) {
151  
152 7912 ▶ my $orig = __PACKAGE__->can ($meth)
Branch: 1 branch
BranchTrueFalseTotal
my $orig = __PACKAGE__->can($meth) or die "$meth is not a ::Storage::DBI method!" 7912 0 7912
153 or die "$meth is not a ::Storage::DBI method!";
154  
155 7912 ▶ my $is_getter = $storage_accessor_idx->{$meth} ? 0 : 1;
Branch: 1 branch
BranchTrueFalseTotal
$storage_accessor_idx->{$meth} ? : 1376 6536 7912
156  
157 7912 quote_sub
158 __PACKAGE__ ."::$meth", sprintf( <<'EOC', $is_getter, perlstring($meth), perlstring(__PACKAGE__) ), { '$orig' => \$orig };
159  
160 if (
161 # only fire when invoked on an instance, a valid class-based invocation
162 # would e.g. be setting a default for an inherited accessor
163 ref $_[0]
164 and
165 ! $_[0]->{_driver_determined}
166 and
167 ! $_[0]->{_in_determine_driver}
168 and
169 # if this is a known *setter* - just set it, no need to connect
170 # and determine the driver
171 ( %1$s or @_ <= 1 )
172 and
173 # Only try to determine stuff if we have *something* that either is or can
174 # provide a DSN: a storage that never got connect info has neither
175 $_[0]->_dbi_connect_info->[0]
176 ) {
177 # Reached directly -- no override sits above this method in the class
178 # of the storage -- the determination may move the storage to a class
179 # that has one, and that class answers the call. Reached through an
180 # override's next::method (a declared driver storage, ADR 0059), the
181 # override is already running: re-dispatching would run it a second
182 # time and hand its result to the first run (karr k345). The call goes
183 # on to the base method instead.
184 my $direct = $_[0]->can(%2$s) == %3$s->can(%2$s);
185  
186 $_[0]->_determine_driver;
187  
188 goto $_[0]->can(%2$s) if $direct;
189 }
190  
191 goto $orig;
192 EOC
193 }
194  
195  
196 3722 ▶sub new {
Subroutine new: called CC=1 SCAR=0.0
Pod documented
197 3722 my $new = shift->next::method(@_);
198  
199 3722 $new->_sql_maker_opts({});
200 3722 $new->_dbh_details({});
201 3722 $new->{_in_do_block} = 0;
202  
203 # read below to see what this does
204 3722 $new->_arm_global_destructor;
205  
206 3722 $new;
207 }
208  
209 # This is hack to work around perl shooting stuff in random
210 # order on exit(). If we do not walk the remaining storage
211 # objects in an END block, there is a *small but real* chance
212 # of a fork()ed child to kill the parent's shared DBI handle,
213 # *before perl reaches the DESTROY in this package*
214 # Yes, it is ugly and effective.
215 # Additionally this registry is used by the CLONE method to
216 # make sure no handles are shared between threads
217 {
218 344 my %seek_and_destroy;
219  
220 3722 ▶ sub _arm_global_destructor {
Subroutine _arm_global_destructor: called CC=3 SCAR=11.0
221  
222 # quick "garbage collection" pass - prevents the registry
223 # from slowly growing with a bunch of undef-valued keys
224 defined $seek_and_destroy{$_} or delete $seek_and_destroy{$_}
225 3722 ▶ for keys %seek_and_destroy;
Branch: 1 branch
BranchTrueFalseTotal
defined $seek_and_destroy{$_} or delete $seek_and_destroy{$_} 9792 2817 12609
226  
227 weaken (
228 3722 $seek_and_destroy{ refaddr($_[0]) } = $_[0]
229 );
230 }
231  
232 344 ▶ END {
Subroutine END: called CC=2 SCAR=6.9
233 344 local $?; # just in case the DBI destructor changes it somehow
234  
235 # destroy just the object if not native to this process
236 344 $_->_verify_pid for (grep
237 905 { defined $_ }
238 values %seek_and_destroy
239 );
240 }
241  
242 0 ▶ sub CLONE {
Subroutine CLONE: not called CC=2 SCAR=17.9
243 # As per DBI's recommendation, DBIO disconnects all handles as
244 # soon as possible (DBIO will reconnect only on demand from within
245 # the thread)
246 0 my @instances = grep { defined $_ } values %seek_and_destroy;
247 0 %seek_and_destroy = ();
248  
249 0 for (@instances) {
250 0 $_->_dbh(undef);
251  
252 0 $_->transaction_depth(0);
253 0 $_->savepoints([]);
254  
255 # properly renumber existing refs
256 0 $_->_arm_global_destructor
257 }
258 }
259 }
260  
261 344 ▶sub DESTROY {
Subroutine DESTROY: called CC=6 SCAR=18.6
262 3382 my $self = $_[0];
263  
264 # A freed schema closes the connections of its embedded async storage. Only
265 # the process that owns them does, and not in global destruction, where the
266 # pool follows its own rules (karr k254, k234). The storage is torn down
267 # only if one was built; DESTROY never builds it.
268 3382 ▶ if ( $self->{_async_storage_obj}
Branch: 1 branch
BranchTrueFalseTotal
if ($self->{"_async_storage_obj"} and not &in_global_destruction() and !defined($self->_conn_pid) || $self->_conn_pid == $$) 305 3077 3382
Condition55%5/9
$self->{"_async_storage_obj"} and not &in_global_destruction() and !defined($self->_conn_pid) || $self->_conn_pid == $$
!ll&&!rl&&r
30770305
$self->{"_async_storage_obj"} and not &in_global_destruction()
!ll&&!rl&&r
30770305
not defined $self->_conn_pid or $self->_conn_pid == $$
l!l&&r!l&&!r
30500
MC/DC25%1/4
$self->{"_async_storage_obj"} and not &in_global_destruction() and !defined($self->_conn_pid) || $self->_conn_pid == $$
$self->{"_async_storage_obj"} not &in_global_destruction() not defined $self->_conn_pid $self->_conn_pid == $$
Truth table40%2/5
A and not(B) and not(C) or D
A= $self->{"_async_storage_obj"}B= not &in_global_destruction()C= not defined $self->_conn_pidD= $self->_conn_pid == $$
ABCDresult
0XXX0
10XX0
11000
111X1
11011
269 and !in_global_destruction
270 and ( !defined $self->_conn_pid or $self->_conn_pid == $$ ) ) {
271 305 local ($@, $?);
272 305 ▶ try {
Subroutine __ANON__: called CC=1 SCAR=0.0
273 305 $self->_reset_async_context_owner_token;
274 305 my $async = delete $self->{_async_storage_obj};
275 305 $async->disconnect;
276 }
277 0 ▶ catch {
Subroutine __ANON__: not called CC=1 SCAR=6.9
278 0 warn "Async storage teardown failed in DESTROY: $_";
279 305 };
280 }
281  
282 3382 ▶ $_[0]->_verify_pid unless is_windows();
Branch: 1 branch
BranchTrueFalseTotal
unless &is_windows() 3382 0 3382
283 # some databases spew warnings on implicit disconnect
284 3382 ▶ local $SIG{__WARN__} = sub {};
Subroutine __ANON__: not called CC=1 SCAR=0.0
285 3382 $_[0]->_dbh(undef);
286  
287 # this op is necessary, since the very last perl runtime statement
288 # triggers a global destruction shootout, and the $SIG localization
289 # may very well be destroyed before perl actually gets to do the
290 # $dbh undef
291 3382 1;
292 }
293  
294 # handle pid changes correctly - do not destroy parent's connection
295 4158 ▶sub _verify_pid {
Subroutine _verify_pid: called CC=4 SCAR=13.9
296  
297 4158 my $pid = $_[0]->_conn_pid;
298  
299 4158 ▶ if( defined $pid and $pid != $$ and my $dbh = $_[0]->_dbh ) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $pid and $pid != $$ and my $dbh = $_[0]->_dbh) 1 4157 4158
Condition83%5/6
defined $pid and $pid != $$ and my $dbh = $_[0]->_dbh
!ll&&!rl&&r
415701
defined $pid and $pid != $$
!ll&&!rl&&r
38812761
MC/DC66%2/3
defined $pid and $pid != $$ and my $dbh = $_[0]->_dbh
defined $pid $pid != $$ my $dbh = $_[0]->_dbh
Truth table75%3/4
A and B and C
A= defined $pidB= $pid != $$C= my $dbh = $_[0]->_dbh
ABCresult
0XX0
10X0
1100
1111
300 1 $dbh->{InactiveDestroy} = 1;
301 1 $_[0]->_dbh(undef);
302 1 $_[0]->transaction_depth(0);
303 1 $_[0]->savepoints([]);
304 }
305  
306 4158 return;
307 }
308  
309  
310 2559 ▶sub connect_info {
Subroutine connect_info: called CC=14 SCAR=26.5
Pod documented
311 2559 my ($self, $info) = @_;
312  
313 2559 ▶ return $self->_connect_info if !$info;
Branch: 1 branch
BranchTrueFalseTotal
unless $info 3 2556 2559
314  
315 2556 $self->_connect_info($info); # copy for _connect_info
316 2556 delete $self->{_connect_info_before_broker};
317  
318 # The embedded async backend was built from the connect info before. It is
319 # let go of here, before anything of the new connect info is read, and
320 # every context tied to its generation is invalidated with it: reading can
321 # throw -- a broker, its answer -- and a call that throws must not leave a
322 # backend that goes on connecting as before, through the broker this call
323 # replaced (karr k293). The next use resolves a backend anew.
324 2556 $self->_reset_async_context_owner_token;
325 2556 delete $self->{_async_storage_obj};
326  
327 2556 ▶ if ($self->_is_access_broker_connect_info($info)) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->_is_access_broker_connect_info($info)) { } 478 2078 2556
328 478 my $beside = $self->_access_broker_call_info($info);
329 476 $self->set_access_broker($info->[0], 'write');
330 476 $info = $self->_normalized_access_broker_connect_info($self->access_broker_mode);
331  
332 # ADR 0030 addendum (karr k240, k243): the connect call's own settings
333 # beside the broker join its answer; one given in both has to agree.
334 364 ▶ $info = $self->_merge_access_broker_call_info($info, $beside) if $beside;
Branch: 1 branch
BranchTrueFalseTotal
if $beside 120 244 364
335 }
336 else {
337 2078 $self->clear_access_broker;
338 2078 ▶ if (ref $info eq 'ARRAY') {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $info eq "ARRAY") 2078 0 2078
339 2078 my $given = $info;
340 2078 $info = $self->_normalize_connect_info($given);
341 2062 $self->_assert_static_connect_info_has_dsn($info, $given);
342 2015 $self->_assert_static_connect_attributes_known($info);
343 }
344 }
345  
346 2357 my ($args, $attrs) = $self->_dbi_args_from_info($info);
347 2357 my %attrs = %$attrs;
348  
349 2357 ▶ if (keys %attrs and ref $args->[0] ne 'CODE') {
Branch: 1 branch
BranchTrueFalseTotal
if (keys %attrs and ref $args->[0] ne "CODE") 766 1591 2357
Condition66%2/3
keys %attrs and ref $args->[0] ne "CODE"
!ll&&!rl&&r
01591766
MC/DC50%1/2
keys %attrs and ref $args->[0] ne "CODE"
keys %attrs ref $args->[0] ne "CODE"
Truth table66%2/3
A and B
A= keys %attrsB= ref $args->[0] ne "CODE"
ABresult
0X0
100
111
350 carp_unique (
351 'You provided explicit AutoCommit => 0 in your connection_info. '
352 . 'This is almost universally a bad idea (see the footnotes of '
353 . 'DBIO::Storage::DBI for more info). If you still want to '
354 . 'do this you can set $ENV{DBIO_UNSAFE_AUTOCOMMIT_OK} to disable '
355 . 'this warning.'
356 766 ▶ ) if ! $attrs{AutoCommit} and ! $ENV{DBIO_UNSAFE_AUTOCOMMIT_OK};
Branch: 1 branch
BranchTrueFalseTotal
unless $attrs{"AutoCommit"} or $ENV{"DBIO_UNSAFE_AUTOCOMMIT_OK"} 0 766 766
Condition33%1/3
$attrs{"AutoCommit"} or $ENV{"DBIO_UNSAFE_AUTOCOMMIT_OK"}
l!l&&r!l&&!r
76600
MC/DC0%0/2
$attrs{"AutoCommit"} or $ENV{"DBIO_UNSAFE_AUTOCOMMIT_OK"}
$attrs{"AutoCommit"} $ENV{"DBIO_UNSAFE_AUTOCOMMIT_OK"}
Truth table33%1/3
A or B
A= $attrs{"AutoCommit"}B= $ENV{"DBIO_UNSAFE_AUTOCOMMIT_OK"}
ABresult
1X1
011
000
357 }
358  
359 # this is the authoritative "always an arrayref" thing fed to DBI->connect
360 # OR a single-element coderef-based $dbh factory. With a broker attached
361 # nothing of its answer is kept (karr k266): every connection asks the
362 # broker again, and _dbi_connect_info derives the answer when it is read.
363 2357 ▶ $self->_dbi_connect_info($self->access_broker ? undef : $args);
Branch: 1 branch
BranchTrueFalseTotal
$self->access_broker ? : 361 1996 2357
364  
365 # ADR 0050: connect_info() is a full reconfiguration, not a merge -- reset
366 # every storage option to its default BEFORE applying this call's options,
367 # so an option not named here does not go on leaking a prior value (the
368 # DBIx::Class fossil: a truthiness-picker that only ever set options that
369 # were present, never cleared ones that were absent). Symmetric with the
370 # _sql_maker/_sql_maker_opts wipe below. cursor_class is the one exception:
371 # it resets to its class default, not undef, since a component_class
372 # accessor with no value breaks cursor creation.
373 2357 for my $storage_opt ($self->_dbio_storage_option_names) {
374 18859 my $accessor = $self->_dbio_storage_option_accessor($storage_opt);
375 18859 $self->$accessor(undef);
376 }
377 2357 $self->cursor_class(ref($self)->cursor_class);
378  
379 # extract the individual storage options
380 2357 for my $storage_opt (keys %{ $info->{storage_options} }) {
381 258 my $value = $info->{storage_options}{$storage_opt};
382  
383 258 ▶ $self->_assert_connection_schema_name($value) if $storage_opt eq 'schema';
Branch: 1 branch
BranchTrueFalseTotal
if $storage_opt eq "schema" 27 231 258
384  
385 250 my $accessor = $self->_dbio_storage_option_accessor($storage_opt);
386 250 $self->$accessor($value);
387 }
388  
389 # ADR 0030: the async execution mode is chosen per connection via
390 # { async => 'MODE' } in the connect attributes. Absent => sync (the
391 # *_async methods croak). The resolved-backend cache was reset on the way
392 # in, so a fresh connect_info re-resolves the mode.
393 2349 $self->_async_mode($info->{async_mode});
394  
395 # Extract the individual sqlmaker options
396 #
397 # Kill sql_maker/_sql_maker_opts, so we get a fresh one with only
398 # the new set of options
399 2349 $self->_sql_maker(undef);
400 2349 $self->_sql_maker_opts({});
401  
402 2349 for my $sql_maker_opt (keys %{ $info->{sql_maker_options} }) {
403 79 my $value = $info->{sql_maker_options}{$sql_maker_opt};
404  
405 79 $self->_sql_maker_opts->{$sql_maker_opt} = $value;
406 }
407  
408 # FIXME - dirty:
409 # save attributes in a separate accessor so they are always
410 # introspectable, even in case of a CODE $dbhmaker
411 2349 $self->_dbio_connect_attributes (\%attrs);
412  
413 2349 return $self->_connect_info;
414 }
415  
416 # The detach of a DBI storage is DBIO::Storage::DBI::AccessBroker's: it takes
417 # the embedded async backend along (karr k293); the storage itself holds
418 # nothing of the broker's answer (karr k266). It is named here as well because
419 # that mixin stands BEHIND DBIO::Storage in the method resolution order of a
420 # driver storage class that does not declare c3 -- the first base,
421 # DBIO::Storage::QueryRewrite, inherits DBIO::Storage, and depth-first that
422 # comes before the other bases. Such a class (DBIO::PostgreSQL::Storage,
423 # DBIO::MySQL::Storage) found the bare DBIO::Storage::clear_access_broker
424 # first, and the mixin's never ran: the backend stayed attached. This class
425 # comes first in either order.
426 2098 ▶sub clear_access_broker {
Subroutine clear_access_broker: called CC=1 SCAR=0.0
Pod documented
427 2098 my $self = shift;
428 2098 return $self->DBIO::Storage::DBI::AccessBroker::clear_access_broker(@_);
429 }
430  
431 # Same shadowing, same reason: the attach reaches the embedded async backend
432 # built before it (karr k331).
433 521 ▶sub set_access_broker {
Subroutine set_access_broker: called CC=1 SCAR=0.0
Pod documented
434 521 my $self = shift;
435 521 return $self->DBIO::Storage::DBI::AccessBroker::set_access_broker(@_);
436 }
437  
438 # Static connect info (no broker) carries its DSN (karr k306): the DSN names
439 # the driver.
440 # $info is the normalised form, so a DSN built from a dbname key counts;
441 # $given is what the caller passed, for the shape the message names -- never a
442 # value of it. The code reference forms open the connection themselves and
443 # need no DSN. A broker's answer has its own refusal
444 # (_normalized_access_broker_connect_info).
445 2062 ▶sub _assert_static_connect_info_has_dsn {
Subroutine _assert_static_connect_info_has_dsn: called CC=11 SCAR=24.0
446 2062 my ($self, $info, $given) = @_;
447  
448 2062 my $dsn = $info->{arguments}[0];
449 2062 ▶ return if ref $dsn eq 'CODE';
Branch: 1 branch
BranchTrueFalseTotal
if ref $dsn eq "CODE" 1574 488 2062
450 488 ▶ return if defined $dsn && length $dsn;
Branch: 1 branch
BranchTrueFalseTotal
if defined $dsn and length $dsn 441 47 488
Condition100%3/3
defined $dsn and length $dsn
!ll&&!rl&&r
3512441
MC/DC100%2/2
defined $dsn and length $dsn
defined $dsn length $dsn
Truth table100%3/3
A and B
A= defined $dsnB= length $dsn
ABresult
0X0
100
111
451  
452 47 ▶ my $hash = ref $given->[0] eq 'HASH' ? $given->[0] : undef;
Branch: 1 branch
BranchTrueFalseTotal
ref $given->[0] eq 'HASH' ? : 26 21 47
453 my $shape = !@$given ? 'no arguments'
454 : $hash && !exists $hash->{dsn} && !exists $hash->{dbname}
455 47 ▶ ? 'a hash with neither a dsn nor a dbname key'
Branch: 4 branches
BranchTrueFalseTotal
!@$given ? : 6 41 47
$hash && !exists $hash->{'dsn'} && !exists $hash->{'dbname'} ? : 10 31 41
$hash ? : 16 15 31
defined $dsn ? : 12 19 31
Condition83%5/6
$hash and not exists $hash->{"dsn"} and not exists $hash->{"dbname"}
!ll&&!rl&&r
31010
$hash and not exists $hash->{"dsn"}
!ll&&!rl&&r
151610
MC/DC66%2/3
$hash and not exists $hash->{"dsn"} and not exists $hash->{"dbname"}
$hash not exists $hash->{"dsn"} not exists $hash->{"dbname"}
Truth table75%3/4
A and not(B) and not(C)
A= $hashB= not exists $hash->{"dsn"}C= not exists $hash->{"dbname"}
ABCresult
0XX0
10X0
1100
1111
456 : ($hash ? 'a hash' : 'the DBI form') . ' with '
457 . (defined $dsn ? 'an empty' : 'an undefined') . ' DSN';
458  
459 47 $self->throw_exception(
460 "Connect info without a DSN ($shape). A DBI storage connects to the DSN "
461 . 'it is given, never to the one in $ENV{DBI_DSN}: the DSN names the '
462 . 'driver. Supply a dsn, or a dbname in the hash form; a code reference '
463 . '(dbh_maker) or an AccessBroker needs none.'
464 );
465 }
466  
467 # Static connect info (no broker) is fully known here, so an attribute that is
468 # neither a DBIO option (already pulled out by _normalize_connect_info) nor a
469 # DBI attribute by its name is refused rather than handed to DBI->connect to be
470 # dropped silently (karr k327). sslmode is let through by name (karr k306).
471 # Without a DSN to judge by (a dbh_maker / coderef) nothing is checked: the
472 # code opens the connection and no attribute is applied either way.
473 2015 ▶sub _assert_static_connect_attributes_known {
Subroutine _assert_static_connect_attributes_known: called CC=4 SCAR=13.9
474 2015 my ($self, $info) = @_;
475  
476 2015 my $dsn = $info->{arguments}[0];
477 2015 ▶ return if ref $dsn eq 'CODE';
Branch: 1 branch
BranchTrueFalseTotal
if ref $dsn eq "CODE" 1574 441 2015
478  
479 # Judged by the async mode of THIS connect info -- which names are async
480 # options depends on it (karr core k397) -- not by the mode the storage held
481 # before; connect_info sets the new one only after this check.
482 441 local $self->{_async_mode} = $info->{async_mode};
483  
484 31 my @unknown = grep { $_ ne 'sslmode' }
485 441 $self->_access_broker_unapplied_parameters($info->{attributes}, $dsn);
486 441 ▶ return unless @unknown;
Branch: 1 branch
BranchTrueFalseTotal
unless @unknown 422 19 441
487  
488 $self->throw_exception(
489 19 ▶ 'Unknown connect attribute(s) ' . join(', ', map { "'$_'" } @unknown)
Branch: 1 branch
BranchTrueFalseTotal
@unknown > 1 ? : 4 15 19
490 . ' in connect info: neither a DBIO connection option nor a DBI attribute '
491 . '(uppercase first letter, private_, dbi_, dbd_, or the prefix of the DBD '
492 . 'the DSN names), so DBI->connect would silently ignore '
493 . (@unknown > 1 ? 'them' : 'it') . '. A parameter of the database client '
494 . 'belongs in the DSN.'
495 . $self->_driver_switch_hint(@unknown)
496 );
497 }
498  
499 # The sentence a refusal gets when driver_strict or driver_warnings stand among
500 # the refused keys: they are accessors of the schema, never connect attributes.
501 # Empty otherwise; no value goes into it.
502 96 ▶sub _driver_switch_hint {
Subroutine _driver_switch_hint: called CC=5 SCAR=16.1
503 96 my ($self, @names) = @_;
504  
505 96 ▶ my @switches = grep { $_ eq 'driver_strict' or $_ eq 'driver_warnings' } @names
Branch: 1 branch
BranchTrueFalseTotal
my(@switches) = grep({$_ eq "driver_strict" or $_ eq "driver_warnings";} @names) or return "" 4 92 96
Condition100%3/3
$_ eq 'driver_strict' || $_ eq 'driver_warnings'
l!l&&r!l&&!r
32128
MC/DC100%2/2
$_ eq 'driver_strict' || $_ eq 'driver_warnings'
$_ eq 'driver_strict' $_ eq 'driver_warnings'
Truth table100%3/3
A || B
A= $_ eq 'driver_strict'B= $_ eq 'driver_warnings'
ABresult
1X1
011
000
506 or return '';
507  
508 return ' ' . join(' and ', @switches)
509 . (@switches > 1
510 ? ' are schema accessors, not connect attributes: set them on the '
511 : ' is a schema accessor, not a connect attribute: set it on the ')
512 . 'schema class or a connected schema, e.g. '
513 4 ▶ . join(' and ', map { '$schema->' . $_ . ($_ eq 'driver_strict' ? '(1)' : '(0)') } @switches)
Branch: 2 branches
BranchTrueFalseTotal
@switches > 1 ? : 1 3 4
$_ eq 'driver_strict' ? : 3 2 5
514 . '.';
515 }
516  
517 # The connect info the storage holds, for the stack trace of an exception to
518 # mask (karr k311): what connect_info stored, and nothing else. It never asks
519 # a broker -- a storage with one attached holds no answer of it (karr k266), so
520 # there is none -- and never connects.
521 1295 ▶sub _held_connect_info {
Subroutine _held_connect_info: called CC=3 SCAR=11.0
522 1295 my $self = shift;
523  
524 1295 ▶ return undef if $self->access_broker;
Branch: 1 branch
BranchTrueFalseTotal
if $self->access_broker 11 1284 1295
525  
526 1284 my $info = $self->{_dbi_connect_info};
527 1284 ▶ return ref $info eq 'ARRAY' ? $info : undef;
Branch: 1 branch
BranchTrueFalseTotal
ref $info eq 'ARRAY' ? : 422 862 1284
528 }
529  
530 3227 ▶sub _dbi_connect_info {
Subroutine _dbi_connect_info: called CC=4 SCAR=13.9
531 3227 my $self = shift;
532  
533 3227 ▶ return $self->{_dbi_connect_info} = $_[0]
Branch: 1 branch
BranchTrueFalseTotal
if @_ 2357 870 3227
534 if @_;
535  
536 # With a broker attached the storage holds nothing of its answer (karr
537 # k266): what is read is the answer of this moment, derived, not kept.
538 870 ▶ return ($self->_access_broker_dbi_args($self->access_broker_mode))[0]
Branch: 1 branch
BranchTrueFalseTotal
if $self->access_broker 113 757 870
539 if $self->access_broker;
540  
541 # What connect_info stored, and nothing in its place: a storage without a
542 # DSN has nothing to connect from, whatever $ENV{DBI_DSN} names (karr k306)
543 757 ▶ return $self->{_dbi_connect_info} || [];
Condition100%2/2
$self->{'_dbi_connect_info'} || []
l!l
68275
MC/DC100%1/1
$self->{'_dbi_connect_info'} || []
$self->{'_dbi_connect_info'}
Truth table100%2/2
A
A= $self->{'_dbi_connect_info'}
Aresult
11
00
544 }
545  
546 # A normalised connect info as the arguments of DBI->connect and the full
547 # attribute set (_dbio_connect_attributes): the one place both are built, for
548 # connect_info, for every connection and for the read of _dbi_connect_info of
549 # a storage with a broker.
550 2711 ▶sub _dbi_args_from_info {
Subroutine _dbi_args_from_info: called CC=5 SCAR=16.1
551 2711 my ($self, $info) = @_;
552  
553 my %attrs = (
554 2711 ▶ %{ $self->_default_dbi_connect_attributes || {} },
Condition50%1/2
$self->_default_dbi_connect_attributes || {}
l!l
27110
MC/DC0%0/1
$self->_default_dbi_connect_attributes || {}
$self->_default_dbi_connect_attributes
Truth table50%1/2
A
A= $self->_default_dbi_connect_attributes
Aresult
11
00
555 2711 ▶ %{ $info->{attributes} || {} },
Condition100%2/2
$info->{'attributes'} || {}
l!l
3512360
MC/DC100%1/1
$info->{'attributes'} || {}
$info->{'attributes'}
Truth table100%2/2
A
A= $info->{'attributes'}
Aresult
11
00
556 );
557  
558 2711 my @args = @{ $info->{arguments} };
559  
560 # _dbio_connect_attributes keeps the full set (including DBIO-private
561 # keys like ignore_version) for introspection by upper layers. The
562 # arguments must only contain attrs that DBI/DBD understands: ignore_version
563 # is consumed by the DeploymentHandler version-storage component
564 # (DBIO::DeploymentHandler::VersionStorage::Standard::Component), not by
565 # the DBD.
566 2711 my %dbi_attrs = %attrs;
567 2711 delete @dbi_attrs{qw( ignore_version )};
568  
569 # An error text carries no bind value (ADR 0075): DBI appends the values
570 # itself when ShowErrorStatement is on, so it is off whatever connect_info
571 # says; _dbi_handle_error writes the statement and the number of binds.
572 2711 $attrs{ShowErrorStatement} = $dbi_attrs{ShowErrorStatement} = 0;
573  
574 2711 ▶ push @args, \%dbi_attrs if keys %dbi_attrs and ref $args[0] ne 'CODE';
Branch: 1 branch
BranchTrueFalseTotal
if keys %dbi_attrs and ref $args[0] ne "CODE" 1113 1598 2711
Condition66%2/3
keys %dbi_attrs and ref $args[0] ne "CODE"
!ll&&!rl&&r
015981113
MC/DC50%1/2
keys %dbi_attrs and ref $args[0] ne "CODE"
keys %dbi_attrs ref $args[0] ne "CODE"
Truth table66%2/3
A and B
A= keys %dbi_attrsB= ref $args[0] ne "CODE"
ABresult
0X0
100
111
575  
576 2711 return (\@args, \%attrs);
577 }
578  
579  
580 3328 ▶sub _normalize_connect_info {
Subroutine _normalize_connect_info: called CC=21 SCAR=30.4
581 3328 my ($self, $info_arg) = @_;
582 3328 my %info;
583  
584 3328 my @args = @$info_arg; # take a shallow copy for further mutilation
585  
586 # combine/pre-parse arguments depending on invocation style
587  
588 3328 my %attrs;
589 3328 ▶ if (ref $args[0] eq 'CODE') { # coderef with optional \%extra_attributes
Branch: 2 branches
BranchTrueFalseTotal
if (ref $args[0] eq 'CODE') { } 1567 1761 3328
elsif (ref $args[0] eq 'HASH') { } 792 969 1761
590 1567 ▶ %attrs = %{ $args[1] || {} };
Condition100%2/2
$args[1] || {}
l!l
241543
MC/DC100%1/1
$args[1] || {}
$args[1]
Truth table100%2/2
A
A= $args[1]
Aresult
11
00
591 1567 @args = $args[0];
592 }
593 elsif (ref $args[0] eq 'HASH') { # single hashref (i.e. Catalyst config)
594 792 %attrs = %{$args[0]};
595 792 @args = ();
596 792 ▶ if (my $code = delete $attrs{dbh_maker}) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $code = delete $attrs{'dbh_maker'}) { } 42 750 792
597 42 @args = $code;
598  
599 42 my @ignored = grep { delete $attrs{$_} } (qw/dsn user password/);
600 42 ▶ if (@ignored) {
Branch: 1 branch
BranchTrueFalseTotal
if (@ignored) 1 41 42
601 carp sprintf (
602 'Attribute(s) %s in connect_info were ignored, as they can not be applied '
603 . "to the result of 'dbh_maker'",
604  
605 1 join (', ', map { "'$_'" } (@ignored) ),
606 );
607 }
608 }
609 else {
610 # A hash of connection parameters without a dsn (e.g. from a
611 # hashref-shaped AccessBroker such as DBIO::AccessBroker::Static):
612 # build the dsn for this storage's driver, unless dbname already is one.
613 750 ▶ if (!exists $attrs{dsn} && exists $attrs{dbname}) {
Branch: 2 branches
BranchTrueFalseTotal
if (not exists $attrs{'dsn'} and exists $attrs{'dbname'}) { } 145 605 750
elsif (not exists $attrs{'dsn'} and my(@parts) = grep({exists $attrs{$_};} 'host', 'port')) { } 12 901 913
Condition100%3/3
not exists $attrs{"dsn"} and exists $attrs{"dbname"}
!ll&&!rl&&r
308297145
MC/DC100%2/2
not exists $attrs{"dsn"} and exists $attrs{"dbname"}
not exists $attrs{"dsn"} exists $attrs{"dbname"}
Truth table100%3/3
not(A) and B
A= not exists $attrs{"dsn"}B= exists $attrs{"dbname"}
ABresult
0X0
100
111
614 145 $attrs{dsn} = $self->_dsn_from_connect_params(\%attrs);
615 }
616 # host and port without either name a server and no database: there is
617 # no DSN to build them into, and they are no DBI attributes (karr k267)
618 ▶ elsif (!exists $attrs{dsn}
Condition100%3/3
not exists $attrs{"dsn"} and my(@parts) = grep({exists $attrs{$_};} "host", "port")
!ll&&!rl&&r
30828512
MC/DC100%2/2
not exists $attrs{"dsn"} and my(@parts) = grep({exists $attrs{$_};} "host", "port")
not exists $attrs{"dsn"} my(@parts) = grep({exists $attrs{$_};} "host", "port")
Truth table100%3/3
not(A) and B
A= not exists $attrs{"dsn"}B= my(@parts) = grep({exists $attrs{$_};} "host", "port")
ABresult
0X0
100
111
619 594 and my @parts = grep { exists $attrs{$_} } qw(host port)
620 ) {
621 $self->throw_exception(
622 12 'Connect info gives ' . join(' and ', map { "'$_'" } @parts)
623 . ' but neither a dsn nor a dbname: there is no DSN to connect to, '
624 . 'and without one a host or port is not passed on as a DBI '
625 . 'attribute. Supply a dsn, or a dbname.'
626 );
627 }
628 723 @args = delete @attrs{qw/dsn user password/};
629 }
630 }
631 else { # otherwise assume dsn/user/password + \%attrs + \%extra_attrs
632 %attrs = (
633 969 ▶ % { $args[3] || {} },
Condition100%2/2
$args[3] || {}
l!l
699270
MC/DC100%1/1
$args[3] || {}
$args[3]
Truth table100%2/2
A
A= $args[3]
Aresult
11
00
634 969 ▶ % { $args[4] || {} },
Condition100%2/2
$args[4] || {}
l!l
5964
MC/DC100%1/1
$args[4] || {}
$args[4]
Truth table100%2/2
A
A= $args[4]
Aresult
11
00
635 );
636 969 @args = @args[0,1,2];
637 }
638  
639 # A user or password not given is the empty string: DBI reads $ENV{DBI_USER}
640 # and $ENV{DBI_PASS} for an undef, and no environment variable stands in for
641 # a credential (karr k392, like the DSN: k306, k340).
642 3301 ▶ if (ref $args[0] ne 'CODE' and @args) {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $args[0] ne "CODE" and @args) 1692 1609 3301
Condition66%2/3
ref $args[0] ne "CODE" and @args
!ll&&!rl&&r
160901692
MC/DC50%1/2
ref $args[0] ne "CODE" and @args
ref $args[0] ne "CODE" @args
Truth table66%2/3
A and B
A= ref $args[0] ne "CODE"B= @args
ABresult
0X0
100
111
643 1692 ▶ $args[$_] //= '' for 1, 2;
Condition100%2/2
$args[$_] //= ""
l!l
2630754
MC/DC100%1/1
$args[$_] //= ""
$args[$_]
Truth table100%2/2
A
A= $args[$_]
Aresult
11
00
644 }
645  
646 3301 $info{arguments} = \@args;
647  
648 # Ask the live storage, not a compile-time snapshot of the base
649 # class, so a driver that declares its own storage option gets it routed to
650 # the storage instead of leaking into DBI->connect. Symmetric to the
651 # sql_maker split below and to DBIO::Storage::Async::connect_info, which both
652 # already read their name list off $self.
653 # cursor_class is appended instead of living in the list because the list
654 # doubles as the 'simple' accessor registration above, and cursor_class
655 # carries a component_class accessor of its own (DBIO::Storage).
656 3301 my @storage_opts = grep exists $attrs{$_},
657 $self->_dbio_storage_option_names, 'cursor_class';
658  
659 218 @{ $info{storage_options} }{@storage_opts} =
660 3301 ▶ delete @attrs{@storage_opts} if @storage_opts;
Branch: 1 branch
BranchTrueFalseTotal
if @storage_opts 218 3083 3301
661  
662 # ADR 0030: the async mode is a DBIO-private connect attribute, not a DBI one.
663 # Pull it out of %attrs (so it never reaches DBI->connect) and surface it
664 # separately for connect_info to set on the instance.
665 $info{async_mode} = delete $attrs{async}
666 3301 ▶ if exists $attrs{async};
Branch: 1 branch
BranchTrueFalseTotal
if exists $attrs{"async"} 172 3129 3301
667  
668 # The async options (pool_size, acquire_timeout, max_waiters, txn_timeout,
669 # and what the mode's backend declares) are the embedded async backend's: it
670 # reads them off the raw _connect_info. They mean nothing to a DBD and a
671 # strict one (DBD::MariaDB) rejects them, so on an async connection they stay
672 # out of THIS owner's own DBI->connect (karr k211, k397). A sync connection
673 # has no backend to consume them, so there they stay DBI attributes and the
674 # DBD's verdict stands.
675 delete @attrs{ $self->_async_option_names($info{async_mode}) }
676 3301 ▶ if defined $info{async_mode};
Branch: 1 branch
BranchTrueFalseTotal
if defined $info{"async_mode"} 172 3129 3301
677  
678 3301 my @sql_maker_opts = grep exists $attrs{$_},
679 $self->_dbio_sql_maker_option_names;
680  
681 119 @{ $info{sql_maker_options} }{@sql_maker_opts} =
682 3301 ▶ delete @attrs{@sql_maker_opts} if @sql_maker_opts;
Branch: 1 branch
BranchTrueFalseTotal
if @sql_maker_opts 119 3182 3301
683  
684 3301 ▶ $info{attributes} = \%attrs if %attrs;
Branch: 1 branch
BranchTrueFalseTotal
if %attrs 569 2732 3301
685  
686 3301 return \%info;
687 }
688  
689 # The dsn for a hash of connection parameters that has none -- dbname, host
690 # and port, as DBIO::AccessBroker::Static (or a HostBound view over it)
691 # answers them. Everything around the DSN's form is core's and happens here,
692 # once, whatever the driver (ADR 0057): the three keys are removed from the
693 # hash, so they cannot reach DBI->connect as attributes; empty ones are
694 # dropped; a dbname that is a whole DSN is the DSN; the driver is the one the
695 # storage class is registered for, which the driver component pins before any
696 # connect -- a storage that is not a driver's (the generic class has none)
697 # refuses rather than guess; a value that would split a
698 # DSN refuses. Only the form itself is the driver's: _connect_params_dsn.
699 145 ▶sub _dsn_from_connect_params {
Subroutine _dsn_from_connect_params: called CC=11 SCAR=24.0
700 145 my ($self, $params) = @_;
701  
702 145 my @keys = qw(dbname host port);
703 145 my %part;
704 145 @part{@keys} = delete @{$params}{@keys};
705  
706 # An empty dbname names no database (karr k340); one not given is undef.
707 $self->throw_exception(
708 'Cannot build a DSN from an empty dbname: it names no database. Give the '
709 . 'database name, or leave dbname out (undef) to build the DSN from host '
710 . 'and port alone.'
711 145 ▶ ) if defined $part{dbname} && !length $part{dbname};
Branch: 1 branch
BranchTrueFalseTotal
if defined $part{"dbname"} and not length $part{"dbname"} 4 141 145
Condition100%3/3
defined $part{"dbname"} and not length $part{"dbname"}
!ll&&!rl&&r
41374
MC/DC100%2/2
defined $part{"dbname"} and not length $part{"dbname"}
defined $part{"dbname"} not length $part{"dbname"}
Truth table100%3/3
A and not(B)
A= defined $part{"dbname"}B= not length $part{"dbname"}
ABresult
0X0
100
111
712  
713 141 ▶ delete @part{ grep { !defined $part{$_} || !length $part{$_} } @keys };
Condition100%3/3
defined $part{$_} && length $part{$_}
!ll&&!rl&&r
1311291
MC/DC100%2/2
defined $part{$_} && length $part{$_}
defined $part{$_} length $part{$_}
Truth table100%3/3
A && B
A= defined $part{$_}B= length $part{$_}
ABresult
0X0
100
111
714  
715 # A dbname that is a whole DSN is taken as the DSN. Host and port cannot go
716 # into it -- where they would go is the DSN form's business -- and as DBI
717 # attributes they would be lost, a HostBound view's host among them.
718 141 ▶ if (defined $part{dbname} && $part{dbname} =~ /^dbi:/i) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $part{"dbname"} and $part{"dbname"} =~ /^dbi:/i) 14 127 141
Condition100%3/3
defined $part{"dbname"} and $part{"dbname"} =~ /^dbi:/i
!ll&&!rl&&r
412314
MC/DC100%2/2
defined $part{"dbname"} and $part{"dbname"} =~ /^dbi:/i
defined $part{"dbname"} $part{"dbname"} =~ /^dbi:/i
Truth table100%3/3
A and B
A= defined $part{"dbname"}B= $part{"dbname"} =~ /^dbi:/i
ABresult
0X0
100
111
719 14 my @beside = grep { exists $part{$_} } qw(host port);
720 $self->throw_exception(
721 14 ▶ 'Connection parameter(s) ' . join(', ', map { "'$_'" } @beside)
Branch: 1 branch
BranchTrueFalseTotal
if @beside 4 10 14
722 . ' given beside a dbname that is a whole DSN: they cannot be put into '
723 . 'it. Give them inside the DSN, or give dbname as a database name.'
724 ) if @beside;
725 10 return $part{dbname};
726 }
727  
728 127 my @drivers = $self->_registered_dbd_drivers;
729 127 ▶ $self->throw_exception(
Branch: 2 branches
BranchTrueFalseTotal
unless @drivers == 1 3 124 127
@drivers ? : 0 3 3
730 'Cannot build a DSN from the connection parameters (dbname, host, port) '
731 . 'in this connect info: they name no DBI driver, and storage class '
732 . ref($self) . ' is ' . (@drivers ? 'registered for ' . join(', ', @drivers)
733 : 'not registered for any')
734 . ' DBD driver. Load the driver component in the schema class (e.g. '
735 . "__PACKAGE__->load_components('PostgreSQL')) so the storage is the "
736 . "driver's own, or supply a dsn instead."
737 ) unless @drivers == 1;
738  
739 124 for my $key (grep { exists $part{$_} } @keys) {
740 $self->throw_exception(
741 "Cannot build a DSN from the connection parameter '$key': its value "
742 . "contains ';', which separates DSN parts. Supply a dsn instead."
743 263 ▶ ) if $part{$key} =~ /;/;
Branch: 1 branch
BranchTrueFalseTotal
if $part{$key} =~ /;/ 3 260 263
744 }
745  
746 121 return $self->_connect_params_dsn($drivers[0], \%part);
747 }
748  
749  
750 118 ▶sub _connect_params_dsn {
Subroutine _connect_params_dsn: called CC=1 SCAR=0.0
751 118 my ($self, $driver, $params) = @_;
752 return "dbi:$driver:" . join ';',
753 118 map { "$_=$params->{$_}" } grep { exists $params->{$_} } qw(dbname host port);
754 }
755  
756  
757 344 my %_SERVER_NAMING_KEY = map { $_ => 1 }
758 qw(hostaddr hostname server servername address addr dsn);
759  
760 166 ▶sub _bind_host_into_dsn {
Subroutine _bind_host_into_dsn: called CC=12 SCAR=24.9
761 166 my ($self, $driver, $dsn, $host, $port) = @_;
762  
763 166 ▶ return (undef, 'a DSN without a dbi:Driver: prefix')
Branch: 1 branch
BranchTrueFalseTotal
unless defined $dsn and $dsn =~ /^dbi:[^:]*:(.*)\z/is 1 165 166
Condition66%2/3
defined $dsn and $dsn =~ /^dbi:[^:]*:(.*)\z/is
!ll&&!rl&&r
01165
MC/DC50%1/2
defined $dsn and $dsn =~ /^dbi:[^:]*:(.*)\z/is
defined $dsn $dsn =~ /^dbi:[^:]*:(.*)\z/is
Truth table66%2/3
A and B
A= defined $dsnB= $dsn =~ /^dbi:[^:]*:(.*)\z/is
ABresult
0X0
100
111
764 unless defined $dsn and $dsn =~ /^dbi:[^:]*:(.*)\z/is;
765 165 my $rest = $1;
766  
767 165 for my $token (grep { length } split /;/, $rest) {
768 292 ▶ return (undef, 'a part without key=value form (Easy Connect, TNS '
Branch: 1 branch
BranchTrueFalseTotal
unless $token =~ /^(\w+)=(.*)\z/s 4 288 292
769 . 'descriptor, data source name or positional DSN)')
770 unless $token =~ /^(\w+)=(.*)\z/s;
771 288 my ($key, $value) = ($1, $2);
772 288 my $lkey = lc $key;
773  
774 return (undef, "the key '$key' naming the server")
775 288 ▶ if $_SERVER_NAMING_KEY{$lkey};
Branch: 1 branch
BranchTrueFalseTotal
if $_SERVER_NAMING_KEY{$lkey} 6 282 288
776  
777 282 ▶ return (undef, "the key '$key' with a host: prefix in its value")
Branch: 1 branch
BranchTrueFalseTotal
if $lkey eq "db" || $lkey eq "dbname" || $lkey eq "database" and $value =~ m(^[^:/\\]+(?:/\d+)?:) and not $value =~ m[^[A-Za-z]:[\\/]] 1 281 282
Condition100%12/12
$lkey eq "db" || $lkey eq "dbname" || $lkey eq "database" and $value =~ m(^[^:/\\]+(?:/\d+)?:) and not $value =~ m[^[A-Za-z]:[\\/]]
!ll&&!rl&&r
28011
$lkey eq "db" || $lkey eq "dbname" || $lkey eq "database" and $value =~ m(^[^:/\\]+(?:/\d+)?:)
!ll&&!rl&&r
1251552
$lkey eq "db" or $lkey eq "dbname" or $lkey eq "database"
l!l&&r!l&&!r
1552125
$lkey eq "db" or $lkey eq "dbname"
l!l&&r!l&&!r
2153127
MC/DC40%2/5
$lkey eq "db" || $lkey eq "dbname" || $lkey eq "database" and $value =~ m(^[^:/\\]+(?:/\d+)?:) and not $value =~ m[^[A-Za-z]:[\\/]]
$lkey eq "db" $lkey eq "dbname" $lkey eq "database" $value =~ m(^[^:/\\]+(?:/\d+)?:) not $value =~ m[^[A-Za-z]:[\\/]]
Truth table50%5/10
A or B or C and D and not(E)
A= $lkey eq "db"B= $lkey eq "dbname"C= $lkey eq "database"D= $value =~ m(^[^:/\\]+(?:/\d+)?:)E= not $value =~ m[^[A-Za-z]:[\\/]]
ABCDEresult
000XX0
1XX0X0
01X0X0
0010X0
1XX100
01X100
001100
1XX111
01X111
001111
778 if ($lkey eq 'db' or $lkey eq 'dbname' or $lkey eq 'database')
779 and $value =~ m{^[^:/\\]+(?:/\d+)?:}
780 and $value !~ m{^[A-Za-z]:[\\/]};
781 }
782  
783 154 $dsn = _dsn_set_token($dsn, host => $host);
784 154 ▶ $dsn = _dsn_set_token($dsn, port => $port) if defined $port;
Branch: 1 branch
BranchTrueFalseTotal
if defined $port 38 116 154
785 154 return $dsn;
786 }
787  
788 # Replace an existing "key=..." token in place, else splice one in front of
789 # the attribute section after "dbi:Driver:".
790 192 ▶sub _dsn_set_token {
Subroutine _dsn_set_token: called CC=4 SCAR=14.0
791 192 my ($dsn, $key, $val) = @_;
792  
793 192 ▶ return $dsn if $dsn =~ s/(^|[:;])\Q$key\E=[^;]*/$1$key=$val/i;
Branch: 1 branch
BranchTrueFalseTotal
if $dsn =~ s/(^|[:;])\Q$key\E=[^;]*/$1$key=$val/i 116 76 192
794  
795 76 ▶ if ($dsn =~ /^(dbi:[^:]*:)(.*)$/is) {
Branch: 1 branch
BranchTrueFalseTotal
if ($dsn =~ /^(dbi:[^:]*:)(.*)$/is) 76 0 76
796 76 my ($prefix, $rest) = ($1, $2);
797 76 ▶ return $prefix . (length $rest ? "$key=$val;$rest" : "$key=$val");
Branch: 1 branch
BranchTrueFalseTotal
length $rest ? : 75 1 76
798 }
799  
800 0 return $dsn;
801 }
802  
803  
804 153 ▶sub _dbd_attribute_prefixes {
Subroutine _dbd_attribute_prefixes: called CC=2 SCAR=7.0
805 153 my ($self, $driver) = @_;
806 153 ▶ return unless defined $driver;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $driver 0 153 153
807  
808 # not before a broker's answer needs it: DBI.pm is otherwise loaded at the
809 # first connect (see _extract_driver_from_connect_info)
810 153 require DBI;
811 153 return DBI->driver_prefix("DBD::$driver");
812 }
813  
814 2711 ▶sub _default_dbi_connect_attributes () {
Subroutine _default_dbi_connect_attributes: called CC=1 SCAR=0.0
815 +{
816 2711 AutoCommit => 1,
817 PrintError => 0,
818 RaiseError => 1,
819 ShowErrorStatement => 0,
820 };
821 }
822  
823  
824  
825 273 ▶sub _parse_connect_do {
Subroutine _parse_connect_do: called CC=5 SCAR=16.2
826 273 my ($self, $type) = @_;
827  
828 273 my $val = $self->$type;
829 273 ▶ return () if not defined $val;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $val 205 68 273
830  
831 68 my @res;
832  
833 68 ▶ if (not ref($val)) {
Branch: 3 branches
BranchTrueFalseTotal
if (not ref $val) { } 10 58 68
elsif (ref $val eq 'CODE') { } 1 57 58
elsif (ref $val eq 'ARRAY') { } 57 0 57
834 10 push @res, [ 'do_sql', $val ];
835 } elsif (ref($val) eq 'CODE') {
836 1 push @res, $val;
837 } elsif (ref($val) eq 'ARRAY') {
838 57 push @res, map { [ 'do_sql', $_ ] } @$val;
839 } else {
840 0 $self->throw_exception("Invalid type for $type: ".ref($val));
841 }
842  
843 68 return \@res;
844 }
845  
846  
847 96 ▶sub dbh_do {
Subroutine dbh_do: called CC=4 SCAR=13.9
Pod documented
848 96 my $self = shift;
849 96 my $run_target = shift; # either a coderef or a method name
850  
851 # short circuit when we know there is no need for a runner
852 #
853 # FIXME - assumption may be wrong
854 # the rationale for the txn_depth check is that if this block is a part
855 # of a larger transaction, everything up to that point is screwed anyway
856 return $self->$run_target($self->_get_dbh, @_)
857 96 ▶ if $self->{_in_do_block} or $self->transaction_depth;
Branch: 1 branch
BranchTrueFalseTotal
if $self->{"_in_do_block"} or $self->transaction_depth 3 93 96
Condition66%2/3
$self->{"_in_do_block"} or $self->transaction_depth
l!l&&r!l&&!r
3093
MC/DC50%1/2
$self->{"_in_do_block"} or $self->transaction_depth
$self->{"_in_do_block"} $self->transaction_depth
Truth table66%2/3
A or B
A= $self->{"_in_do_block"}B= $self->transaction_depth
ABresult
1X1
011
000
858  
859 # take a ref instead of a copy, to preserve @_ aliasing
860 # semantics within the coderef, but only if needed
861 # (pseudoforking doesn't like this trick much)
862 93 ▶ my $args = @_ ? \@_ : [];
Branch: 1 branch
BranchTrueFalseTotal
@_ ? : 31 62 93
863  
864 DBIO::Storage::BlockRunner->new(
865 storage => $self,
866 wrap_txn => 0,
867 25 ▶ retry_handler => sub {
Subroutine __ANON__: called CC=2 SCAR=7.6
868 25 ▶ $_[0]->failed_attempt_count == 1
Branch: 1 branch
BranchTrueFalseTotal
$_[0]->failed_attempt_count == 1 and not $_[0]->storage->connected 25 0 25
869 and
870 ! $_[0]->storage->connected
871 },
872 98 ▶ )->run(sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
873 98 $self->$run_target ($self->_get_dbh, @$args )
874 93 });
875 }
876  
877 111 ▶sub txn_do {
Subroutine txn_do: called CC=1 SCAR=0.0
Pod documented
878 111 $_[0]->_get_dbh; # connects or reconnects on pid change, necessary to grab correct txn_depth
879 111 shift->next::method(@_);
880 }
881  
882  
883 405 ▶sub register_async_mode {
Subroutine register_async_mode: called CC=1 SCAR=0.0
Pod documented
884 405 my ($class, $mode, $backend_class) = @_;
885 405 $_async_mode_registry{$class}{$mode} = $backend_class;
886 }
887  
888 # Ownership of a pinned async context is scoped to one backend/pool generation.
889 # The owner mirrors the current backend's opaque token; no class, DSN or schema
890 # identity participates in the comparison.
891 2963 ▶sub _reset_async_context_owner_token {
Subroutine _reset_async_context_owner_token: called CC=1 SCAR=0.0
892 2963 my ($self) = @_;
893 2963 $self->_async_context_owner_token(undef);
894 2963 return;
895 }
896  
897 # A detached old backend may rotate while shutting down. Adopt its token only
898 # while it is still the backend cached by this concrete sync storage object.
899 454 ▶sub _adopt_async_context_owner_token {
Subroutine _adopt_async_context_owner_token: called CC=3 SCAR=11.0
900 454 my ($self, $backend, $token) = @_;
901 454 ▶ my $current = $self->{_async_storage_obj} or return;
Branch: 1 branch
BranchTrueFalseTotal
my $current = $self->{"_async_storage_obj"} or return 10 444 454
902 10 ▶ return unless refaddr($current) == refaddr($backend);
Branch: 1 branch
BranchTrueFalseTotal
unless builtin::refaddr($current) == builtin::refaddr($backend) 3 7 10
903 7 $self->_async_context_owner_token($token);
904 7 return;
905 }
906  
907 # The one ownership comparison used by with_context, ORM dispatch and direct
908 # Core context entry points. Context-shaped external objects without Core's
909 # token evidence fail closed.
910 #
911 # One context carries no token and is still this storage's own: in the
912 # 'immediate' mode txn_do_async hands its coderef the storage itself (ADR
913 # 0055), so there the proof is identity -- the very object asked, and only
914 # while its mode is literally 'immediate' (karr k282). Another storage, a
915 # storage with no async mode and a storage with a real backend (whose context
916 # is a TransactionContext carrying the token) all fall through to the token
917 # comparison below and are refused there as before.
918 698 ▶sub _assert_async_context_owner {
Subroutine _assert_async_context_owner: called CC=15 SCAR=27.5
919 698 my ($self, $ctx) = @_;
920  
921 698 ▶ return $ctx
Branch: 1 branch
BranchTrueFalseTotal
if builtin::blessed($ctx) and builtin::refaddr($ctx) == builtin::refaddr($self) and ($self->_async_mode // "") eq "immediate" 102 596 698
Condition87%7/8
builtin::blessed($ctx) and builtin::refaddr($ctx) == builtin::refaddr($self) and ($self->_async_mode // "") eq "immediate"
!ll&&!rl&&r
5942102
builtin::blessed($ctx) and builtin::refaddr($ctx) == builtin::refaddr($self)
!ll&&!rl&&r
0594104
$self->_async_mode // ""
l!l
1031
MC/DC66%2/3
builtin::blessed($ctx) and builtin::refaddr($ctx) == builtin::refaddr($self) and ($self->_async_mode // "") eq "immediate"
builtin::blessed($ctx) builtin::refaddr($ctx) == builtin::refaddr($self) $self->_async_mode
Truth table75%3/4
A and B and C
A= builtin::blessed($ctx)B= builtin::refaddr($ctx) == builtin::refaddr($self)C= $self->_async_mode
ABCresult
0XX0
10X0
1100
1111
922 if blessed($ctx)
923 and refaddr($ctx) == refaddr($self)
924 and ( $self->_async_mode // '' ) eq 'immediate';
925  
926 # The pooled backend itself carries the owner token by construction and
927 # answers the six *_async methods, but it is no pinned context: a statement
928 # sent through it takes whatever pool connection is free. A context comes
929 # out of txn_do_async or a pipeline coderef (karr k331).
930 $self->throw_exception(
931 'the pooled async backend is not a pinned context: with_context takes '
932 . 'the context handed to a txn_do_async or pipeline coderef'
933 ) if blessed($ctx)
934 and ( $ctx->isa('DBIO::Storage::Async')
935 or ( ($self->{_async_storage_obj} // 0)
936 596 ▶ and refaddr($ctx) == refaddr($self->{_async_storage_obj}) ) );
Branch: 1 branch
BranchTrueFalseTotal
if builtin::blessed($ctx) and $ctx->isa("DBIO::Storage::Async") || ($self->{"_async_storage_obj"} // 0) && builtin::refaddr($ctx) == builtin::refaddr($self->{"_async_storage_obj"}) 2 594 596
Condition72%8/11
builtin::blessed($ctx) and $ctx->isa("DBIO::Storage::Async") || ($self->{"_async_storage_obj"} // 0) && builtin::refaddr($ctx) == builtin::refaddr($self->{"_async_storage_obj"})
!ll&&!rl&&r
05942
$ctx->isa("DBIO::Storage::Async") or $self->{"_async_storage_obj"} // 0 and builtin::refaddr($ctx) == builtin::refaddr($self->{"_async_storage_obj"})
l!l&&r!l&&!r
20594
$self->{"_async_storage_obj"} // 0 and builtin::refaddr($ctx) == builtin::refaddr($self->{"_async_storage_obj"})
!ll&&!rl&&r
1374570
$self->{"_async_storage_obj"} // 0
l!l
457137
MC/DC25%1/4
builtin::blessed($ctx) and $ctx->isa("DBIO::Storage::Async") || ($self->{"_async_storage_obj"} // 0) && builtin::refaddr($ctx) == builtin::refaddr($self->{"_async_storage_obj"})
builtin::blessed($ctx) $ctx->isa("DBIO::Storage::Async") $self->{"_async_storage_obj"} builtin::refaddr($ctx) == builtin::refaddr($self->{"_async_storage_obj"})
Truth table60%3/5
A and B or C and D
A= builtin::blessed($ctx)B= $ctx->isa("DBIO::Storage::Async")C= $self->{"_async_storage_obj"}D= builtin::refaddr($ctx) == builtin::refaddr($self->{"_async_storage_obj"})
ABCDresult
0XXX0
100X0
10100
11XX1
10111
937  
938 594 ▶ $self->throw_exception('async context ownership cannot be proven')
Branch: 1 branch
BranchTrueFalseTotal
unless builtin::blessed($ctx) and $ctx->can("_context_owner_token") 7 587 594
Condition66%2/3
builtin::blessed($ctx) and $ctx->can("_context_owner_token")
!ll&&!rl&&r
07587
MC/DC50%1/2
builtin::blessed($ctx) and $ctx->can("_context_owner_token")
builtin::blessed($ctx) $ctx->can("_context_owner_token")
Truth table66%2/3
A and B
A= builtin::blessed($ctx)B= $ctx->can("_context_owner_token")
ABresult
0X0
100
111
939 unless blessed($ctx) && $ctx->can('_context_owner_token');
940  
941 587 my $ours = $self->_async_context_owner_token;
942 587 my $theirs = $ctx->_context_owner_token;
943 587 ▶ $self->throw_exception(
Branch: 1 branch
BranchTrueFalseTotal
unless $ours and $theirs and builtin::refaddr($ours) == builtin::refaddr($theirs) 18 569 587
Condition83%5/6
$ours and $theirs and builtin::refaddr($ours) == builtin::refaddr($theirs)
!ll&&!rl&&r
117569
$ours and $theirs
!ll&&!rl&&r
10586
MC/DC66%2/3
$ours and $theirs and builtin::refaddr($ours) == builtin::refaddr($theirs)
$ours $theirs builtin::refaddr($ours) == builtin::refaddr($theirs)
Truth table75%3/4
A and B and C
A= $oursB= $theirsC= builtin::refaddr($ours) == builtin::refaddr($theirs)
ABCresult
0XX0
10X0
1100
1111
944 'async context does not belong to this storage generation'
945 ) unless $ours && $theirs && refaddr($ours) == refaddr($theirs);
946 569 return $ctx;
947 }
948  
949 # The storage as the 'immediate' mode's transaction context (ADR 0055) answers
950 # the two things a ResultSet, Row or ResultSetColumn bound to it asks beyond
951 # the six *_async methods (ADR 0045, karr k282).
952 #
953 # _context_active: true while an 'immediate' txn_do_async is running on this
954 # storage -- from before its coderef is called until it has returned, which is
955 # when the COMMIT or ROLLBACK goes out. A bound object used outside of that is
956 # refused ('no longer active') like one held past a real backend's
957 # transaction. There is one connection and no pool here, so "a transaction of
958 # this kind is open" is all there is to know: an object bound in one such
959 # transaction and used inside a later one runs in the later one.
960 61 ▶sub _context_active { $_[0]->{_immediate_txn_failures} ? 1 : 0 }
Subroutine _context_active: called CC=2 SCAR=6.9
Branch: 1 branch
BranchTrueFalseTotal
$_[0]{'_immediate_txn_failures'} ? : 55 6 61
961  
962 # _query_async: the raw-SQL member of the surface (results_exist_async uses
963 # it). With a real backend it is the backend's own pooled seam; in the
964 # 'immediate' mode the rendered statement runs in-process and resolves with
965 # its rows, the form the seam resolves a SELECT with.
966 1 ▶sub _query_async { shift->_run_async( _query => @_ ) }
Subroutine _query_async: called CC=1 SCAR=0.0
967  
968 # The class whose linearised ISA the async transport/mode resolution walks.
969 # Async transport (mode) resolution is a property of the DRIVER, never of the
970 # storage LAYERS composed on top of it (ADR 0032): a composed instance's class
971 # (DBIO::Storage::Composed::<layer>__<driver>) has the sync layer packages
972 # more-specific than the driver in its MRO, and a sync layer's plain ::Async
973 # mixin (the WP2 async-mirror target -- NOT a DBIO::Storage::Async transport)
974 # would otherwise be probed before the driver's real transport adapter. So we
975 # resolve the walk against the composition BASE (the concrete driver storage),
976 # not ref($self). A non-composed instance has no registry entry -> base is just
977 # ref($self), i.e. behaviour identical to before composition existed. Class-
978 # method callers (e.g. DBIO::Storage::DBI->_resolve_async_mode_class) keep the
979 # ref($self) || $self fallback.
980 841 ▶sub _async_resolution_class {
Subroutine _async_resolution_class: called CC=3 SCAR=11.0
981 841 my $self = shift;
982 841 ▶ my $class = ref($self) || $self;
Condition66%2/3
ref $self || $self
l!l&&r!l&&!r
83650
MC/DC0%0/2
ref $self || $self
ref $self $self
Truth table66%2/3
A || B
A= ref $selfB= $self
ABresult
1X1
011
000
983 841 my $comp = DBIO::Storage::Composed->composition_of($class);
984 841 ▶ return $comp ? $comp->{base} : $class;
Branch: 1 branch
BranchTrueFalseTotal
$comp ? : 15 826 841
985 }
986  
987 # Walk the instance's MRO and return the backend class registered for $mode
988 # (driver registrations shadow/extend generic ones), or undef if no class in
989 # the linearised ISA registered that mode. With exclude => $pkg, that one class
990 # is skipped in the walk -- used by future_io to honour an explicit
991 # per-driver registration while ignoring any GENERIC base-class one. The walk
992 # is over the composition BASE (see _async_resolution_class), so storage layers
993 # never shadow the driver's transport registrations.
994 806 ▶sub _resolve_async_mode_class {
Subroutine _resolve_async_mode_class: called CC=6 SCAR=17.9
995 806 my ($self, $mode, %opt) = @_;
996 806 my $exclude = $opt{exclude};
997 806 for my $pkg (@{ mro::get_linear_isa($self->_async_resolution_class) }) {
998 1687 ▶ next if defined $exclude and $pkg eq $exclude;
Branch: 1 branch
BranchTrueFalseTotal
if defined $exclude and $pkg eq $exclude 32 1655 1687
Condition100%3/3
defined $exclude and $pkg eq $exclude
!ll&&!rl&&r
130035532
MC/DC100%2/2
defined $exclude and $pkg eq $exclude
defined $exclude $pkg eq $exclude
Truth table100%3/3
A and B
A= defined $excludeB= $pkg eq $exclude
ABresult
0X0
100
111
999 return $_async_mode_registry{$pkg}{$mode}
1000 if exists $_async_mode_registry{$pkg}
1001 1655 ▶ && exists $_async_mode_registry{$pkg}{$mode};
Branch: 1 branch
BranchTrueFalseTotal
if exists $_async_mode_registry{$pkg} and exists $_async_mode_registry{$pkg}{$mode} 770 885 1655
Condition100%3/3
exists $_async_mode_registry{$pkg} and exists $_async_mode_registry{$pkg}{$mode}
!ll&&!rl&&r
83451770
MC/DC100%2/2
exists $_async_mode_registry{$pkg} and exists $_async_mode_registry{$pkg}{$mode}
exists $_async_mode_registry{$pkg} exists $_async_mode_registry{$pkg}{$mode}
Truth table100%3/3
A and B
A= exists $_async_mode_registry{$pkg}B= exists $_async_mode_registry{$pkg}{$mode}
ABresult
0X0
100
111
1002 }
1003 36 return undef;
1004 }
1005  
1006 # Resolve an OPTIONAL async class candidate to the three-way outcome that
1007 # load_optional_class alone cannot express: LOADED / genuinely-ABSENT /
1008 # PRESENT-but-UNLOADABLE. load_optional_class returns 0 only when the
1009 # candidate's OWN .pm is missing from @INC; when the file EXISTS but its
1010 # compilation fails -- e.g. its own dependency is not installed (the driver
1011 # ships <pkg>::Async, but the separate async dist providing its base class,
1012 # such as DBIO::Async, is absent), or a genuine bug in the adapter -- it
1013 # instead THROWS the raw compile error. We reproduce the distinction and, on
1014 # the unloadable case, fail loud with a clear, correctly-attributed message
1015 # (ADR 0030 §3: a broken adapter fails loud, never silently degrading to a
1016 # parent's). Naming the missing MODULE is only claimed when Perl actually
1017 # reports one -- a syntax error in an installed adapter is surfaced honestly,
1018 # never misreported as a missing dependency.
1019 # Returns 1 if loaded, 0 if genuinely absent; throws otherwise.
1020 65 ▶sub _try_load_async_class {
Subroutine _try_load_async_class: called CC=7 SCAR=19.8
1021 65 my ($self, $candidate, $what) = @_;
1022 65 ▶ $what //= 'async class';
Condition50%1/2
$what //= "async class"
l!l
650
MC/DC0%0/1
$what //= "async class"
$what
Truth table50%1/2
A
A= $what
Aresult
11
00
1023  
1024 65 my $loaded = eval { $self->load_optional_class($candidate) };
1025 65 ▶ return $loaded if defined $loaded; # 1 = loaded, 0 = genuinely absent
Branch: 1 branch
BranchTrueFalseTotal
if defined $loaded 62 3 65
1026  
1027 3 my $err = $@; # load_optional_class threw: file exists, compilation failed
1028  
1029 # A not-installed dependency shows up in one of two shapes: the require's
1030 # own "Can't locate X.pm in @INC", or use base/parent's "Base class
1031 # package "X" is empty" (base.pm suppresses the inner Can't-locate and
1032 # reports the empty base instead).
1033 3 my $missing;
1034 3 ▶ if ($err =~ /\bCan't locate (\S+?)\.pm in \@INC/) {
Branch: 2 branches
BranchTrueFalseTotal
if ($err =~ /\bCan't locate (\S+?)\.pm in \@INC/) { } 0 3 3
elsif ($err =~ /\bBase class package "([\w:]+)" is empty/) { } 2 1 3
1035 0 ($missing = $1) =~ s{/}{::}g;
1036 }
1037 elsif ($err =~ /\bBase class package "([\w:]+)" is empty/) {
1038 2 $missing = $1;
1039 }
1040  
1041 $self->throw_exception(
1042 3 ▶ (defined $missing && $missing ne $candidate)
Branch: 1 branch
BranchTrueFalseTotal
defined $missing && $missing ne $candidate ? : 2 1 3
Condition66%2/3
defined $missing and $missing ne $candidate
!ll&&!rl&&r
102
MC/DC50%1/2
defined $missing and $missing ne $candidate
defined $missing $missing ne $candidate
Truth table66%2/3
A and B
A= defined $missingB= $missing ne $candidate
ABresult
0X0
100
111
1043 ? "$what '$candidate' is present but cannot be loaded -- it requires "
1044 . "'$missing', which is not installed. Install the distribution that "
1045 . "provides '$missing' and retry.\n\nUnderlying error: $err"
1046 : "$what '$candidate' is present but failed to load.\n\n"
1047 . "Underlying error: $err"
1048 );
1049 }
1050  
1051 # Resolve (and cache) the embedded async backend for this instance's chosen
1052 # mode, or undef. undef means one of two very different things, disambiguated
1053 # by _async_mode: no mode chosen (sync -- *_async croaks) vs. the 'immediate'
1054 # in-process mode (no event loop, no backend -- *_async degrades). A bad/absent
1055 # mode, or a loaded wrong-type target for any mode other than literal
1056 # 'immediate', croaks loudly here (ADR 0030: explicit or it croaks). The
1057 # resolved value is cached in {_async_storage_obj}; disconnect/connect_info
1058 # delete the slot.
1059 2202 ▶sub _async_storage {
Subroutine _async_storage: called CC=3 SCAR=11.0
1060 2202 my $self = shift;
1061  
1062 return $self->{_async_storage_obj}
1063 2202 ▶ if exists $self->{_async_storage_obj};
Branch: 1 branch
BranchTrueFalseTotal
if exists $self->{"_async_storage_obj"} 1660 542 2202
1064  
1065 542 my $mode = $self->_async_mode;
1066  
1067 # No async mode chosen -> sync instance, no backend. The *_async dispatch
1068 # turns this into a loud croak; we never touch the driver/registry here.
1069 return $self->{_async_storage_obj} = undef
1070 542 ▶ if !defined $mode;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $mode 22 520 542
1071  
1072 # The native 'ev' mapping is declared on the concrete driver storage class,
1073 # and future_io's adapter is derived by convention FROM that class (below);
1074 # both only work once the storage is reblessed into its driver storage. Force
1075 # driver determination so the registry walk sees the driver's registrations
1076 # and ref($self) is the concrete driver storage class.
1077 520 $self->_determine_driver;
1078  
1079 520 my $backend_class = $self->_resolve_async_backend_class($mode);
1080 508 return $self->_embed_async_backend($mode, $backend_class);
1081 }
1082  
1083 # The backend class an async mode resolves to, or a throw that names why the
1084 # mode is not available. Split from _async_storage so that the class can be
1085 # asked for on its own: the connect options a backend declares are known from
1086 # it (_async_option_names, karr core k397).
1087 802 ▶sub _resolve_async_backend_class {
Subroutine _resolve_async_backend_class: called CC=11 SCAR=24.0
1088 802 my ($self, $mode) = @_;
1089  
1090 802 my $backend_class;
1091  
1092 802 ▶ if ($mode eq 'future_io') {
Branch: 1 branch
BranchTrueFalseTotal
if ($mode eq 'future_io') { } 33 769 802
1093 # --- ADR 0030 refinement: future_io class-by-CONVENTION ----------------
1094 # future_io's transport adapter is discovered off the concrete,
1095 # driver-determined storage class: <pkg> . '::Async' -- parallel to the
1096 # sync driver storage (DBIO::X::Storage -> DBIO::X::Storage::Async). Because
1097 # a storage is always driver-specific, every driver's adapter is thus
1098 # deterministic with no registry entry at all. Precedence:
1099 # 1. An EXPLICIT register_async_mode(future_io => ...) on a concrete
1100 # driver storage class still wins, as a backward-compatible override.
1101 # A GENERIC base-class (DBIO::Storage::DBI) registration is deliberately
1102 # NOT honoured -- so merely loading an async dist can no longer globally
1103 # "claim" future_io for every driver and then die deep in an abstract
1104 # base's _submit_query seam. That is exactly what this replaces.
1105 # 2. Otherwise WALK the linearised ISA (ADR 0030 second refinement),
1106 # most-specific first, probing <pkg>::Async at each rung and
1107 # STOPPING strictly BEFORE the generic DBIO::Storage::DBI base (a
1108 # generic ::Async claiming every driver is the hole rule 1 closes; the
1109 # walk must not reopen it). The first candidate that LOADS wins; one
1110 # that loads but is NOT a DBIO::Storage::Async croaks AT ONCE naming
1111 # it -- a broken extension adapter fails loud, never silently degrading
1112 # to a parent's adapter. This mirrors the registry walk
1113 # (_resolve_async_mode_class) so extension storage_type subclasses
1114 # (AGE/PostGIS) inherit the nearest parent adapter, just like sync
1115 # storage inheritance.
1116 # The MODE stays explicit (ADR 0030: the caller still writes
1117 # { async => 'future_io' }); only the CLASS is resolved by convention. This
1118 # is NOT the banned ADR 0029 mode auto-fallback.
1119 33 $backend_class = $self->_resolve_async_mode_class($mode, exclude => __PACKAGE__);
1120  
1121 33 ▶ if (defined $backend_class) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $backend_class) { } 1 32 33
1122 1 ▶ $self->throw_exception(
Branch: 1 branch
BranchTrueFalseTotal
unless $self->load_optional_class($backend_class) 0 1 1
1123 "async mode '$mode' is not available -- install $backend_class"
1124 ) unless $self->load_optional_class($backend_class);
1125 }
1126 else {
1127 # Walk the composition BASE, not ref($self): the transport adapter is a
1128 # property of the concrete DRIVER, and a composed instance's storage
1129 # layers (with their plain ::Async mixins) sit more-specific than the
1130 # driver in ref($self)'s MRO -- probing those would find a layer's async
1131 # mixin (not a DBIO::Storage::Async) before the driver's real adapter and
1132 # croak. For a non-composed instance the base IS ref($self).
1133 32 my $class = $self->_async_resolution_class;
1134 32 my @tried;
1135 32 for my $pkg (@{ mro::get_linear_isa($class) }) {
1136 46 ▶ last if $pkg eq __PACKAGE__; # stop strictly BEFORE the generic base
Branch: 1 branch
BranchTrueFalseTotal
if $pkg eq __PACKAGE__ 6 40 46
1137 40 my $adapter = $pkg . '::Async';
1138 40 push @tried, $adapter;
1139 # Genuinely absent -> keep walking; present-but-unloadable (its own
1140 # async dependency missing, or broken) -> fail loud with the cause.
1141 40 ▶ next unless $self->_try_load_async_class($adapter, 'future_io adapter');
Branch: 1 branch
BranchTrueFalseTotal
unless $self->_try_load_async_class($adapter, "future_io adapter") 14 24 38
1142  
1143 # Loaded -- it MUST be a proper backend or we fail loud, naming it;
1144 # never silently skip past it to a parent's adapter (ADR 0030 §3).
1145 24 ▶ $self->throw_exception(
Branch: 1 branch
BranchTrueFalseTotal
unless $adapter->isa("DBIO::Storage::Async") 1 23 24
1146 "driver $class does not support future_io -- "
1147 . "$adapter loaded but is not a DBIO::Storage::Async"
1148 ) unless $adapter->isa('DBIO::Storage::Async');
1149  
1150 23 $backend_class = $adapter;
1151 23 last;
1152 }
1153  
1154 $self->throw_exception(
1155 29 ▶ "driver $class does not support future_io -- no ${class}::Async adapter "
Branch: 1 branch
BranchTrueFalseTotal
unless defined $backend_class 6 23 29
1156 6 . "found on it or any parent (tried: @{[ join ', ', @tried ]})"
1157 ) unless defined $backend_class;
1158 }
1159 }
1160 else {
1161 769 $backend_class = $self->_resolve_async_mode_class($mode);
1162  
1163 769 ▶ $self->throw_exception(
Branch: 1 branch
BranchTrueFalseTotal
unless defined $backend_class 3 766 769
1164 "async mode '$mode' is not available -- no driver or add-on registers it"
1165 ) if !defined $backend_class;
1166  
1167 766 ▶ $self->throw_exception(
Branch: 1 branch
BranchTrueFalseTotal
unless $self->load_optional_class($backend_class) 1 765 766
1168 "async mode '$mode' is not available -- install $backend_class"
1169 ) unless $self->load_optional_class($backend_class);
1170 }
1171  
1172 789 return $backend_class;
1173 }
1174  
1175 # The names of the async options a connection with async mode $mode takes: the
1176 # core's (DBIO::Storage::_core_async_option_names) and those the mode's backend
1177 # class declares (DBIO::Storage::Async->async_option_names). The backend class
1178 # is asked without connecting and without a driver determination; a mode whose
1179 # backend cannot be resolved or loaded contributes the core names alone -- the
1180 # mode's own error is thrown at its first use, as before (karr core k397).
1181 282 ▶sub _async_option_names {
Subroutine _async_option_names: called CC=5 SCAR=16.1
1182 282 my ($self, $mode) = @_;
1183  
1184 282 my @names = $self->_core_async_option_names;
1185 282 ▶ return @names unless defined $mode;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $mode 0 282 282
1186  
1187 282 my $backend_class;
1188 282 { local $@; $backend_class = eval { $self->_resolve_async_backend_class($mode) }; }
1189 282 ▶ push @names, $backend_class->async_option_names
Branch: 1 branch
BranchTrueFalseTotal
if defined $backend_class and not ref $backend_class and $backend_class->can("async_option_names") 203 79 282
Condition83%5/6
defined $backend_class and not ref $backend_class and $backend_class->can("async_option_names")
!ll&&!rl&&r
178203
defined $backend_class and not ref $backend_class
!ll&&!rl&&r
10281
MC/DC66%2/3
defined $backend_class and not ref $backend_class and $backend_class->can("async_option_names")
defined $backend_class not ref $backend_class $backend_class->can("async_option_names")
Truth table75%3/4
A and not(B) and C
A= defined $backend_classB= not ref $backend_classC= $backend_class->can("async_option_names")
ABCresult
0XX0
10X0
1100
1111
1190 if defined $backend_class && !ref $backend_class
1191 && $backend_class->can('async_option_names');
1192  
1193 282 my %seen;
1194 282 return grep { !$seen{$_}++ } @names;
1195 }
1196  
1197 # The embedded backend for $mode, built from the class it resolved to and this
1198 # storage's connect info, cached in {_async_storage_obj}.
1199 508 ▶sub _embed_async_backend {
Subroutine _embed_async_backend: called CC=26 SCAR=32.7
1200 508 my ($self, $mode, $backend_class) = @_;
1201  
1202 # Only the literal 'immediate' mode may resolve to its Future class rather
1203 # than a DBIO::Storage::Async backend. A wrong-type registry target is a
1204 # configuration error, never a silent synchronous fallback.
1205 508 ▶ unless ($backend_class->isa('DBIO::Storage::Async')) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($backend_class->isa("DBIO::Storage::Async")) 90 418 508
1206 return $self->{_async_storage_obj} = undef
1207 90 ▶ if $mode eq 'immediate';
Branch: 1 branch
BranchTrueFalseTotal
if $mode eq "immediate" 88 2 90
1208 2 $self->throw_exception(
1209 "async mode '$mode' resolved to $backend_class, which is not a "
1210 . 'DBIO::Storage::Async backend'
1211 );
1212 }
1213  
1214 # The transport itself, before any async layer is composed over it.
1215 418 my $transport_class = $backend_class;
1216  
1217 # --- Async mirror composition (ADR 0032). The transport class is now
1218 # resolved; mirror each registered SYNC storage layer onto its ASYNC
1219 # counterpart and compose them over the transport, so an extension's async
1220 # behaviour rides every transport just as its sync behaviour rides every
1221 # driver (one behaviour, one transport). Per sync layer L, in registration
1222 # order:
1223 # * L->async_layer_class($mode) if L defines it -- a package (must load, or
1224 # croak) or undef, which is the STATED opt-out: L is deliberately
1225 # sync-only for $mode and is skipped without any load attempt (ADR 0032
1226 # amendment 2026-09-25, karr k159);
1227 # * otherwise (method NOT defined -- silent) the convention sibling
1228 # "${L}::Async" via load_optional_class;
1229 # * silent and absent -> REFUSAL (karr k159 step 3, ADR 0032 amendment
1230 # 2026-09-25): a layer that neither states an answer nor ships the
1231 # convention sibling croaks, naming the layer and both ways out. There
1232 # is no silent path left in the mirror step.
1233 # This does NOT touch the transport resolution above (ADR 0030: the mode
1234 # stays explicit; only the layer CLASSES are added by composition).
1235 # A storage with no live schema (weakened ref already gone) can carry no
1236 # registered layers, so there is nothing to mirror.
1237 418 my $schema = $self->schema;
1238 418 my @async_layers;
1239 418 ▶ for my $sync_layer ($schema ? @{ $schema->storage_layers } : ()) {
Branch: 1 branch
BranchTrueFalseTotal
$schema ? : 396 22 418
1240 35 my $async_layer;
1241  
1242 35 ▶ if ($sync_layer->can('async_layer_class')) {
Branch: 1 branch
BranchTrueFalseTotal
if ($sync_layer->can('async_layer_class')) { } 12 23 35
1243 # Defining the method IS the statement (stated vs. silent, as for
1244 # required_transport_capabilities below). Its undef return therefore
1245 # means "deliberately no async layer for this mode" -- NOT "use the
1246 # convention": undef here is not a forgotten return. The convention
1247 # sibling is neither probed nor loaded, even if one exists; the
1248 # layer's own declaration wins. Note can() sees an inherited
1249 # declaration, so a subclass of a declaring layer inherits its answer.
1250 12 $async_layer = $sync_layer->async_layer_class($mode);
1251 12 ▶ next unless defined $async_layer;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $async_layer 10 2 12
1252  
1253 # An explicitly declared class MUST load: genuinely absent -> the
1254 # "could not be loaded" croak; present-but-unloadable -> _try_load's
1255 # cause-naming croak (never a raw compile stack).
1256 2 ▶ $self->throw_exception(
Branch: 1 branch
BranchTrueFalseTotal
unless $self->_try_load_async_class($async_layer, "async layer class for storage layer '${sync_layer}'") 0 2 2
1257 "async layer class '$async_layer' for storage layer '$sync_layer' "
1258 . "(async mode '$mode') could not be loaded"
1259 ) unless $self->_try_load_async_class(
1260 $async_layer, "async layer class for storage layer '$sync_layer'"
1261 );
1262 }
1263 else {
1264 23 my $candidate = "${sync_layer}::Async";
1265 # Silent layer -> convention sibling. Present-but-unloadable -> fail
1266 # loud naming the cause, never a silent feature loss nor a raw compile
1267 # stack. Genuinely absent -> REFUSAL (karr k159 step 3, ADR 0032
1268 # amendment 2026-09-25): a typo in a mirror's package name and a
1269 # deliberately sync-only extension used to end in the same silent
1270 # skip. Now the layer must say which it is.
1271 23 ▶ $self->throw_exception(
Branch: 1 branch
BranchTrueFalseTotal
unless $self->_try_load_async_class($candidate, "async layer") 1 21 22
1272 "storage layer '$sync_layer' has no async counterpart for async mode "
1273 . "'$mode': it does not define async_layer_class and no convention "
1274 . "sibling '$candidate' could be found. Either declare the layer "
1275 . "deliberately sync-only -- sub async_layer_class { undef } in "
1276 . "$sync_layer -- or ship the async mirror as '$candidate'. "
1277 . "(ADR 0032)"
1278 ) unless $self->_try_load_async_class($candidate, 'async layer');
1279 21 $async_layer = $candidate;
1280 }
1281  
1282 23 ▶ push @async_layers, $async_layer if defined $async_layer;
Branch: 1 branch
BranchTrueFalseTotal
if defined $async_layer 23 0 23
1283 }
1284  
1285 416 ▶ if (@async_layers) {
Branch: 1 branch
BranchTrueFalseTotal
if (@async_layers) 22 394 416
1286 # Capability gate: an async layer may only compose over a transport that
1287 # provides every capability it declares as required. A shortfall croaks
1288 # naming the layer, the missing capabilities and the transport -- a
1289 # transport gap becomes that transport's ticket, never a silent feature loss.
1290 #
1291 # The gate used to protect by DECLARATION, not by SEAM. A layer
1292 # that declared a requirement and did not find it was stopped, but a layer
1293 # that declared NOTHING composed onto any transport without a word --
1294 # including one that offers no query seam to wrap, where the layer would
1295 # load, compose and then quietly do nothing (the very silent feature loss
1296 # ADR 0032 section 5 exists to prevent). So a missing declaration is now
1297 # read as "needs the DEFAULT SEAM": the layer is taken to require
1298 # _query_async, and a transport that does not own the query path refuses
1299 # it. "Says nothing" is thus the safe case, not the unchecked one, and the
1300 # hole closes for every transport rather than only for the forked one.
1301 #
1302 # A transport OFFERS the seam iff it actually overrides the abstract
1303 # _query_async stub on DBIO::Storage::Async. Model A backends (DBIO::Forked)
1304 # override the six *_async entry points directly and run the driver's
1305 # ordinary sync CRUD elsewhere, so they inherit the stub and have no seam.
1306 22 my %have = map { $_ => 1 } $backend_class->transport_capabilities;
1307 22 my $abstract_seam = DBIO::Storage::Async->can('_query_async');
1308 22 my $backend_seam = $backend_class->can('_query_async');
1309 22 ▶ my $has_seam = $backend_seam
Condition66%4/6
$backend_seam && (!$abstract_seam || $backend_seam != $abstract_seam)
!ll&&!rl&&r
0517
not $abstract_seam or $backend_seam != $abstract_seam
l!l&&r!l&&!r
0175
MC/DC33%1/3
$backend_seam && (!$abstract_seam || $backend_seam != $abstract_seam)
$backend_seam not $abstract_seam $backend_seam != $abstract_seam
Truth table50%2/4
A && not(B) or C
A= $backend_seamB= not $abstract_seamC= $backend_seam != $abstract_seam
ABCresult
0XX0
1000
11X1
1011
1310 && (!$abstract_seam || $backend_seam != $abstract_seam);
1311  
1312 22 for my $async_layer (@async_layers) {
1313 22 ▶ if (!$async_layer->can('required_transport_capabilities')) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($async_layer->can("required_transport_capabilities")) 11 11 22
1314 11 ▶ next if $has_seam;
Branch: 1 branch
BranchTrueFalseTotal
if $has_seam 9 2 11
1315 2 $self->throw_exception(
1316 "async layer '$async_layer' declares no "
1317 . "required_transport_capabilities, so it is taken to require the "
1318 . "default async query seam '_query_async' -- and transport "
1319 . "'$backend_class' does not provide that seam (it does not override "
1320 . "DBIO::Storage::Async::_query_async, so it does not own the query "
1321 . "path a layer wraps; the layer would compose and then do nothing). "
1322 . "Give '$async_layer' a required_transport_capabilities method "
1323 . "declaring what it actually needs from a transport -- an explicit "
1324 . "empty list if it genuinely needs nothing beyond what any transport "
1325 . "gives -- or choose another async mode whose transport owns the "
1326 . "query path"
1327 );
1328 }
1329  
1330 # Names core reads itself never count as a layer capability, whatever
1331 # the transport declares (karr k268).
1332 11 my %core_read = map { $_ => 1 } DBIO::Storage::Async->_core_read_capabilities;
1333 11 my @required = $async_layer->required_transport_capabilities;
1334 11 my @core_asked = grep { $core_read{$_} } @required;
1335 11 ▶ if (@core_asked) {
Branch: 1 branch
BranchTrueFalseTotal
if (@core_asked) 3 8 11
1336 3 ▶ $self->throw_exception(
Branch: 1 branch
BranchTrueFalseTotal
@core_asked == 1 ? : 3 0 3
1337 "async layer '$async_layer' requires transport "
1338 . (@core_asked == 1 ? 'capability' : 'capabilities') . " '"
1339 . join("', '", @core_asked) . "' of transport '$backend_class', "
1340 . "which is read by core, not by layers: it describes how the "
1341 . "transport takes connect options, not a feature a layer can build "
1342 . "on -- drop it from required_transport_capabilities"
1343 );
1344 }
1345 8 my @missing = grep { !$have{$_} } @required;
1346 8 ▶ next unless @missing;
Branch: 1 branch
BranchTrueFalseTotal
unless @missing 5 3 8
1347 3 ▶ $self->throw_exception(
Branch: 1 branch
BranchTrueFalseTotal
@missing == 1 ? : 3 0 3
1348 "async layer '$async_layer' requires transport "
1349 . (@missing == 1 ? 'capability' : 'capabilities') . " '"
1350 . join("', '", @missing) . "' which transport '$backend_class' does not "
1351 . "provide -- upgrade the transport '$backend_class' (or its "
1352 . "distribution) or choose another async mode"
1353 );
1354 }
1355  
1356 $backend_class =
1357 14 DBIO::Storage::Composed->compose($backend_class, \@async_layers);
1358 }
1359  
1360 # The backend is handed this storage's connect info as given, as with a DSN
1361 # -- except beside a broker (ADR 0030 addenda, karr k240/k243). Most of what
1362 # may stand there is this owner's to apply (the mode, storage options,
1363 # SQL maker options); pooled connections get the connection actions from
1364 # the owner (ADR 0049). So the backend gets the broker alone -- the form
1365 # every backend takes a broker in -- unless the hash holds settings a
1366 # backend applies itself (DBD attributes, pool_size). Those go only to a
1367 # transport that declares it takes them; any other would open every pooled
1368 # connection without them while this one has them, so that throws.
1369 408 my $connect_info = $self->_connect_info;
1370 408 ▶ if ($self->_is_access_broker_connect_info($connect_info)) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->_is_access_broker_connect_info($connect_info)) 34 374 408
1371 # A broker detached from this storage (clear_access_broker) opens nothing
1372 # any more (karr k266) -- not through a backend built only now either,
1373 # which would attach it again and ask it (karr k293).
1374 34 ▶ $self->throw_exception(
Branch: 1 branch
BranchTrueFalseTotal
unless $self->access_broker 3 31 34
1375 "async mode '$mode': the AccessBroker this storage was connected "
1376 . 'through has been detached, so there is nothing to connect an async '
1377 . 'backend from. Give the storage connect info again.'
1378 ) unless $self->access_broker;
1379  
1380 31 ▶ if (my @for_backend = $self->_access_broker_backend_settings($connect_info)) {
Branch: 1 branch
BranchTrueFalseTotal
if (my(@for_backend) = $self->_access_broker_backend_settings($connect_info)) { } 6 25 31
1381 6 ▶ $self->throw_exception(
Branch: 1 branch
BranchTrueFalseTotal
unless $transport_class->_takes_broker_connect_options 1 5 6
1382 "async mode '$mode': transport $transport_class does not take "
1383 . 'connection settings beside an AccessBroker (it does not declare '
1384 . "'broker_connect_options' among its transport_capabilities), so "
1385 . join(', ', @for_backend) . ' would reach this connection but none of '
1386 . 'its pooled ones. Leave them out for this mode, or use a transport '
1387 . 'that declares it.'
1388 ) unless $transport_class->_takes_broker_connect_options;
1389 }
1390 else {
1391 # The async options beside the broker (acquire_timeout, ...) are the
1392 # backend's own, with no transport capability to declare (karr k397).
1393 25 my $async_options = $self->_access_broker_async_options($connect_info);
1394 25 ▶ $connect_info = %$async_options
Branch: 1 branch
BranchTrueFalseTotal
%$async_options ? : 1 24 25
1395 ? [ $connect_info->[0], $async_options ]
1396 : [ $connect_info->[0] ];
1397 }
1398 }
1399  
1400 # Build the embedded backend -- the mechanism introduced by the withdrawn
1401 # ADR 0028 and kept by ADR 0030, which moved only the CHOICE of backend from
1402 # a per-class default to the connect call: ->new($schema) fed this storage's
1403 # DBI-form connect_info.
1404 404 my $async = $backend_class->new($self->schema);
1405 404 $async->connect_info($connect_info);
1406  
1407 # Give the async backend a weak back-reference to THIS owning sync
1408 # storage, so its pool can resolve on_connect_call/on_connect_do (and their
1409 # connect_call_* methods) on the class that actually defines them, and replay
1410 # them against each freshly-spawned pool connection. Mirror this backend's
1411 # current generation token onto that concrete owner; composed storage classes
1412 # do not alter the owning object.
1413 395 ▶ $async->_owner_storage($self) if $async->can('_owner_storage');
Branch: 1 branch
BranchTrueFalseTotal
if $async->can("_owner_storage") 395 0 395
1414 395 $self->_async_context_owner_token($async->_context_owner_token);
1415  
1416 395 return $self->{_async_storage_obj} = $async;
1417 }
1418  
1419  
1420 107 ▶sub async {
Subroutine async: called CC=1 SCAR=0.0
Pod documented
1421 107 my $self = shift;
1422 107 return $self->_async_storage;
1423 }
1424  
1425  
1426 102 ▶sub disconnect {
Subroutine disconnect: called CC=6 SCAR=18.1
Pod documented
1427  
1428 102 ▶ if( my $dbh = $_[0]->_dbh ) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $dbh = $_[0]->_dbh) 102 0 102
1429  
1430 102 ▶ $_[0]->_do_connection_actions(disconnect_call_ => $_) for (
Condition66%2/3
$_[0]->on_disconnect_call || ()
l!l&&r!l&&!r
01191
MC/DC50%1/2
$_[0]->on_disconnect_call || ()
$_[0]->on_disconnect_call ()
Truth table66%2/3
A || B
A= $_[0]->on_disconnect_callB= ()
ABresult
1X1
011
000
1431 ( $_[0]->on_disconnect_call || () ),
1432 $_[0]->_parse_connect_do ('on_disconnect_do')
1433 );
1434  
1435 # stops the "implicit rollback on disconnect" warning
1436 102 ▶ $_[0]->_exec_txn_rollback unless $_[0]->_dbh_autocommit;
Branch: 1 branch
BranchTrueFalseTotal
unless $_[0]->_dbh_autocommit 0 102 102
1437  
1438 102 %{ $dbh->{CachedKids} } = ();
1439 102 $dbh->disconnect;
1440 102 $_[0]->_dbh(undef);
1441 102 $_[0]->deferred_rollback(undef);
1442 }
1443  
1444 # Tear down the embedded async backend, if one was built. Outside the _dbh
1445 # guard so it runs even when no sync dbh was ever opened. Reset ownership
1446 # before deleting the cache; the old backend's disconnect rotates its own
1447 # token, but may not re-adopt it after this storage has detached that backend.
1448 102 $_[0]->_reset_async_context_owner_token;
1449 102 ▶ if (my $async = delete $_[0]->{_async_storage_obj}) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $async = delete $_[0]{"_async_storage_obj"}) 8 94 102
1450 8 $async->disconnect;
1451 }
1452 }
1453  
1454  
1455 # Storage subclasses should override this
1456 sub with_deferred_fk_checks {
1457 #my ($self, $sub) = @_;
1458 $_[1]->();
1459 }
1460  
1461  
1462 158 ▶sub connected {
Subroutine connected: called CC=2 SCAR=6.9
Pod documented
1463 158 ▶ return 0 unless $_[0]->_seems_connected;
Branch: 1 branch
BranchTrueFalseTotal
unless $_[0]->_seems_connected 123 35 158
1464  
1465 #be on the safe side
1466 35 local $_[0]->_dbh->{RaiseError} = 1;
1467  
1468 35 return $_[0]->_ping;
1469 }
1470  
1471 167 ▶sub _seems_connected {
Subroutine _seems_connected: called CC=3 SCAR=11.1
1472 167 ▶ $_[0]->_verify_pid unless is_windows();
Branch: 1 branch
BranchTrueFalseTotal
unless &is_windows() 167 0 167
1473  
1474 167 ▶ ($_[0]->_dbh || return 0)->FETCH('Active');
Condition100%2/2
$_[0]->_dbh || (return 0)
l!l
52115
MC/DC100%1/1
$_[0]->_dbh || (return 0)
$_[0]->_dbh
Truth table100%2/2
A
A= $_[0]->_dbh
Aresult
11
00
1475 }
1476  
1477 35 ▶sub _ping {
Subroutine _ping: called CC=2 SCAR=7.6
1478 35 ▶ ($_[0]->_dbh || return 0)->ping;
Condition50%1/2
$_[0]->_dbh || (return 0)
l!l
350
MC/DC0%0/1
$_[0]->_dbh || (return 0)
$_[0]->_dbh
Truth table50%1/2
A
A= $_[0]->_dbh
Aresult
11
00
1479 }
1480  
1481 133 ▶sub ensure_connected {
Subroutine ensure_connected: called CC=3 SCAR=11.0
Pod documented
1482 133 ▶ $_[0]->connected || ( $_[0]->_populate_dbh && 1 );
Branch: 1 branch
BranchTrueFalseTotal
$_[0]->connected or $_[0]->_populate_dbh and 1 27 106 133
Condition80%4/5
$_[0]->connected || $_[0]->_populate_dbh && 1
l!l&&r!l&&!r
271060
$_[0]->_populate_dbh and 1
!ll
232
MC/DC0%0/2
$_[0]->connected || $_[0]->_populate_dbh && 1
$_[0]->connected $_[0]->_populate_dbh
Truth table66%2/3
A || B
A= $_[0]->connectedB= $_[0]->_populate_dbh
ABresult
1X1
011
000
1483 }
1484  
1485  
1486 146 ▶sub dbh {
Subroutine dbh: called CC=3 SCAR=11.1
Pod documented
1487 # maybe save a ping call
1488 146 ▶ $_[0]->_dbh
Branch: 1 branch
BranchTrueFalseTotal
$_[0]->_dbh ? : 28 118 146
Condition66%2/3
$_[0]->ensure_connected and $_[0]->_dbh
!ll&&!rl&&r
0235
MC/DC0%0/2
$_[0]->ensure_connected and $_[0]->_dbh
$_[0]->ensure_connected $_[0]->_dbh
Truth table33%1/3
A and B
A= $_[0]->ensure_connectedB= $_[0]->_dbh
ABresult
0X0
100
111
1489 ? ( $_[0]->ensure_connected and $_[0]->_dbh )
1490 : $_[0]->_populate_dbh
1491 ;
1492 }
1493  
1494 # this is the internal "get dbh or connect (don't check)" method
1495 191 ▶sub _get_dbh {
Subroutine _get_dbh: called CC=3 SCAR=11.1
1496 191 ▶ $_[0]->_verify_pid unless is_windows();
Branch: 1 branch
BranchTrueFalseTotal
unless &is_windows() 191 0 191
1497 191 ▶ $_[0]->_dbh || $_[0]->_populate_dbh;
Branch: 1 branch
BranchTrueFalseTotal
$_[0]->_dbh or $_[0]->_populate_dbh 75 116 191
1498 }
1499  
1500 # *DELIBERATELY* not a setter (for the time being)
1501 # Too intertwined with everything else for any kind of sanity
1502 17811 ▶sub sql_maker {
Subroutine sql_maker: called CC=12 SCAR=24.9
1503 17811 my $self = shift;
1504  
1505 16394 ▶ $self->throw_exception('sql_maker() is not a setter method') if @_;
Branch: 1 branch
BranchTrueFalseTotal
if @_ 2503 24499 27002
1506  
1507 16394 ▶ unless ($self->_sql_maker) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($self->_sql_maker) 719 13871 14590
1508 4065 my $sql_maker_class = $self->sql_maker_class;
1509  
1510 4873 ▶ my %opts = %{$self->_sql_maker_opts||{}};
Condition66%2/3
$self->_sql_maker_opts || {}
l!l
679550
MC/DC100%1/1
$self->_sql_maker_opts || {}
$self->_sql_maker_opts
Truth table100%2/2
A
A= $self->_sql_maker_opts
Aresult
11
00
1511  
1512 3941 my ($quote_char, $name_sep);
1513  
1514 # Identifier quoting defaults to ON (security hardening, Codeberg
1515 # dbio/dbio#2). Quote unless the user explicitly passed a false
1516 # quote_names in their connect_info.
1517 3941 ▶ if (!exists $opts{quote_names} || $opts{quote_names}) {
Branch: 1 branch
BranchTrueFalseTotal
if (not exists $opts{"quote_names"} or $opts{"quote_names"}) 3027 54 3081
Condition100%3/3
not exists $opts{"quote_names"} or $opts{"quote_names"}
l!l&&r!l&&!r
66323671
MC/DC50%1/2
not exists $opts{"quote_names"} or $opts{"quote_names"}
not exists $opts{"quote_names"} $opts{"quote_names"}
Truth table66%2/3
not(A) or B
A= not exists $opts{"quote_names"}B= $opts{"quote_names"}
ABresult
1X1
011
000
1518 # An explicitly supplied quote_char is always respected, including an
1519 # empty string (which means "no quoting" and must win over the class
1520 # default) -- hence exists(), not truthiness.
1521 $quote_char = exists $opts{quote_char}
1522 ? delete $opts{quote_char}
1523 14556 ▶ : $self->sql_quote_char || do {
Branch: 1 branch
BranchTrueFalseTotal
exists $opts{'quote_char'} ? : 3710 10844 14554
Condition66%2/3
$self->sql_quote_char or do { my $s_class = ref $self || $self; carp_unique(qq[You requested 'quote_names' but your storage class ($s_class) does\nnot explicitly define a default sql_quote_char and you have not\nsupplied a quote_char as part of your connection_info. DBIO will\ndefault to the ANSI SQL standard quote '"', which works most of\nthe time. Please file a Codeberg issue against '${s_class}' at\nhttps://codeberg.org/dbio/dbio/issues\n]); "\"" }
l!l&&r!l&&!r
25820901
MC/DC0%0/2
$self->sql_quote_char or do { my $s_class = ref $self || $self; carp_unique(qq[You requested 'quote_names' but your storage class ($s_class) does\nnot explicitly define a default sql_quote_char and you have not\nsupplied a quote_char as part of your connection_info. DBIO will\ndefault to the ANSI SQL standard quote '"', which works most of\nthe time. Please file a Codeberg issue against '${s_class}' at\nhttps://codeberg.org/dbio/dbio/issues\n]); "\"" }
$self->sql_quote_char do { my $s_class = ref $self || $self; carp_unique(qq[You requested 'quote_names' but your storage class ($s_class) does\nnot explicitly define a default sql_quote_char and you have not\nsupplied a quote_char as part of your connection_info. DBIO will\ndefault to the ANSI SQL standard quote '"', which works most of\nthe time. Please file a Codeberg issue against '${s_class}' at\nhttps://codeberg.org/dbio/dbio/issues\n]); "\"" }
Truth table33%1/3
A or B
A= $self->sql_quote_charB= do { my $s_class = ref $self || $self; carp_unique(qq[You requested 'quote_names' but your storage class ($s_class) does\nnot explicitly define a default sql_quote_char and you have not\nsupplied a quote_char as part of your connection_info. DBIO will\ndefault to the ANSI SQL standard quote '"', which works most of\nthe time. Please file a Codeberg issue against '${s_class}' at\nhttps://codeberg.org/dbio/dbio/issues\n]); "\"" }
ABresult
1X1
011
000
1524 2416 ▶ my $s_class = (ref $self) || $self;
Condition66%2/3
ref $self || $self
l!l&&r!l&&!r
90330
MC/DC0%0/2
ref $self || $self
ref $self $self
Truth table66%2/3
A || B
A= ref $selfB= $self
ABresult
1X1
011
000
1525 2414 carp_unique (<<"__EOW__");
1526 You requested 'quote_names' but your storage class ($s_class) does
1527 not explicitly define a default sql_quote_char and you have not
1528 supplied a quote_char as part of your connection_info. DBIO will
1529 default to the ANSI SQL standard quote '"', which works most of
1530 the time. Please file a Codeberg issue against '$s_class' at
1531 https://codeberg.org/dbio/dbio/issues
1532 __EOW__
1533  
1534 13894 '"'; # RV
1535 };
1536  
1537 3924 ▶ $name_sep = (delete $opts{name_sep}) || $self->sql_name_sep;
Condition66%2/3
delete $opts{'name_sep'} || $self->sql_name_sep
l!l&&r!l&&!r
45411080
MC/DC0%0/2
delete $opts{'name_sep'} || $self->sql_name_sep
delete $opts{'name_sep'} $self->sql_name_sep
Truth table66%2/3
A || B
A= delete $opts{'name_sep'}B= $self->sql_name_sep
ABresult
1X1
011
000
1538 }
1539  
1540 14553 ▶ $self->_sql_maker($sql_maker_class->new(
Branch: 1 branch
BranchTrueFalseTotal
$quote_char ? : 1561 2365 3926
Condition100%3/3
$name_sep || '.'
l!l
7279117263
MC/DC100%1/1
$name_sep || '.'
$name_sep
Truth table100%2/2
A
A= $name_sep
Aresult
11
00
1541 bindtype=>'columns',
1542 array_datatypes => 1,
1543 ($quote_char ? (quote_char => $quote_char) : ()),
1544 name_sep => ($name_sep || '.'),
1545 %opts,
1546 ));
1547 }
1548 18698 return $self->_sql_maker;
1549 }
1550  
1551 # nothing to do by default
1552 119 ▶sub _init {}
Subroutine _init: called CC=1 SCAR=0.0
1553  
1554 347 ▶sub _populate_dbh {
Subroutine _populate_dbh: called CC=4 SCAR=13.9
1555  
1556 347 $_[0]->_dbh(undef); # in case ->connected failed we might get sent here
1557  
1558 347 $_[0]->_dbh_details({}); # reset everything we know
1559  
1560 # FIXME - this needs reenabling with the proper "no reset on same DSN" check
1561 #$_[0]->_sql_maker(undef); # this may also end up being different
1562  
1563 347 $_[0]->_dbh($_[0]->_connect);
1564  
1565 165 ▶ $_[0]->_conn_pid($$) unless is_windows(); # on win32 these are in fact threads
Branch: 1 branch
BranchTrueFalseTotal
unless &is_windows() 165 0 165
1566  
1567 # A driver determination that throws takes the handle with it: no connection
1568 # action has run on it, and connected() would take the storage for usable.
1569 # The rule of _do_connection_actions, without its exception for a pool
1570 # connection -- this handle is the one opened above. Only the handle goes:
1571 # the transaction depth is not set yet, _conn_pid means nothing without a
1572 # handle, and the next connect resets _dbh_details. A guard and not a catch,
1573 # so that the error passes as it was thrown (karr k312).
1574 {
1575 165 my ($self, $determined) = $_[0];
1576 165 ▶ my $guard = scope_guard { $self->_dbh(undef) unless $determined };
Subroutine __ANON__: called CC=2 SCAR=6.9
Branch: 1 branch
BranchTrueFalseTotal
unless $determined 73 92 165
1577 165 $self->_determine_driver;
1578 92 $determined = 1;
1579 }
1580  
1581 # Always set the transaction depth on connect, since
1582 # there is no transaction in progress by definition
1583 92 ▶ $_[0]->{transaction_depth} = $_[0]->_dbh_autocommit ? 0 : 1;
Branch: 1 branch
BranchTrueFalseTotal
$_[0]->_dbh_autocommit ? : 92 0 92
1584 92 $_[0]->deferred_rollback(undef);
1585  
1586 92 ▶ $_[0]->_run_connection_actions unless $_[0]->{_in_determine_driver};
Branch: 1 branch
BranchTrueFalseTotal
unless $_[0]{"_in_determine_driver"} 81 11 92
1587  
1588 89 $_[0]->_dbh;
1589 }
1590  
1591 # The connect key 'schema' (ADR 0065): the namespace this connection works in.
1592 # Core owns the word, the plain-name contract and the refusal; the meaning is
1593 # the driver's, given by overriding _set_connection_schema.
1594 27 ▶sub _assert_connection_schema_name {
Subroutine _assert_connection_schema_name: called CC=6 SCAR=17.9
1595 27 my ($self, $value) = @_;
1596  
1597 27 ▶ DBIO::Exception->throw(
Branch: 3 branches
BranchTrueFalseTotal
unless defined $value and not ref $value and length $value 4 23 27
!defined($value) ? : 1 3 4
ref $value ? : 2 1 3
Condition100%6/6
defined $value and not ref $value and length $value
!ll&&!rl&&r
3123
defined $value and not ref $value
!ll&&!rl&&r
1224
MC/DC100%3/3
defined $value and not ref $value and length $value
defined $value not ref $value length $value
Truth table100%4/4
A and not(B) and C
A= defined $valueB= not ref $valueC= length $value
ABCresult
0XX0
10X0
1100
1111
1598 "The connect key 'schema' takes a single non-empty name (the namespace "
1599 . 'this connection works in), not '
1600 . (!defined $value ? 'undef' : ref $value ? 'a ' . ref($value) . ' reference' : 'an empty string')
1601 ) unless defined $value and !ref $value and length $value;
1602  
1603 # an identifier (ADR 0077): ';', a line break and NUL would end the driver's
1604 # statement; the rest (quote, blank, backslash) the driver quotes or refuses
1605 23 DBIO::Util::assert_identifier_text("The connect key 'schema'", $value);
1606  
1607 19 return $value;
1608 }
1609  
1610 # Driver seam: make $name the namespace of the connection being set up. Runs
1611 # on every new connection, sync (_run_connection_actions) and async pool
1612 # (_run_pool_connect_actions), before the user's on_connect_call/on_connect_do,
1613 # only when the connect info gave 'schema'. Issue the statement(s) through
1614 # _do_query, which lands on the right connection in both places. A storage
1615 # whose driver has no namespaces keeps this default and refuses.
1616 # $name is an identifier (ADR 0077): write it only through the driver's
1617 # identifier quoting (or a bind), or refuse it with a DBIO::Exception.
1618 2 ▶sub _set_connection_schema {
Subroutine _set_connection_schema: called CC=1 SCAR=0.0
1619 2 my ($self, $name) = @_;
1620  
1621 2 DBIO::Exception->throw(
1622 ref($self) . " has no namespaces: the connect key 'schema' (given '$name') "
1623 . 'has no meaning for this driver. Remove it from the connect info, or use a '
1624 . 'driver that gives it one.'
1625 );
1626 }
1627  
1628 # Driver seam (ADR 0066): what the declared database extensions want of a new
1629 # connection, as data -- { load => [ ... ], search_path => [ ... ] } -- or
1630 # undef for none (the default). Asked with the connection's namespace, which
1631 # may be undef. The driver resolves its extension list here.
1632 135 ▶sub _extension_activation { undef }
Subroutine _extension_activation: called CC=1 SCAR=0.0
1633  
1634 # Driver seam (ADR 0066): write the activation the driver got from
1635 # _extension_activation as the dialect's statements (PostgreSQL: LOAD, and,
1636 # when $name is undef, appending to the search_path; with a namespace the
1637 # search_path is _set_connection_schema's). Only called with an activation.
1638 # Issue statements through _do_query. The default does nothing.
1639 1 ▶sub _activate_extensions { $_[0] }
Subroutine _activate_extensions: called CC=1 SCAR=0.0
1640  
1641 145 ▶sub _apply_connection_schema {
Subroutine _apply_connection_schema: called CC=3 SCAR=11.0
1642 145 my $self = shift;
1643 145 my $name = $self->connection_schema;
1644  
1645 145 my $activation = $self->_extension_activation($name);
1646 145 ▶ $self->_activate_extensions($activation, $name) if $activation;
Branch: 1 branch
BranchTrueFalseTotal
if $activation 9 136 145
1647 145 ▶ $self->_set_connection_schema($name, $activation) if defined $name;
Branch: 1 branch
BranchTrueFalseTotal
if defined $name 10 135 145
1648  
1649 143 return $self;
1650 }
1651  
1652 105 ▶sub _run_connection_actions {
Subroutine _run_connection_actions: called CC=11 SCAR=35.1
1653 # there are pathological cases in the CI where this can loop
1654 # did not investigae in depth, but in either case this makes
1655 # sense to guard like this
1656 105 ▶ return if $_[0]->{_running_connections_actions};
Branch: 1 branch
BranchTrueFalseTotal
if $_[0]{"_running_connections_actions"} 0 105 105
1657  
1658 105 local $_[0]->{_running_connections_actions} = 1;
1659  
1660 105 $_[0]->_apply_connection_schema;
1661  
1662 103 ▶ $_[0]->_do_connection_actions(connect_call_ => $_) for (
Condition100%3/3
$_[0]->on_connect_call || ()
l!l&&r!l&&!r
501538
MC/DC100%2/2
$_[0]->on_connect_call || ()
$_[0]->on_connect_call ()
Truth table100%3/3
A || B
A= $_[0]->on_connect_callB= ()
ABresult
1X1
011
000
1663 ( $_[0]->on_connect_call || () ),
1664 $_[0]->_parse_connect_do ('on_connect_do'),
1665 );
1666  
1667 96 my $sqlac_like;
1668 96 ▶ if(
Branch: 1 branch
BranchTrueFalseTotal
if (&is_dev_release() and $ENV{"DBIODEVREL_SWAPOUT_SQLAC_WITH"} || $ENV{"DBICDEVREL_SWAPOUT_SQLAC_WITH"} and ($sqlac_like) = ($ENV{"DBIODEVREL_SWAPOUT_SQLAC_WITH"} || $ENV{"DBICDEVREL_SWAPOUT_SQLAC_WITH"}) =~ /(.+)/ and "DBIO::Componentised"->ensure_class_loaded($sqlac_like), 1 and not ref($_[0]->sql_maker) =~ /__REBASED__/) 0 96 96
Condition22%4/18
&is_dev_release() and $ENV{"DBIODEVREL_SWAPOUT_SQLAC_WITH"} || $ENV{"DBICDEVREL_SWAPOUT_SQLAC_WITH"} and ($sqlac_like) = ($ENV{"DBIODEVREL_SWAPOUT_SQLAC_WITH"} || $ENV{"DBICDEVREL_SWAPOUT_SQLAC_WITH"}) =~ /(.+)/ and "DBIO::Componentised"->ensure_class_loaded($sqlac_like), 1 and not ref($_[0]->sql_maker) =~ /__REBASED__/
!ll&&!rl&&r
9600
&is_dev_release() and $ENV{"DBIODEVREL_SWAPOUT_SQLAC_WITH"} || $ENV{"DBICDEVREL_SWAPOUT_SQLAC_WITH"} and ($sqlac_like) = ($ENV{"DBIODEVREL_SWAPOUT_SQLAC_WITH"} || $ENV{"DBICDEVREL_SWAPOUT_SQLAC_WITH"}) =~ /(.+)/ and "DBIO::Componentised"->ensure_class_loaded($sqlac_like), 1
!ll&&!rl&&r
9600
&is_dev_release() and $ENV{"DBIODEVREL_SWAPOUT_SQLAC_WITH"} || $ENV{"DBICDEVREL_SWAPOUT_SQLAC_WITH"} and ($sqlac_like) = ($ENV{"DBIODEVREL_SWAPOUT_SQLAC_WITH"} || $ENV{"DBICDEVREL_SWAPOUT_SQLAC_WITH"}) =~ /(.+)/
!ll&&!rl&&r
9600
&is_dev_release() and $ENV{"DBIODEVREL_SWAPOUT_SQLAC_WITH"} || $ENV{"DBICDEVREL_SWAPOUT_SQLAC_WITH"}
!ll&&!rl&&r
9600
$ENV{"DBIODEVREL_SWAPOUT_SQLAC_WITH"} or $ENV{"DBICDEVREL_SWAPOUT_SQLAC_WITH"}
l!l&&r!l&&!r
000
$ENV{'DBIODEVREL_SWAPOUT_SQLAC_WITH'} || $ENV{'DBICDEVREL_SWAPOUT_SQLAC_WITH'}
l!l&&r!l&&!r
000
MC/DC0%0/6
&is_dev_release() and $ENV{"DBIODEVREL_SWAPOUT_SQLAC_WITH"} || $ENV{"DBICDEVREL_SWAPOUT_SQLAC_WITH"} and ($sqlac_like) = ($ENV{"DBIODEVREL_SWAPOUT_SQLAC_WITH"} || $ENV{"DBICDEVREL_SWAPOUT_SQLAC_WITH"}) =~ /(.+)/ and "DBIO::Componentised"->ensure_class_loaded($sqlac_like), 1 and not ref($_[0]->sql_maker) =~ /__REBASED__/
&is_dev_release() $ENV{"DBIODEVREL_SWAPOUT_SQLAC_WITH"} $ENV{"DBICDEVREL_SWAPOUT_SQLAC_WITH"} ($sqlac_like) = ($ENV{"DBIODEVREL_SWAPOUT_SQLAC_WITH"} || $ENV{"DBICDEVREL_SWAPOUT_SQLAC_WITH"}) =~ /(.+)/ "DBIO::Componentised"->ensure_class_loaded($sqlac_like), 1 not ref($_[0]->sql_maker) =~ /__REBASED__/
MC/DC0%0/2
$ENV{'DBIODEVREL_SWAPOUT_SQLAC_WITH'} || $ENV{'DBICDEVREL_SWAPOUT_SQLAC_WITH'}
$ENV{'DBIODEVREL_SWAPOUT_SQLAC_WITH'} $ENV{'DBICDEVREL_SWAPOUT_SQLAC_WITH'}
Truth table10%1/10
A and B or C and D and E and not(F)
A= &is_dev_release()B= $ENV{"DBIODEVREL_SWAPOUT_SQLAC_WITH"}C= $ENV{"DBICDEVREL_SWAPOUT_SQLAC_WITH"}D= ($sqlac_like) = ($ENV{"DBIODEVREL_SWAPOUT_SQLAC_WITH"} || $ENV{"DBICDEVREL_SWAPOUT_SQLAC_WITH"}) =~ /(.+)/E= "DBIO::Componentised"->ensure_class_loaded($sqlac_like), 1F= not ref($_[0]->sql_maker) =~ /__REBASED__/
ABCDEFresult
0XXXXX0
100XXX0
11X0XX0
1010XX0
11X10X0
10110X0
11X1100
1011100
11X1111
1011111
Truth table0%0/3
A || B
A= $ENV{'DBIODEVREL_SWAPOUT_SQLAC_WITH'}B= $ENV{'DBICDEVREL_SWAPOUT_SQLAC_WITH'}
ABresult
1X1
011
000
1669 is_dev_release
1670 and
1671 ($ENV{DBIODEVREL_SWAPOUT_SQLAC_WITH} || $ENV{DBICDEVREL_SWAPOUT_SQLAC_WITH})
1672 and
1673 ( $sqlac_like ) = ($ENV{DBIODEVREL_SWAPOUT_SQLAC_WITH} || $ENV{DBICDEVREL_SWAPOUT_SQLAC_WITH}) =~ /(.+)/
1674 and
1675 # delay calling ->sql_maker as long as we can
1676 # ensure_class_loaded returns undef or throws
1677 ( DBIO::Componentised->ensure_class_loaded( $sqlac_like ), 1 )
1678 and
1679 ( ref $_[0]->sql_maker ) !~ /__REBASED__/
1680 ) {
1681  
1682 0 require DBIO::SQLMaker::ClassicExtensions;
1683 0 require SQL::Abstract;
1684  
1685 0 Class::C3::Componentised->inject_base(
1686 'DBICDevRel::SQLAC::SwapOut',
1687 'DBIO::SQLMaker::ClassicExtensions',
1688 $sqlac_like,
1689 'SQL::Abstract',
1690 );
1691  
1692 0 $_[0]->_do_connection_actions(connect_call_ => [[ rebase_sqlmaker => 'DBICDevRel::SQLAC::SwapOut' ]]);
1693 }
1694 }
1695  
1696 # Replay THIS storage's configured on_connect actions against a freshly
1697 # spawned async pool connection. Called from the embedded async backend's
1698 # _setup_pool_connection with $runner, a coderef that runs one statement on the
1699 # pool connection. We reuse the exact sync dispatch (_do_connection_actions +
1700 # _parse_connect_do, in the same order _run_connection_actions uses) so that
1701 # connect_call_* resolve on this (owning) storage identically to sync -- but the
1702 # statements they emit via _do_query are redirected onto the pool connection by
1703 # localising _pool_connect_runner (honoured in _do_query). This is the
1704 # convention-friendly dispatch: resolve on the sync storage, execute against
1705 # the pool handle.
1706 44 ▶sub _run_pool_connect_actions {
Subroutine _run_pool_connect_actions: called CC=3 SCAR=11.0
1707 44 my ($self, $runner) = @_;
1708  
1709 44 local $self->{_pool_connect_runner} = $runner;
1710  
1711 44 $self->_apply_connection_schema;
1712  
1713 44 ▶ $self->_do_connection_actions(connect_call_ => $_) for (
Condition100%3/3
$self->on_connect_call || ()
l!l&&r!l&&!r
72215
MC/DC100%2/2
$self->on_connect_call || ()
$self->on_connect_call ()
Truth table100%3/3
A || B
A= $self->on_connect_callB= ()
ABresult
1X1
011
000
1714 ( $self->on_connect_call || () ),
1715 $self->_parse_connect_do('on_connect_do'),
1716 );
1717  
1718 38 return $self;
1719 }
1720  
1721 # The rows of a query for a connect_call_*: inside the pool replay
1722 # (_pool_connect_runner set) the runner reads them from the pool connection,
1723 # else they come from this storage's own handle, so one connect_call_* asks the
1724 # same question on both paths. Returns an arrayref of row arrayrefs.
1725 4 ▶sub _pool_connect_rows {
Subroutine _pool_connect_rows: called CC=1 SCAR=0.8
1726 4 my ($self, $sql, @bind) = @_;
1727  
1728 4 local $self->{_statement_in_flight} = $sql;
1729 4 local $self->{_values_in_flight} = \@bind;
1730  
1731 4 ▶ my $rows = try {
Subroutine __ANON__: called CC=2 SCAR=6.9
1732 4 ▶ if (my $runner = $self->{_pool_connect_runner}) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $runner = $self->{'_pool_connect_runner'}) { } 2 2 4
1733 2 $runner->($sql, { dbio_rows => 1 }, @bind);
1734 }
1735 else {
1736 2 ▶ $self->dbh_do(sub { $_[1]->selectall_arrayref($sql, undef, @bind) });
Subroutine __ANON__: called CC=1 SCAR=0.0
1737 }
1738 }
1739 1 ▶ catch {
Subroutine __ANON__: called CC=6 SCAR=28.6
1740 1 my $err = $_;
1741 1 my $values = _plain_error_values(@bind);
1742 1 ▶ if (!ref $err) {
Branch: 2 branches
BranchTrueFalseTotal
if (not ref $err) { } 1 0 1
elsif (builtin::blessed($err) and $err->isa('DBIO::Exception') and defined $err->{'msg'} and not ref $err->{'msg'}) { } 0 0 0
1743 1 $err = $self->_mask_error_values(mask_statement_secrets($err, $sql), $values, $sql);
1744 }
1745 ▶ elsif (blessed $err and $err->isa('DBIO::Exception') and defined $err->{msg} and !ref $err->{msg}) {
Condition0%0/9
builtin::blessed($err) and $err->isa("DBIO::Exception") and defined $err->{"msg"} and not ref $err->{"msg"}
!ll&&!rl&&r
000
builtin::blessed($err) and $err->isa("DBIO::Exception") and defined $err->{"msg"}
!ll&&!rl&&r
000
builtin::blessed($err) and $err->isa("DBIO::Exception")
!ll&&!rl&&r
000
MC/DC0%0/4
builtin::blessed($err) and $err->isa("DBIO::Exception") and defined $err->{"msg"} and not ref $err->{"msg"}
builtin::blessed($err) $err->isa("DBIO::Exception") defined $err->{"msg"} not ref $err->{"msg"}
Truth table0%0/5
A and B and C and not(D)
A= builtin::blessed($err)B= $err->isa("DBIO::Exception")C= defined $err->{"msg"}D= not ref $err->{"msg"}
ABCDresult
0XXX0
10XX0
110X0
11100
11111
1746 0 $err->{msg} = $self->_mask_error_values(mask_statement_secrets($err->{msg}, $sql), $values, $sql);
1747 }
1748 1 die $err;
1749 4 };
1750  
1751 3 return $rows;
1752 }
1753  
1754 # Symmetric counterpart for disconnect: same dispatch machinery, run against the
1755 # pool connection while it is still live (from the pool's shutdown path).
1756 20 ▶sub _run_pool_disconnect_actions {
Subroutine _run_pool_disconnect_actions: called CC=3 SCAR=11.0
1757 20 my ($self, $runner) = @_;
1758  
1759 20 local $self->{_pool_connect_runner} = $runner;
1760  
1761 20 ▶ $self->_do_connection_actions(disconnect_call_ => $_) for (
Condition100%3/3
$self->on_disconnect_call || ()
l!l&&r!l&&!r
1109
MC/DC100%2/2
$self->on_disconnect_call || ()
$self->on_disconnect_call ()
Truth table100%3/3
A || B
A= $self->on_disconnect_callB= ()
ABresult
1X1
011
000
1762 ( $self->on_disconnect_call || () ),
1763 $self->_parse_connect_do('on_disconnect_do'),
1764 );
1765  
1766 20 return $self;
1767 }
1768  
1769  
1770  
1771 sub _server_info {
1772 my $self = shift;
1773  
1774 my $info;
1775 unless ($info = $self->_dbh_details->{info}) {
1776  
1777 $info = {};
1778 # this guarantees that problematic conninfo won't be hidden
1779 # by the try{} below
1780 $self->ensure_connected;
1781  
1782 my $server_version = try {
1783 $self->_get_server_version
1784 } catch {
1785 # driver determination *may* use this codepath
1786 # in which case we must rethrow
1787 $self->throw_exception($_) if $self->{_in_determine_driver};
1788  
1789 # $server_version on failure
1790 undef;
1791 };
1792  
1793 if (defined $server_version) {
1794 $info->{dbms_version} = $server_version;
1795  
1796 my ($numeric_version) = $server_version =~ /^([\d\.]+)/;
1797 my @verparts = split (/\./, $numeric_version);
1798 if (
1799 @verparts
1800 &&
1801 $verparts[0] <= 999
1802 ) {
1803 # consider only up to 3 version parts, iff not more than 3 digits
1804 my @use_parts;
1805 while (@verparts && @use_parts < 3) {
1806 my $p = shift @verparts;
1807 last if $p > 999;
1808 push @use_parts, $p;
1809 }
1810 push @use_parts, 0 while @use_parts < 3;
1811  
1812 $info->{normalized_dbms_version} = sprintf "%d.%03d%03d", @use_parts;
1813 }
1814 }
1815  
1816 $self->_dbh_details->{info} = $info;
1817 }
1818  
1819 return $info;
1820 }
1821  
1822 sub _get_server_version {
1823 shift->_dbh_get_info('SQL_DBMS_VER');
1824 }
1825  
1826 84 ▶sub _dbh_get_info {
Subroutine _dbh_get_info: called CC=3 SCAR=11.2
1827 84 my ($self, $info) = @_;
1828  
1829 84 ▶ if ($info =~ /[^0-9]/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($info =~ /[^0-9]/) 84 0 84
1830 84 require DBI::Const::GetInfoType;
1831 84 $info = $DBI::Const::GetInfoType::GetInfoType{$info};
1832 84 ▶ $self->throw_exception("Info type '$_[1]' not provided by DBI::Const::GetInfoType")
Branch: 1 branch
BranchTrueFalseTotal
unless defined $info 0 84 84
1833 unless defined $info;
1834 }
1835  
1836 84 $self->_get_dbh->get_info($info);
1837 }
1838  
1839 4 ▶sub _describe_connection {
Subroutine _describe_connection: called CC=7 SCAR=19.5
1840 4 require DBI::Const::GetInfoReturn;
1841  
1842 4 my $self = shift;
1843  
1844 4 my $drv;
1845 4 ▶ try {
Subroutine __ANON__: called CC=1 SCAR=0.0
1846 4 $drv = $self->_extract_driver_from_connect_info;
1847 3 $self->ensure_connected;
1848 4 };
1849  
1850 4 ▶ $drv = "DBD::$drv" if $drv;
Branch: 1 branch
BranchTrueFalseTotal
if $drv 1 3 4
1851  
1852 4 my $info = $self->_dbi_connect_info;
1853  
1854 4 my $res = do {
1855 4 local $SIG{__WARN__} = sigwarn_silencer(qr/Argument .+? isn't numeric in subroutine entry/);
1856 {
1857 # never the password in it: this goes into a warning (karr k297)
1858 DBIO_DSN => mask_connect_secrets($info->[0], $info),
1859 DBI_VER => DBI->VERSION,
1860 DBIO_VER => DBIO->VERSION,
1861 DBIO_DRIVER => ref $self,
1862 $drv ? (
1863 DBD => $drv,
1864 1 ▶ DBD_VER => try { $drv->VERSION },
Subroutine __ANON__: called CC=1 SCAR=0.0
1865 4 ▶ ) : (),
Branch: 1 branch
BranchTrueFalseTotal
$drv ? : 1 3 4
1866 }
1867 };
1868  
1869 # try to grab data even if we never managed to connect
1870 # will cover us in cases of an oddly broken half-connect
1871 4 for my $inf (
1872 #keys %DBI::Const::GetInfoType::GetInfoType,
1873 qw/
1874 SQL_CURSOR_COMMIT_BEHAVIOR
1875 SQL_CURSOR_ROLLBACK_BEHAVIOR
1876 SQL_CURSOR_SENSITIVITY
1877 SQL_DATA_SOURCE_NAME
1878 SQL_DBMS_NAME
1879 SQL_DBMS_VER
1880 SQL_DEFAULT_TXN_ISOLATION
1881 SQL_DM_VER
1882 SQL_DRIVER_NAME
1883 SQL_DRIVER_ODBC_VER
1884 SQL_DRIVER_VER
1885 SQL_EXPRESSIONS_IN_ORDERBY
1886 SQL_GROUP_BY
1887 SQL_IDENTIFIER_CASE
1888 SQL_IDENTIFIER_QUOTE_CHAR
1889 SQL_MAX_CATALOG_NAME_LEN
1890 SQL_MAX_COLUMN_NAME_LEN
1891 SQL_MAX_IDENTIFIER_LEN
1892 SQL_MAX_TABLE_NAME_LEN
1893 SQL_MULTIPLE_ACTIVE_TXN
1894 SQL_MULT_RESULT_SETS
1895 SQL_NEED_LONG_DATA_LEN
1896 SQL_NON_NULLABLE_COLUMNS
1897 SQL_ODBC_VER
1898 SQL_QUALIFIER_NAME_SEPARATOR
1899 SQL_QUOTED_IDENTIFIER_CASE
1900 SQL_TXN_CAPABLE
1901 SQL_TXN_ISOLATION_OPTION
1902 /
1903 ) {
1904 # some drivers barf on things they do not know about instead
1905 # of returning undef
1906 112 ▶ my $v = try { $self->_dbh_get_info($inf) };
Subroutine __ANON__: called CC=1 SCAR=0.0
1907 112 ▶ next unless defined $v;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $v 110 2 112
1908  
1909 #my $key = sprintf( '%s(%s)', $inf, $DBI::Const::GetInfoType::GetInfoType{$inf} );
1910 2 my $expl = DBI::Const::GetInfoReturn::Explain($inf, $v);
1911 2 ▶ $res->{$inf} = DBI::Const::GetInfoReturn::Format($inf, $v) . ( $expl ? " ($expl)" : '' );
Branch: 1 branch
BranchTrueFalseTotal
$expl ? : 0 2 2
1912 }
1913  
1914 # what a DBD answers here may be its DSN again
1915 $res->{SQL_DATA_SOURCE_NAME} = mask_connect_secrets($res->{SQL_DATA_SOURCE_NAME}, $info)
1916 4 ▶ if defined $res->{SQL_DATA_SOURCE_NAME};
Branch: 1 branch
BranchTrueFalseTotal
if defined $res->{"SQL_DATA_SOURCE_NAME"} 1 3 4
1917  
1918 4 $res;
1919 }
1920  
1921 # Driver registry: maps DBD driver names to DBIO Storage classes.
1922 # External DBIO::* distributions register themselves here via
1923 # register_driver(), or are discovered via the default mapping below.
1924 344 my %_driver_registry = (
1925 Pg => 'DBIO::PostgreSQL::Storage',
1926 mysql => 'DBIO::MySQL::Storage',
1927 MariaDB => 'DBIO::MySQL::Storage::MariaDB',
1928 SQLite => 'DBIO::SQLite::Storage',
1929 Oracle => 'DBIO::Oracle::Storage',
1930 Sybase => 'DBIO::Sybase::Storage',
1931 Firebird => 'DBIO::Firebird::Storage',
1932 InterBase => 'DBIO::Firebird::Storage::InterBase',
1933 Informix => 'DBIO::Informix::Storage',
1934 DB2 => 'DBIO::DB2::Storage',
1935 ODBC => 'DBIO::Storage::DBI::ODBC',
1936 );
1937  
1938  
1939 59 ▶sub register_driver {
Subroutine register_driver: called CC=1 SCAR=0.0
Pod documented
1940 59 my ($class, $driver_name, $storage_class) = @_;
1941 59 $_driver_registry{$driver_name} = $storage_class;
1942 }
1943  
1944 190 ▶sub driver_storage_class {
Subroutine driver_storage_class: called CC=1 SCAR=0.0
Pod undocumented
1945 190 my ($class, $driver_name) = @_;
1946 190 return $_driver_registry{$driver_name};
1947 }
1948  
1949 # The registry read backwards: the DBD driver names the nearest registered
1950 # class in this storage's MRO is registered for. Most specific first, so a
1951 # storage layer composed over a driver storage answers that driver, and a
1952 # driver subclass with an entry of its own (DBIO::MySQL::Storage::MariaDB)
1953 # answers its own. Empty for a storage no class of which is registered.
1954 304 ▶sub _registered_dbd_drivers {
Subroutine _registered_dbd_drivers: called CC=4 SCAR=13.9
1955 304 my $self = shift;
1956 304 ▶ for my $class (@{ mro::get_linear_isa(ref $self || $self) }) {
Condition66%2/3
ref $self || $self
l!l&&r!l&&!r
1271770
MC/DC0%0/2
ref $self || $self
ref $self $self
Truth table66%2/3
A || B
A= ref $selfB= $self
ABresult
1X1
011
000
1957 401 my @drivers = sort grep { $_driver_registry{$_} eq $class }
1958 keys %_driver_registry;
1959 401 ▶ return @drivers if @drivers;
Branch: 1 branch
BranchTrueFalseTotal
if @drivers 295 106 401
1960 }
1961 9 return;
1962 }
1963  
1964  
1965 344 my %_access_path_dbds;
1966  
1967 1 ▶sub register_access_path_dbd {
Subroutine register_access_path_dbd: called CC=3 SCAR=11.7
Pod documented
1968 1 my ($class, @dbds) = @_;
1969 1 ▶ $class = ref $class || $class;
Condition33%1/3
ref $class || $class
l!l&&r!l&&!r
010
MC/DC0%0/2
ref $class || $class
ref $class $class
Truth table33%1/3
A || B
A= ref $classB= $class
ABresult
1X1
011
000
1970 1 $_access_path_dbds{$class}{$_} = 1 for @dbds;
1971 1 return;
1972 }
1973  
1974 # Does a class in this storage's MRO -- the adapted class, and with it the
1975 # declared one -- declare $dbd as its access path? Class or instance.
1976 185 ▶sub _access_path_dbd_declared {
Subroutine _access_path_dbd_declared: called CC=6 SCAR=18.0
1977 185 my ($self, $dbd) = @_;
1978 185 ▶ return 0 unless defined $dbd;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $dbd 0 185 185
1979 185 ▶ for my $class (@{ mro::get_linear_isa(ref $self || $self) }) {
Condition66%2/3
ref $self || $self
l!l&&r!l&&!r
18050
MC/DC0%0/2
ref $self || $self
ref $self $self
Truth table66%2/3
A || B
A= ref $selfB= $self
ABresult
1X1
011
000
1980 2090 ▶ return 1 if $_access_path_dbds{$class} and $_access_path_dbds{$class}{$dbd};
Branch: 1 branch
BranchTrueFalseTotal
if $_access_path_dbds{$class} and $_access_path_dbds{$class}{$dbd} 5 2085 2090
Condition100%3/3
$_access_path_dbds{$class} and $_access_path_dbds{$class}{$dbd}
!ll&&!rl&&r
208235
MC/DC100%2/2
$_access_path_dbds{$class} and $_access_path_dbds{$class}{$dbd}
$_access_path_dbds{$class} $_access_path_dbds{$class}{$dbd}
Truth table100%3/3
A and B
A= $_access_path_dbds{$class}B= $_access_path_dbds{$class}{$dbd}
ABresult
0X0
100
111
1981 }
1982 180 return 0;
1983 }
1984  
1985  
1986 1 ▶sub register_connector_driver {
Subroutine register_connector_driver: called CC=1 SCAR=0.0
Pod documented
1987 1 my $class = shift;
1988 1 $class->throw_exception(
1989 'register_connector_driver is retired (ADR 0067): a storage is never '
1990 . 'moved into a driver by the engine an ODBC connection reports. Declare '
1991 . "the driver on the schema (use DBIO 'Schema', -<driver>); a driver that "
1992 . 'runs over ODBC adapts itself to it in _adapt_to_access_path.'
1993 );
1994 }
1995  
1996 # Standard SQL type registrations for DBIO::Cake.
1997 # Driver subclasses add or override entries for their own types.
1998 344 __PACKAGE__->register_type('json', {
1999 cake_options => [qw(inflate_json)],
2000 components => ['InflateColumn::Serializer'],
2001 col_attrs => { serializer_class => 'JSON' },
2002 });
2003  
2004 344 for my $dt (qw(date datetime timestamp time timetz timestamptz interval)) {
2005 2408 __PACKAGE__->register_type($dt, {
2006 cake_options => ['inflate_datetime'],
2007 components => ['InflateColumn::DateTime'],
2008 });
2009 }
2010  
2011 314 ▶sub _determine_driver {
Subroutine _determine_driver: called CC=10 SCAR=23.0
2012 314 my ($self) = @_;
2013  
2014 314 ▶ if ((not $self->_driver_determined) && (not $self->{_in_determine_driver})) {
Branch: 1 branch
BranchTrueFalseTotal
if (not $self->_driver_determined || $self->{"_in_determine_driver"}) 253 61 314
Condition100%3/3
$self->_driver_determined || $self->{'_in_determine_driver'}
l!l&&r!l&&!r
547253
MC/DC100%2/2
$self->_driver_determined || $self->{'_in_determine_driver'}
$self->_driver_determined $self->{'_in_determine_driver'}
Truth table100%3/3
A || B
A= $self->_driver_determinedB= $self->{'_in_determine_driver'}
ABresult
1X1
011
000
2015 # Connected on entry means _populate_dbh is the caller and runs the
2016 # connection actions itself once we return. Running them is ours only when
2017 # the determination opens the connection, since _populate_dbh holds them
2018 # back while _in_determine_driver is set. That holds for a declared class
2019 # as for the generic one (karr k309).
2020 253 ▶ my $started_connected = $self->_dbh ? 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
$self->_dbh ? : 105 148 253
2021 253 local $self->{_in_determine_driver} = 1;
2022  
2023 # A determination that throws leaves the storage as it came in: in the
2024 # class it had, undetermined, and without a handle the determination
2025 # opened itself -- no connection action has run on that one (a handle the
2026 # storage came in with is _populate_dbh's to drop). The next use starts
2027 # over, through the same branch. ADR 0059 says so for the hook of a
2028 # declared class, and _adapt_declared_storage does it for the hook; this
2029 # covers what else can throw: _init (karr k312, k313).
2030 # Whatever the failed step set on the instance stays, as it does there.
2031 # A guard and not a catch, so that the error passes as it was thrown.
2032 253 my $entry_class = ref $self;
2033 253 my $determined;
2034 253 ▶ my $guard = scope_guard {
Subroutine __ANON__: called CC=3 SCAR=11.0
2035 253 ▶ return if $determined;
Branch: 1 branch
BranchTrueFalseTotal
if $determined 119 134 253
2036 134 bless $self, $entry_class;
2037 134 $self->_driver_determined(0);
2038 134 ▶ $self->_dbh(undef) unless $started_connected;
Branch: 1 branch
BranchTrueFalseTotal
unless $started_connected 61 73 134
2039 253 };
2040  
2041 # A composed storage class (DBIO::Storage::Composed) is judged by its
2042 # base: layers over the generic __PACKAGE__ are as driverless as the bare
2043 # generic storage, layers over a driver class are declared. A non-composed
2044 # instance has no registry entry and is judged by its own class.
2045 253 my $composition = DBIO::Storage::Composed->composition_of(ref $self);
2046 my $is_generic = ref($self) eq __PACKAGE__
2047 253 ▶ || ($composition && $composition->{base} eq __PACKAGE__);
Condition100%6/6
ref $self eq __PACKAGE__ || $composition && $composition->{'base'} eq __PACKAGE__
l!l&&r!l&&!r
211231
$composition and $composition->{"base"} eq __PACKAGE__
!ll&&!rl&&r
185461
MC/DC100%3/3
ref $self eq __PACKAGE__ || $composition && $composition->{'base'} eq __PACKAGE__
ref $self eq __PACKAGE__ $composition $composition->{"base"} eq __PACKAGE__
Truth table100%4/4
A || B and C
A= ref $self eq __PACKAGE__B= $compositionC= $composition->{"base"} eq __PACKAGE__
ABCresult
1XX1
0111
00X0
0100
2048  
2049 253 ▶ if ($is_generic) {
Branch: 1 branch
BranchTrueFalseTotal
if ($is_generic) { } 22 231 253
2050 # The generic storage has no driver, and none is guessed from the DSN
2051 # (ADR 0067). A schema refuses it at connect; a storage built by hand
2052 # that gets this far is refused here, and a connection opened for it is
2053 # dropped by the guard above.
2054 22 $self->throw_exception(
2055 'The generic storage DBIO::Storage::DBI has no driver, and a storage '
2056 . 'always has one (ADR 0067). Use the storage class of a driver -- '
2057 . "declared on the schema with use DBIO 'Schema', -<driver>, the "
2058 . "driver's component or storage_type. DBIO->driver_for(\$dsn) names "
2059 . 'the driver of a DSN.'
2060 );
2061 }
2062 else {
2063 # A declared storage class -- pinned by a driver component or a driver
2064 # shortcut through the schema's storage_type -- never leaves its driver.
2065 # It gets to adapt itself to the access path (ADR 0059, karr k301).
2066 231 $self->_adapt_declared_storage($composition);
2067 }
2068  
2069 151 $self->_driver_determined(1);
2070  
2071 151 ▶ Class::C3->reinitialize() if old_mro();
Branch: 1 branch
BranchTrueFalseTotal
if &old_mro() 0 151 151
2072  
2073 151 $self->_init; # run driver-specific initializations
2074  
2075 # A connection action that fails below is no failed determination: it
2076 # gives up the connection (_do_connection_actions) and not the driver.
2077 119 $determined = 1;
2078  
2079 119 ▶ $self->_run_connection_actions
Branch: 1 branch
BranchTrueFalseTotal
if not $started_connected and defined $self->_dbh 7 112 119
Condition100%3/3
not $started_connected and defined $self->_dbh
!ll&&!rl&&r
32807
MC/DC100%2/2
not $started_connected and defined $self->_dbh
not $started_connected defined $self->_dbh
Truth table100%3/3
not(A) and B
A= not $started_connectedB= defined $self->_dbh
ABresult
0X0
100
111
2080 if !$started_connected && defined $self->_dbh;
2081 }
2082 }
2083  
2084 5 ▶sub _extract_driver_from_connect_info {
Subroutine _extract_driver_from_connect_info: called CC=3 SCAR=11.1
2085 5 my $self = shift;
2086  
2087 5 my $drv;
2088  
2089 # if connect_info is a CODEREF, we have no choice but to connect
2090 5 ▶ if (
Branch: 1 branch
BranchTrueFalseTotal
if (ref $self->_dbi_connect_info->[0] and builtin::reftype($self->_dbi_connect_info->[0]) eq 'CODE') { } 1 4 5
Condition66%2/3
ref $self->_dbi_connect_info->[0] and builtin::reftype($self->_dbi_connect_info->[0]) eq "CODE"
!ll&&!rl&&r
401
MC/DC50%1/2
ref $self->_dbi_connect_info->[0] and builtin::reftype($self->_dbi_connect_info->[0]) eq "CODE"
ref $self->_dbi_connect_info->[0] builtin::reftype($self->_dbi_connect_info->[0]) eq "CODE"
Truth table66%2/3
A and B
A= ref $self->_dbi_connect_info->[0]B= builtin::reftype($self->_dbi_connect_info->[0]) eq "CODE"
ABresult
0X0
100
111
2091 ref $self->_dbi_connect_info->[0]
2092 and
2093 reftype $self->_dbi_connect_info->[0] eq 'CODE'
2094 ) {
2095 1 $self->_populate_dbh;
2096 0 $drv = $self->_dbh->{Driver}{Name};
2097 }
2098 else {
2099 # try to use dsn to not require being connected
2100 # (dsn may not be supplied at all if all we do is make a mock-schema)
2101 #
2102 # Use the same regex as the one used by DBI itself (even if the use of
2103 # \w is odd given unicode):
2104 # https://metacpan.org/source/TIMB/DBI-1.634/DBI.pm#L621
2105 #
2106 # DO NOT use https://metacpan.org/source/TIMB/DBI-1.634/DBI.pm#L559-566
2107 # as there is a long-standing precedent of not loading DBI.pm until the
2108 # very moment we are actually connecting
2109 #
2110 4 $drv = $self->_dsn_driver_part($self->_dbi_connect_info->[0]);
2111 }
2112  
2113 4 return $drv;
2114 }
2115  
2116  
2117 56 ▶sub _adapt_to_access_path {}
Subroutine _adapt_to_access_path: called CC=1 SCAR=0.0
2118  
2119  
2120 61 ▶sub _driver_mismatch {
Subroutine _driver_mismatch: called CC=7 SCAR=19.5
2121 61 my ($self, $message) = @_;
2122  
2123 61 my $schema = $self->_driver_switch_schema;
2124 61 ▶ my $strict = $schema ? $schema->driver_strict : 0;
Branch: 1 branch
BranchTrueFalseTotal
$schema ? : 59 2 61
2125 61 ▶ my $warn = $schema ? $schema->driver_warnings : 1;
Branch: 1 branch
BranchTrueFalseTotal
$schema ? : 59 2 61
2126  
2127 61 ▶ return unless $strict or $warn;
Branch: 1 branch
BranchTrueFalseTotal
unless $strict or $warn 3 58 61
Condition100%3/3
$strict or $warn
l!l&&r!l&&!r
47113
MC/DC100%2/2
$strict or $warn
$strict $warn
Truth table100%3/3
A or B
A= $strictB= $warn
ABresult
1X1
011
000
2128  
2129 58 ▶ $message = sprintf 'Driver mismatch for declared storage class %s: %s',
Condition66%2/3
$self->_declared_storage_class || ref $self
l!l&&r!l&&!r
5170
MC/DC0%0/2
$self->_declared_storage_class || ref $self
$self->_declared_storage_class ref $self
Truth table66%2/3
A || B
A= $self->_declared_storage_classB= ref $self
ABresult
1X1
011
000
2130 ( $self->_declared_storage_class || ref $self ), $message;
2131  
2132 58 ▶ $self->throw_exception(
Branch: 1 branch
BranchTrueFalseTotal
if $strict 47 11 58
2133 "$message (an error because driver_strict is set on the schema)"
2134 ) if $strict;
2135  
2136 11 carp "$message -- set driver_strict(1) on the schema to make this an "
2137 . 'error, or driver_warnings(0) to silence it';
2138  
2139 11 return;
2140 }
2141  
2142 # The schema whose driver_strict / driver_warnings apply to this storage: its
2143 # own, else that of the nearest parent storage along _parent_storage (a writer
2144 # or bulk storage a driver builds without a schema). Bounded and cycle-safe.
2145 61 ▶sub _driver_switch_schema {
Subroutine _driver_switch_schema: called CC=5 SCAR=16.1
2146 61 my $self = shift;
2147  
2148 61 my %seen;
2149 61 my $storage = $self;
2150 61 for (1 .. 16) {
2151 69 ▶ last if !$storage or $seen{ refaddr($storage) }++;
Branch: 1 branch
BranchTrueFalseTotal
if not $storage or $seen{builtin::refaddr($storage)}++ 2 67 69
Condition100%3/3
not $storage or $seen{builtin::refaddr($storage)}++
l!l&&r!l&&!r
1167
MC/DC100%2/2
not $storage or $seen{builtin::refaddr($storage)}++
not $storage $seen{builtin::refaddr($storage)}++
Truth table100%3/3
not(A) or B
A= not $storageB= $seen{builtin::refaddr($storage)}++
ABresult
1X1
011
000
2152 67 my $schema = $storage->schema;
2153 67 ▶ return $schema if $schema;
Branch: 1 branch
BranchTrueFalseTotal
if $schema 59 8 67
2154 8 $storage = $storage->_parent_storage;
2155 }
2156  
2157 2 return undef;
2158 }
2159  
2160 # The declared half of driver determination (ADR 0059): the hook, the check
2161 # of its one rule, the layers, and the DBD of another driver. $composition is
2162 # the DBIO::Storage::Composed entry of the instance's class, if it is layered.
2163 231 ▶sub _adapt_declared_storage {
Subroutine _adapt_declared_storage: called CC=2 SCAR=6.9
2164 231 my ($self, $composition) = @_;
2165  
2166 231 my $entry_class = ref $self;
2167 231 ▶ my $declared = $composition ? $composition->{base} : $entry_class;
Branch: 1 branch
BranchTrueFalseTotal
$composition ? : 46 185 231
2168  
2169 231 $self->_declared_storage_class($declared);
2170  
2171 231 ▶ try {
Subroutine __ANON__: called CC=4 SCAR=13.9
2172 231 $self->_adapt_to_access_path($self->_access_path_dbd);
2173  
2174 198 my $adapted = ref $self;
2175  
2176 # The rule is checked here and not left to the hook: a storage in the
2177 # class of another driver is what this path exists to rule out. Back into
2178 # the class it came in first -- the foreign one may not even be a storage.
2179 198 ▶ if (! $self->isa($declared)) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($self->isa($declared)) 4 194 198
2180 4 bless $self, $entry_class;
2181 4 $self->throw_exception(
2182 "The _adapt_to_access_path hook of declared storage class $declared "
2183 . "reblessed the storage into $adapted, which is not a subclass of it. "
2184 . 'A declared driver adapts to the access path within its own classes '
2185 . 'only; a server that is something else is reported through '
2186 . '_driver_mismatch.'
2187 );
2188 }
2189  
2190 # The hook reblesses into a plain class of its driver; the layers of the
2191 # schema go back over it.
2192 194 ▶ bless $self, DBIO::Storage::Composed->recompose($entry_class, $adapted)
Branch: 1 branch
BranchTrueFalseTotal
if $composition and not "DBIO::Storage::Composed"->composition_of($adapted) 2 192 194
Condition100%3/3
$composition and not "DBIO::Storage::Composed"->composition_of($adapted)
!ll&&!rl&&r
154382
MC/DC100%2/2
$composition and not "DBIO::Storage::Composed"->composition_of($adapted)
$composition not "DBIO::Storage::Composed"->composition_of($adapted)
Truth table100%3/3
A and not(B)
A= $compositionB= not "DBIO::Storage::Composed"->composition_of($adapted)
ABresult
0X0
100
111
2193 if $composition
2194 and ! DBIO::Storage::Composed->composition_of($adapted);
2195  
2196 194 $self->_check_access_path_dbd($declared);
2197 }
2198 80 ▶ catch {
Subroutine __ANON__: called CC=1 SCAR=0.0
2199 80 bless $self, $entry_class;
2200 80 $self->throw_exception($_);
2201 231 };
2202  
2203 151 return;
2204 }
2205  
2206 # The DBD the connect info leads through, as far as it is known WITHOUT
2207 # connecting: the live handle's when there is one, else the one the DSN names,
2208 # else none (a DSN with an empty driver part is refused, karr k340). Undef for
2209 # a connection coderef that has not been run and for connect info without a
2210 # DSN. The driver part is read as _extract_driver_from_connect_info reads it;
2211 # that method is not shared because it connects for a coderef, which
2212 # _describe_connection may and this may not.
2213 425 ▶sub _access_path_dbd {
Subroutine _access_path_dbd: called CC=3 SCAR=11.0
2214 425 my $self = shift;
2215  
2216 425 ▶ if (my $dbh = $self->_dbh) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $dbh = $self->_dbh) 173 252 425
2217 173 return $dbh->{Driver}{Name};
2218 }
2219  
2220 252 my $dsn = $self->_dbi_connect_info->[0];
2221 252 ▶ return undef if ref $dsn;
Branch: 1 branch
BranchTrueFalseTotal
if ref $dsn 4 248 252
2222  
2223 248 return $self->_dsn_driver_part($dsn);
2224 }
2225  
2226 # The driver part of a DSN, undef for no DSN. The DSN decides the driver
2227 # (karr k340): a DSN whose driver part is empty (dbi::dbname=x) is refused,
2228 # and $ENV{DBI_DRIVER} does not stand in for it. The message names the shape,
2229 # never the DSN. The regex is the one DBI itself uses.
2230 751 ▶sub _dsn_driver_part {
Subroutine _dsn_driver_part: called CC=5 SCAR=16.5
2231 751 my ($self, $dsn) = @_;
2232  
2233 751 ▶ return undef unless defined $dsn && length $dsn;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $dsn and length $dsn 0 751 751
Condition33%1/3
defined $dsn and length $dsn
!ll&&!rl&&r
00751
MC/DC0%0/2
defined $dsn and length $dsn
defined $dsn length $dsn
Truth table33%1/3
A and B
A= defined $dsnB= length $dsn
ABresult
0X0
100
111
2234  
2235 751 my ($dbd) = $dsn =~ /^dbi:(\w*)/i;
2236 751 ▶ return undef unless defined $dbd;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $dbd 79 672 751
2237  
2238 672 ▶ $self->throw_exception(
Branch: 1 branch
BranchTrueFalseTotal
unless length $dbd 8 664 672
2239 'Connect info with a DSN without a driver part (dbi::...). The DSN names '
2240 . 'the driver, never $ENV{DBI_DRIVER}: give the DBD name in the DSN '
2241 . '(dbi:<driver>:...).'
2242 ) unless length $dbd;
2243  
2244 664 return $dbd;
2245 }
2246  
2247 # The DBD of another driver: the registry maps it to a class that is neither
2248 # an ancestor of the (adapted) storage nor a subclass of the declared class.
2249 # A DBD nothing is registered for (Proxy, Gofer, a mock) is not a finding.
2250 # A registered class that cannot be loaded is no relative.
2251 194 ▶sub _check_access_path_dbd {
Subroutine _check_access_path_dbd: called CC=8 SCAR=20.8
2252 194 my ($self, $declared) = @_;
2253  
2254 194 my $dbd = $self->_access_path_dbd;
2255 194 ▶ return unless defined $dbd;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $dbd 14 180 194
2256  
2257 # A DBD the driver declared as its own access path is no finding
2258 # (register_access_path_dbd, karr k321).
2259 180 ▶ return if $self->_access_path_dbd_declared($dbd);
Branch: 1 branch
BranchTrueFalseTotal
if $self->_access_path_dbd_declared($dbd) 3 177 180
2260  
2261 # Only a class of registered origin is judged: a private subclass of the
2262 # generic storage, set by hand, has no driver to compare the DBD with
2263 # (karr k301).
2264 177 ▶ return unless $declared->_registered_dbd_drivers;
Branch: 1 branch
BranchTrueFalseTotal
unless $declared->_registered_dbd_drivers 6 171 177
2265  
2266 171 ▶ my $registered = $_driver_registry{$dbd}
Branch: 1 branch
BranchTrueFalseTotal
my $registered = $_driver_registry{$dbd} or return 170 1 171
2267 or return;
2268  
2269 170 ▶ return if $self->isa($registered);
Branch: 1 branch
BranchTrueFalseTotal
if $self->isa($registered) 120 50 170
2270  
2271 return if (
2272 50 ▶ ( try { $self->load_optional_class($registered) } )
Subroutine __ANON__: called CC=1 SCAR=0.0
2273 50 ▶ and
Branch: 1 branch
BranchTrueFalseTotal
if &try(sub { $self->load_optional_class($registered); } ) and $registered->isa($declared) 1 49 50
Condition100%3/3
&try(sub { $self->load_optional_class($registered); } ) and $registered->isa($declared)
!ll&&!rl&&r
1481
MC/DC100%2/2
&try(sub { $self->load_optional_class($registered); } ) and $registered->isa($declared)
&try(sub { $self->load_optional_class($registered); } ) $registered->isa($declared)
Truth table100%3/3
A and B
A= &try(sub { $self->load_optional_class($registered); } )B= $registered->isa($declared)
ABresult
0X0
100
111
2274 $registered->isa($declared)
2275 );
2276  
2277 49 $self->_driver_mismatch(
2278 "the connect info leads through DBD::$dbd, which is registered for $registered"
2279 );
2280  
2281 6 return;
2282 }
2283  
2284 202 ▶sub _do_connection_actions {
Subroutine _do_connection_actions: called CC=1 SCAR=0.0
2285 202 my ($self, $method_prefix, $call, @args) = @_;
2286  
2287 202 ▶ try {
Subroutine __ANON__: called CC=7 SCAR=19.6
2288 202 ▶ if (not ref($call)) {
Branch: 3 branches
BranchTrueFalseTotal
if (not ref $call) { } 129 73 202
elsif (ref $call eq 'CODE') { } 3 70 73
elsif (ref $call eq 'ARRAY') { } 70 0 70
2289 129 my $method = $method_prefix . $call;
2290 129 $self->$method(@args);
2291 }
2292 elsif (ref($call) eq 'CODE') {
2293 3 $self->$call(@args);
2294 }
2295 elsif (ref($call) eq 'ARRAY') {
2296 70 ▶ if (ref($call->[0]) ne 'ARRAY') {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $call->[0] ne 'ARRAY') { } 2 68 70
2297 2 $self->_do_connection_actions($method_prefix, $_) for @$call;
2298 }
2299 else {
2300 68 $self->_do_connection_actions($method_prefix, @$_) for @$call;
2301 }
2302 }
2303 else {
2304 0 $self->throw_exception (sprintf ("Don't know how to process conection actions of type '%s'", ref($call)) );
2305 }
2306 }
2307 27 ▶ catch {
Subroutine __ANON__: called CC=3 SCAR=11.4
2308 27 ▶ if ( $method_prefix =~ /^connect/ ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($method_prefix =~ /^connect/) { } 27 0 27
2309 # this is an on_connect cycle - we can't just throw while leaving
2310 # a handle in an undefined state in our storage object
2311 # kill it with fire and rethrow
2312 #
2313 # Unless the actions were replayed on an async pool connection
2314 # (_run_pool_connect_actions): then the half-configured handle is the
2315 # pool's, which retires it (ADR 0047). Ours is another connection the
2316 # failure never touched, possibly in the middle of a transaction
2317 # (karr k251).
2318 27 ▶ $self->_dbh(undef) unless $self->{_pool_connect_runner};
Branch: 1 branch
BranchTrueFalseTotal
unless $self->{"_pool_connect_runner"} 15 12 27
2319 27 $self->throw_exception( $_[0] );
2320 }
2321 else {
2322 0 carp "Disconnect action failed: $_[0]";
2323 }
2324 202 };
2325  
2326 175 return $self;
2327 }
2328  
2329 69 ▶sub connect_call_do_sql {
Subroutine connect_call_do_sql: called CC=1 SCAR=0.0
Pod undocumented
2330 69 my $self = shift;
2331 69 $self->_do_query(@_);
2332 }
2333  
2334 6 ▶sub disconnect_call_do_sql {
Subroutine disconnect_call_do_sql: called CC=1 SCAR=0.0
Pod undocumented
2335 6 my $self = shift;
2336 6 $self->_do_query(@_);
2337 }
2338  
2339  
2340 0 ▶sub connect_call_datetime_setup { 1 }
Subroutine connect_call_datetime_setup: not called CC=1 SCAR=6.9
Pod documented
2341  
2342 100 ▶sub _do_query {
Subroutine _do_query: called CC=10 SCAR=23.2
2343 100 my ($self, $action) = @_;
2344  
2345 100 ▶ if (ref $action eq 'CODE') {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $action eq 'CODE') { } 13 87 100
2346 13 my $answer = $action->($self);
2347  
2348 # nothing, one statement as a plain string, or a list of statements
2349 13 ▶ return $self unless defined $answer and (ref $answer or length $answer);
Branch: 1 branch
BranchTrueFalseTotal
unless defined $answer and ref $answer || length $answer 3 10 13
Condition100%6/6
defined $answer and ref $answer || length $answer
!ll&&!rl&&r
2110
ref $answer or length $answer
l!l&&r!l&&!r
551
MC/DC100%3/3
defined $answer and ref $answer || length $answer
defined $answer ref $answer length $answer
Truth table100%4/4
A and B or C
A= defined $answerB= ref $answerC= length $answer
ABCresult
0XX0
1000
11X1
1011
2350  
2351 10 ▶ $answer = [ $answer ] unless ref $answer;
Branch: 1 branch
BranchTrueFalseTotal
unless ref $answer 5 5 10
2352  
2353 10 ▶ $self->throw_exception(
Branch: 2 branches
BranchTrueFalseTotal
unless ref $answer eq "ARRAY" 3 7 10
builtin::blessed($answer) ? : 1 2 3
2354 'A code reference given to on_connect_do / on_disconnect_do / do_sql '
2355 . 'must return a SQL string, an array reference of statements, or '
2356 . 'nothing, not ' . (blessed($answer)
2357 ? 'an object of class ' . ref $answer
2358 : 'a ' . ref($answer) . ' reference')
2359 ) unless ref $answer eq 'ARRAY';
2360  
2361 7 $self->_do_query($_) foreach @$answer;
2362 }
2363 else {
2364 # Most debuggers expect ($sql, @bind), so we need to exclude
2365 # the attribute hash which is the second argument to $dbh->do
2366 # furthermore the bind values are usually to be presented
2367 # as named arrayref pairs, so wrap those here too
2368 87 ▶ my @do_args = (ref $action eq 'ARRAY') ? (@$action) : ($action);
Branch: 1 branch
BranchTrueFalseTotal
ref $action eq 'ARRAY' ? : 2 85 87
2369 87 my $sql = shift @do_args;
2370 87 my $attrs = shift @do_args;
2371 87 my @bind = map { [ undef, $_ ] } @do_args;
2372  
2373 # An error about this statement never quotes what it carries as a secret
2374 # (karr k343): _dbi_handle_error masks the text of the database before
2375 # the exception_action sees it, a die of the pool runner is masked here.
2376 87 local $self->{_statement_in_flight} = $sql;
2377 87 local $self->{_values_in_flight} = \@do_args;
2378  
2379 87 ▶ try {
Subroutine __ANON__: called CC=2 SCAR=6.9
2380 # When replaying this storage's connection actions against a
2381 # freshly-spawned async pool connection (_run_pool_connect_actions), the
2382 # statement must execute on THAT pool connection, not on this sync
2383 # storage's own dbh. The runner (installed by the async backend's
2384 # _setup_pool_connection) does the blocking do on the pool handle. Only
2385 # ever set inside that dynamic scope, so the normal sync path is
2386 # untouched.
2387 87 ▶ if (my $runner = $self->{_pool_connect_runner}) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $runner = $self->{'_pool_connect_runner'}) { } 34 53 87
2388 34 $runner->($sql, $attrs, @do_args);
2389 }
2390 else {
2391 53 ▶ $self->dbh_do(sub {
Subroutine __ANON__: called CC=1 SCAR=0.0
2392 53 $_[0]->_query_start($sql, \@bind);
2393 53 $_[1]->do($sql, $attrs, @do_args);
2394 44 $_[0]->_query_end($sql, \@bind);
2395 53 });
2396 }
2397 }
2398 17 ▶ catch {
Subroutine __ANON__: called CC=6 SCAR=20.5
2399 17 my $err = $_;
2400 17 my $values = _plain_error_values(@do_args);
2401 17 ▶ if (!ref $err) {
Branch: 2 branches
BranchTrueFalseTotal
if (not ref $err) { } 7 10 17
elsif (builtin::blessed($err) and $err->isa('DBIO::Exception') and defined $err->{'msg'} and not ref $err->{'msg'}) { } 10 0 10
2402 7 $err = $self->_mask_error_values(mask_statement_secrets($err, $sql), $values, $sql);
2403 }
2404 ▶ elsif (blessed $err and $err->isa('DBIO::Exception') and defined $err->{msg} and !ref $err->{msg}) {
Condition33%3/9
builtin::blessed($err) and $err->isa("DBIO::Exception") and defined $err->{"msg"} and not ref $err->{"msg"}
!ll&&!rl&&r
0010
builtin::blessed($err) and $err->isa("DBIO::Exception") and defined $err->{"msg"}
!ll&&!rl&&r
0010
builtin::blessed($err) and $err->isa("DBIO::Exception")
!ll&&!rl&&r
0010
MC/DC0%0/4
builtin::blessed($err) and $err->isa("DBIO::Exception") and defined $err->{"msg"} and not ref $err->{"msg"}
builtin::blessed($err) $err->isa("DBIO::Exception") defined $err->{"msg"} not ref $err->{"msg"}
Truth table20%1/5
A and B and C and not(D)
A= builtin::blessed($err)B= $err->isa("DBIO::Exception")C= defined $err->{"msg"}D= not ref $err->{"msg"}
ABCDresult
0XXX0
10XX0
110X0
11100
11111
2405 10 $err->{msg} = $self->_mask_error_values(mask_statement_secrets($err->{msg}, $sql), $values, $sql);
2406 }
2407 17 die $err;
2408 87 };
2409 }
2410  
2411 77 return $self;
2412 }
2413  
2414  
2415 1 ▶sub connect_call_rebase_sqlmaker {
Subroutine connect_call_rebase_sqlmaker: called CC=9 SCAR=23.7
Pod documented
2416 1 my( $self, $requested_base_class ) = @_;
2417  
2418 1 ▶ $self->throw_exception(
Branch: 1 branch
BranchTrueFalseTotal
if @_ != 2 or not length $requested_base_class 0 1 1
Condition33%1/3
@_ != 2 or not length $requested_base_class
l!l&&r!l&&!r
001
MC/DC0%0/2
@_ != 2 or not length $requested_base_class
@_ != 2 not length $requested_base_class
Truth table33%1/3
A or not(B)
A= @_ != 2B= not length $requested_base_class
ABresult
1X1
011
000
2419 "The on_connect callee 'rebase_sqlmaker' expects a single plain string argument: the name of the target base class"
2420 ) if (
2421 @_ != 2
2422 or
2423 ! length( $requested_base_class )
2424 );
2425  
2426 1 my $old_class = ref( $self->sql_maker );
2427  
2428 # nothing to do!
2429 1 ▶ return if $old_class->isa( $requested_base_class );
Branch: 1 branch
BranchTrueFalseTotal
if $old_class->isa($requested_base_class) 0 1 1
2430  
2431 1 my $synthetic_class = "${old_class}__REBASED_ON__${requested_base_class}";
2432  
2433 {
2434 344 ▶ no strict 'refs';
Subroutine BEGIN: called CC=1 SCAR=0.0
2435  
2436 # skip if we already made that class
2437 1 ▶ unless( @{"${synthetic_class}::ISA"} ) {
Branch: 1 branch
BranchTrueFalseTotal
unless (@{"${synthetic_class}::ISA";}) 1 0 1
2438  
2439 1 $self->ensure_class_loaded( $requested_base_class );
2440  
2441 1 ▶ $self->throw_exception(
Branch: 1 branch
BranchTrueFalseTotal
unless $requested_base_class->isa("DBIO::SQLMaker::ClassicExtensions") 0 1 1
2442 "The 'rebase_sqlmaker' target class '$requested_base_class' is not inheriting from 'DBIO::SQLMaker::ClassicExtensions', this can not work"
2443 ) unless $requested_base_class->isa( 'DBIO::SQLMaker::ClassicExtensions' );
2444  
2445 1 ▶ $self->throw_exception(
Branch: 1 branch
BranchTrueFalseTotal
unless $requested_base_class->isa("SQL::Abstract") or $requested_base_class->isa("SQL::Abstract::Classic") 0 1 1
Condition33%1/3
$requested_base_class->isa("SQL::Abstract") or $requested_base_class->isa("SQL::Abstract::Classic")
l!l&&r!l&&!r
100
MC/DC0%0/2
$requested_base_class->isa("SQL::Abstract") or $requested_base_class->isa("SQL::Abstract::Classic")
$requested_base_class->isa("SQL::Abstract") $requested_base_class->isa("SQL::Abstract::Classic")
Truth table33%1/3
A or B
A= $requested_base_class->isa("SQL::Abstract")B= $requested_base_class->isa("SQL::Abstract::Classic")
ABresult
1X1
011
000
2446 "The 'rebase_sqlmaker' target class '$requested_base_class' must inherit from SQL::Abstract or SQL::Abstract::Classic"
2447 ) unless $requested_base_class->isa( 'SQL::Abstract' )
2448 or $requested_base_class->isa( 'SQL::Abstract::Classic' );
2449  
2450 1 $self->inject_base( $synthetic_class, $old_class, $requested_base_class );
2451  
2452 1 ▶ Class::C3->reinitialize
Branch: 1 branch
BranchTrueFalseTotal
if &old_mro() 0 1 1
2453 if old_mro();
2454 }
2455 }
2456  
2457 # force re-build on next access for this particular $storage instance
2458 1 $self->sql_maker_class( $synthetic_class );
2459 1 $self->_sql_maker( undef );
2460 }
2461  
2462  
2463 485 ▶sub _finish_connect_dsn { $_[1] }
Subroutine _finish_connect_dsn: called CC=1 SCAR=0.0
2464  
2465 885 ▶sub _connect {
Subroutine _connect: called CC=7 SCAR=21.8
2466 885 my $self = shift;
2467  
2468 885 my $info;
2469 885 ▶ if ($self->access_broker) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->access_broker) { } 532 353 885
2470 # nothing of the answer is stored: it is formed for this connection alone
2471 532 my ($args, $attrs) = $self->_access_broker_dbi_args(
2472 $self->access_broker_mode, connecting => 1,
2473 );
2474 263 $info = $args;
2475 263 $self->_dbio_connect_attributes($attrs);
2476 }
2477 else {
2478 353 $info = $self->_dbi_connect_info;
2479 }
2480  
2481 616 ▶ $self->throw_exception("You did not provide any connection_info")
Branch: 1 branch
BranchTrueFalseTotal
unless defined $info->[0] 64 552 616
2482 unless defined $info->[0];
2483  
2484 # before DBI->connect, which would take the driver from $ENV{DBI_DRIVER}
2485 # for a DSN without a driver part (karr k340)
2486 552 ▶ $self->_dsn_driver_part($info->[0]) unless ref $info->[0];
Branch: 1 branch
BranchTrueFalseTotal
unless ref $info->[0] 499 53 552
2487  
2488 # the driver's last word on the DSN, for broker and static connect info
2489 # alike; on a copy, the stored connect info stays as it is
2490 544 ▶ unless (ref $info->[0]) {
Branch: 1 branch
BranchTrueFalseTotal
unless (ref $info->[0]) 491 53 544
2491 491 $info = [ @$info ];
2492 491 $info->[0] = $self->_finish_connect_dsn($info->[0]);
2493 }
2494  
2495 544 my ($old_connect_via, $dbh);
2496  
2497 544 ▶ local $DBI::connect_via = 'connect' if $INC{'Apache/DBI.pm'} && $ENV{MOD_PERL};
Branch: 1 branch
BranchTrueFalseTotal
if $INC{"Apache/DBI.pm"} and $ENV{"MOD_PERL"} 0 544 544
Condition33%1/3
$INC{"Apache/DBI.pm"} and $ENV{"MOD_PERL"}
!ll&&!rl&&r
54400
MC/DC0%0/2
$INC{"Apache/DBI.pm"} and $ENV{"MOD_PERL"}
$INC{"Apache/DBI.pm"} $ENV{"MOD_PERL"}
Truth table33%1/3
A and B
A= $INC{"Apache/DBI.pm"}B= $ENV{"MOD_PERL"}
ABresult
0X0
100
111
2498  
2499 # this odd anonymous coderef dereference is in fact really
2500 # necessary to avoid the unwanted effect described in perl5
2501 # RT#75792
2502 #
2503 # in addition the coderef itself can't reside inside the try{} block below
2504 # as it somehow triggers a leak under perl -d
2505 361 ▶ my $dbh_error_handler_installer = sub {
Subroutine __ANON__: called CC=1 SCAR=4.7
2506 361 weaken (my $weak_self = $_[0]);
2507  
2508 # the coderef is blessed so we can distinguish it from externally
2509 # supplied handles (which must be preserved)
2510 0 ▶ $_[1]->{HandleError} = bless sub {
Subroutine __ANON__: not called CC=3 SCAR=24.8
2511 0 ▶ if ($weak_self) {
Branch: 1 branch
BranchTrueFalseTotal
if ($weak_self) { } 0 0 0
2512 0 $weak_self->_dbi_handle_error(@_[0, 1]);
2513 }
2514 else {
2515 # the handler may be invoked by something totally out of
2516 # the scope of DBIO
2517 0 my $err;
2518 0 ▶ eval {
Branch: 1 branch
BranchTrueFalseTotal
eval { do { "DBIO::Exception"->throw("DBI Exception (unhandled by DBIO, ::Schema GCed): $_[0]"); 1 } } or $err = $@ 0 0 0
2519 0 DBIO::Exception->throw("DBI Exception (unhandled by DBIO, ::Schema GCed): $_[0]");
2520 0 1;
2521 } or $err = $@;
2522 0 die _exception_as_server($err, __PACKAGE__->_dbi_error_fields($_[1]));
2523 }
2524 361 }, '__DBIO__DBH__ERROR__HANDLER__';
2525 544 };
2526  
2527 544 ▶ try {
Subroutine __ANON__: called CC=10 SCAR=27.3
2528 544 ▶ if(ref $info->[0] eq 'CODE') {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $info->[0] eq 'CODE') { } 53 491 544
2529 53 $dbh = $info->[0]->();
2530 }
2531 else {
2532 491 require DBI;
2533 491 $dbh = DBI->connect(@$info);
2534 }
2535  
2536 365 ▶ die $DBI::errstr unless $dbh;
Branch: 1 branch
BranchTrueFalseTotal
unless $dbh 0 365 365
2537  
2538 365 ▶ die sprintf ("%s fresh DBI handle with a *false* 'Active' attribute. "
Branch: 2 branches
BranchTrueFalseTotal
unless $dbh->FETCH("Active") 0 365 365
ref $info->[0] eq 'CODE' ? : 0 0 0
2539 . 'This handle is disconnected as far as DBIO is concerned, and we can '
2540 . 'not continue',
2541 ref $info->[0] eq 'CODE'
2542 ? "Connection coderef $info->[0] returned a"
2543 : 'DBI->connect($schema->storage->connect_info) resulted in a'
2544 ) unless $dbh->FETCH('Active');
2545  
2546 # sanity checks unless asked otherwise
2547 365 ▶ unless ($self->unsafe) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($self->unsafe) 361 4 365
2548  
2549 $self->throw_exception(
2550 'Refusing clobbering of {HandleError} installed on externally supplied '
2551 ."DBI handle $dbh. Either remove the handler or use the 'unsafe' attribute."
2552 361 ▶ ) if $dbh->{HandleError} and ref $dbh->{HandleError} ne '__DBIO__DBH__ERROR__HANDLER__';
Branch: 1 branch
BranchTrueFalseTotal
if $dbh->{"HandleError"} and ref $dbh->{"HandleError"} ne "__DBIO__DBH__ERROR__HANDLER__" 0 361 361
Condition33%1/3
$dbh->{"HandleError"} and ref $dbh->{"HandleError"} ne "__DBIO__DBH__ERROR__HANDLER__"
!ll&&!rl&&r
36100
MC/DC0%0/2
$dbh->{"HandleError"} and ref $dbh->{"HandleError"} ne "__DBIO__DBH__ERROR__HANDLER__"
$dbh->{"HandleError"} ref $dbh->{"HandleError"} ne "__DBIO__DBH__ERROR__HANDLER__"
Truth table33%1/3
A and B
A= $dbh->{"HandleError"}B= ref $dbh->{"HandleError"} ne "__DBIO__DBH__ERROR__HANDLER__"
ABresult
0X0
100
111
2553  
2554 # Default via _default_dbi_connect_attributes is 1, hence it was an explicit
2555 # request, or an external handle. Complain and set anyway
2556 361 ▶ unless ($dbh->{RaiseError}) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($dbh->{"RaiseError"}) 0 361 361
2557 0 ▶ carp( ref $info->[0] eq 'CODE'
Branch: 1 branch
BranchTrueFalseTotal
ref $info->[0] eq 'CODE' ? : 0 0 0
2558  
2559 ? "The 'RaiseError' of the externally supplied DBI handle is set to false. "
2560 ."DBIO will toggle it back to true, unless the 'unsafe' connect "
2561 .'attribute has been supplied'
2562  
2563 : 'RaiseError => 0 supplied in your connection_info, without an explicit '
2564 .'unsafe => 1. Toggling RaiseError back to true'
2565 );
2566  
2567 0 $dbh->{RaiseError} = 1;
2568 }
2569  
2570 361 $dbh->{ShowErrorStatement} = 0;
2571  
2572 361 $dbh_error_handler_installer->($self, $dbh);
2573 }
2574 }
2575 179 ▶ catch {
Subroutine __ANON__: called CC=1 SCAR=0.0
2576 # DBI dies quoting the data source it was given, and a DBD or a connection
2577 # coderef may repeat any of it: never the password (karr k297)
2578 179 $self->throw_exception(mask_connect_secrets("DBI Connection failed: $_", $info))
2579 544 };
2580  
2581 365 $self->_dbh_autocommit($dbh->{AutoCommit});
2582 365 return $dbh;
2583 }
2584  
2585 # What the HandleError handler of every handle this storage opens does with
2586 # a refused statement (ADR 0062, decision 2026-10-12): throws it as a
2587 # DBIO::Exception::Server -- a DBIO::Exception, so existing catch blocks keep
2588 # working -- whose text is the "DBI Exception: ..." (caller included) it always
2589 # was, and whose sqlstate and further fields come from _dbi_error_fields. The
2590 # exception still goes through throw_exception first, so an exception_action
2591 # of the schema sees the same text it always did and an object of its own that
2592 # it throws is left alone.
2593 28 ▶sub _dbi_handle_error {
Subroutine _dbi_handle_error: called CC=18 SCAR=29.2
2594 28 my ($self, $msg, $h) = @_;
2595  
2596 # the statement being run: the one of _dbh_execute, else the one of a
2597 # connect action (_do_query), else the one the handle knows
2598 # _exec_in_flight holds the statement (in placeholder form) and the values
2599 # bound to it; _values_in_flight the values of a statement _do_query runs
2600 28 ▶ my ($exec_sql, $exec_values) = @{ $self->{_exec_in_flight} || [] };
Condition100%2/2
$self->{'_exec_in_flight'} || []
l!l
1117
MC/DC100%1/1
$self->{'_exec_in_flight'} || []
$self->{'_exec_in_flight'}
Truth table100%2/2
A
A= $self->{'_exec_in_flight'}
Aresult
11
00
2601 28 ▶ my $mask_values = $exec_values // $self->{_values_in_flight};
Condition100%3/3
$exec_values // $self->{"_values_in_flight"}
l!l&&r!l&&!r
11611
MC/DC100%2/2
$exec_values // $self->{"_values_in_flight"}
$exec_values $self->{"_values_in_flight"}
Truth table100%3/3
A // B
A= $exec_valuesB= $self->{"_values_in_flight"}
ABresult
1X1
011
000
2602 my $statement = $exec_sql // $self->{_statement_in_flight}
2603 28 ▶ // eval { $h->{Statement} };
Condition100%6/6
($exec_sql // $self->{"_statement_in_flight"}) // eval { do { $h->{"Statement"} } }
l!l&&r!l&&!r
17110
$exec_sql // $self->{"_statement_in_flight"}
l!l&&r!l&&!r
11611
MC/DC100%3/3
($exec_sql // $self->{"_statement_in_flight"}) // eval { do { $h->{"Statement"} } }
$exec_sql $self->{"_statement_in_flight"} eval { do { $h->{"Statement"} } }
Truth table100%4/4
A // B // C
A= $exec_sqlB= $self->{"_statement_in_flight"}C= eval { do { $h->{"Statement"} } }
ABCresult
1XX1
01X1
0011
0000
2604 # a handle that knows no bind count answers with a DBI warning; the error
2605 # handler stays silent
2606 28 ▶ my $binds = ref $exec_values eq 'ARRAY' ? scalar @$exec_values : do {
Branch: 1 branch
BranchTrueFalseTotal
ref $exec_values eq 'ARRAY' ? : 11 17 28
2607 17 ▶ local $SIG{__WARN__} = sub { };
Subroutine __ANON__: called CC=1 SCAR=0.0
2608 17 ▶ eval { $h->{NUM_OF_PARAMS} } // 0;
Condition50%1/2
eval { do { $h->{"NUM_OF_PARAMS"} } } // 0
l!l
017
MC/DC0%0/1
eval { do { $h->{"NUM_OF_PARAMS"} } } // 0
eval { do { $h->{"NUM_OF_PARAMS"} } }
Truth table50%1/2
A
A= eval { do { $h->{"NUM_OF_PARAMS"} } }
Aresult
11
00
2609 };
2610  
2611 # the statement being run through _do_query (karr k343)
2612 $msg = mask_statement_secrets($msg, $self->{_statement_in_flight})
2613 28 ▶ if defined $self->{_statement_in_flight};
Branch: 1 branch
BranchTrueFalseTotal
if defined $self->{"_statement_in_flight"} 6 22 28
2614  
2615 # the values bound to the statement stay out of the text of the engine
2616 # (ADR 0075)
2617 28 ▶ $msg = $self->_mask_error_values(
Branch: 2 branches
BranchTrueFalseTotal
ref $mask_values eq 'ARRAY' ? : 17 11 28
defined $statement && !ref($statement) && length $statement ? : 18 10 28
Condition66%4/6
defined $statement and not ref $statement and length $statement
!ll&&!rl&&r
10018
defined $statement and not ref $statement
!ll&&!rl&&r
10018
MC/DC33%1/3
defined $statement and not ref $statement and length $statement
defined $statement not ref $statement length $statement
Truth table50%2/4
A and not(B) and C
A= defined $statementB= not ref $statementC= length $statement
ABCresult
0XX0
10X0
1100
1111
2618 $msg,
2619 _plain_error_values(ref $mask_values eq 'ARRAY' ? @$mask_values : ()),
2620 (defined $statement and !ref $statement and length $statement) ? $statement : undef,
2621 );
2622  
2623 # What DBI appends on its own for a handle with ShowErrorStatement on (a
2624 # handle supplied by a coderef, 'unsafe') is replaced by the statement and
2625 # the number of its binds below. It is cut off after the values are masked:
2626 # a value that holds the marker is masked whole first.
2627 28 $msg =~ s/\s*\[for Statement ".*\z//s;
2628  
2629 28 ▶ if (defined $statement and !ref $statement and length $statement) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $statement and not ref $statement and length $statement) 18 10 28
Condition66%4/6
defined $statement and not ref $statement and length $statement
!ll&&!rl&&r
10018
defined $statement and not ref $statement
!ll&&!rl&&r
10018
MC/DC33%1/3
defined $statement and not ref $statement and length $statement
defined $statement not ref $statement length $statement
Truth table50%2/4
A and not(B) and C
A= defined $statementB= not ref $statementC= length $statement
ABCresult
0XX0
10X0
1100
1111
2630 $statement = mask_statement_secrets($statement, $self->{_statement_in_flight})
2631 18 ▶ if defined $self->{_statement_in_flight};
Branch: 1 branch
BranchTrueFalseTotal
if defined $self->{"_statement_in_flight"} 6 12 18
2632 18 ▶ $msg .= sprintf ' [for Statement "%s" with %d bind value%s]',
Branch: 1 branch
BranchTrueFalseTotal
$binds == 1 ? : 7 11 18
2633 $statement, $binds, $binds == 1 ? '' : 's';
2634 }
2635  
2636 28 my $err;
2637 0 ▶ eval { $self->throw_exception("DBI Exception: $msg"); 1 } or $err = $@;
Branch: 1 branch
BranchTrueFalseTotal
eval { do { $self->throw_exception("DBI Exception: $msg"); 1 } } or $err = $@ 0 28 28
2638  
2639 28 die _exception_as_server($err, $self->_dbi_error_fields($h));
2640 }
2641  
2642  
2643 50 ▶sub _mask_error_values {
Subroutine _mask_error_values: called CC=6 SCAR=18.4
2644 50 my ($self, $text, $values, $statement) = @_;
2645  
2646 50 ▶ return $text unless defined $text and !ref $text;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $text and not ref $text 0 50 50
Condition33%1/3
defined $text and not ref $text
!ll&&!rl&&r
0050
MC/DC0%0/2
defined $text and not ref $text
defined $text not ref $text
Truth table33%1/3
A and not(B)
A= defined $textB= not ref $text
ABresult
0X0
100
111
2647  
2648 50 my $masked = eval {
2649 50 my $dbh = $self->_dbh;
2650 my $quote = (blessed $dbh and $dbh->can('quote'))
2651 3 ▶ ? sub { $dbh->quote($_[0]) }
Subroutine __ANON__: called CC=1 SCAR=0.0
2652 50 ▶ : undef;
Branch: 1 branch
BranchTrueFalseTotal
builtin::blessed($dbh) && $dbh->can('quote') ? : 2 48 50
Condition100%3/3
builtin::blessed($dbh) and $dbh->can("quote")
!ll&&!rl&&r
12362
MC/DC100%2/2
builtin::blessed($dbh) and $dbh->can("quote")
builtin::blessed($dbh) $dbh->can("quote")
Truth table100%3/3
A and B
A= builtin::blessed($dbh)B= $dbh->can("quote")
ABresult
0X0
100
111
2653 50 mask_bound_values($text, $values, $quote);
2654 };
2655  
2656 50 ▶ return defined $masked ? $masked : $text;
Branch: 1 branch
BranchTrueFalseTotal
defined $masked ? : 50 0 50
2657 }
2658  
2659 # The values of a list of binds as the hook _mask_error_values takes them:
2660 # undef and a reference that is no plain value fall away, an object with a
2661 # stringification is its string.
2662 48 ▶sub _plain_error_values {
Subroutine _plain_error_values: called CC=6 SCAR=18.8
2663 48 my @plain;
2664 48 for my $v (@_) {
2665 28 ▶ next unless defined $v;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $v 4 24 28
2666 24 ▶ if (length ref $v) {
Branch: 1 branch
BranchTrueFalseTotal
if (length ref $v) { } 1 23 24
2667 1 ▶ my $p = is_plain_value($v) or next;
Branch: 1 branch
BranchTrueFalseTotal
my $p = &is_plain_value($v) or next 0 1 1
2668 0 ▶ push @plain, "$$p" if defined $$p;
Branch: 1 branch
BranchTrueFalseTotal
if defined $$p 0 0 0
2669 }
2670 else {
2671 23 push @plain, $v;
2672 }
2673 }
2674 48 return \@plain;
2675 }
2676  
2677 # The statement and values of a bind list for the text of an error: the
2678 # statement in placeholder form, the values raw. NoBindVars overrides this,
2679 # its statement carries the values.
2680 36 ▶sub _error_form_of_bind {
Subroutine _error_form_of_bind: called CC=2 SCAR=7.0
2681 36 my ($self, $sql, $bind) = @_;
2682 36 ▶ return ($sql, [ map { $_->[1] } @{ $bind || [] } ]);
Condition50%1/2
$bind || []
l!l
360
MC/DC0%0/1
$bind || []
$bind
Truth table50%1/2
A
A= $bind
Aresult
11
00
2683 }
2684  
2685 # A plain DBIO::Exception becomes the Server object with the same text; what
2686 # is any other class (an exception_action's own object, an object of a driver)
2687 # is left exactly as it is.
2688 28 ▶sub _exception_as_server {
Subroutine _exception_as_server: called CC=2 SCAR=6.9
2689 28 my ($err, $fields) = @_;
2690  
2691 28 ▶ return $err unless ref $err eq 'DBIO::Exception';
Branch: 1 branch
BranchTrueFalseTotal
unless ref $err eq "DBIO::Exception" 1 27 28
2692  
2693 5 my %own = map { $_ => $fields->{$_} }
2694 27 grep { defined $fields->{$_} } qw(sqlstate constraint table detail);
2695  
2696 27 return bless { %$err, %own }, 'DBIO::Exception::Server';
2697 }
2698  
2699  
2700 28 ▶sub _dbi_error_fields {
Subroutine _dbi_error_fields: called CC=7 SCAR=19.5
2701 28 my ($self, $h) = @_;
2702  
2703 my $state = blessed($h) && $h->can('state')
2704 28 ▶ ? eval { $h->state }
Branch: 1 branch
BranchTrueFalseTotal
builtin::blessed($h) && $h->can('state') ? : 8 20 28
Condition100%3/3
builtin::blessed($h) and $h->can("state")
!ll&&!rl&&r
1918
MC/DC100%2/2
builtin::blessed($h) and $h->can("state")
builtin::blessed($h) $h->can("state")
Truth table100%3/3
A and B
A= builtin::blessed($h)B= $h->can("state")
ABresult
0X0
100
111
2705 : undef;
2706  
2707 28 ▶ return {} unless defined $state && length $state
Branch: 1 branch
BranchTrueFalseTotal
unless defined $state and length $state and $state ne "00000" and $state ne "S1000" 24 4 28
Condition100%9/9
defined $state and length $state and $state ne "00000" and $state ne "S1000"
!ll&&!rl&&r
2314
defined $state and length $state and $state ne "00000"
!ll&&!rl&&r
2215
defined $state and length $state
!ll&&!rl&&r
2116
MC/DC100%4/4
defined $state and length $state and $state ne "00000" and $state ne "S1000"
defined $state length $state $state ne "00000" $state ne "S1000"
Truth table100%5/5
A and B and C and D
A= defined $stateB= length $stateC= $state ne "00000"D= $state ne "S1000"
ABCDresult
0XXX0
10XX0
110X0
11100
11111
2708 && $state ne '00000' && $state ne 'S1000';
2709 4 return { sqlstate => $state };
2710 }
2711  
2712 44 ▶sub txn_begin {
Subroutine txn_begin: called CC=2 SCAR=7.0
2713 3260 $_[0]->_assert_transaction_safe_access_broker;
2714 29 local $_[0]->{_access_broker_txn_safety_checked} = 1;
2715  
2716 # this means we have not yet connected and do not know the AC status
2717 # (e.g. coderef $dbh), need a full-fledged connection check
2718 29 ▶ if (! defined $_[0]->_dbh_autocommit) {
Branch: 1 branch
BranchTrueFalseTotal
if (not defined $_[0]->_dbh_autocommit) { } 7263 6629 13892
2719 3260 $_[0]->ensure_connected;
2720 }
2721 # Otherwise simply connect or re-connect on pid changes
2722 else {
2723 0 $_[0]->_get_dbh;
2724 }
2725  
2726 2 shift->next::method(@_);
2727 }
2728  
2729 6 ▶sub _exec_txn_begin {
Subroutine _exec_txn_begin: called CC=2 SCAR=6.9
2730 6 my $self = shift;
2731  
2732 # if the user is utilizing txn_do - good for him, otherwise we need to
2733 # ensure that the $dbh is healthy on BEGIN.
2734 # We do this via ->dbh_do instead of ->dbh, so that the ->dbh "ping"
2735 # will be replaced by a failure of begin_work itself (which will be
2736 # then retried on reconnect)
2737 6 ▶ if ($self->{_in_do_block}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->{'_in_do_block'}) { } 3 3 6
2738 3 $self->_dbh->begin_work;
2739 } else {
2740 3 ▶ $self->dbh_do(sub { $_[1]->begin_work });
Subroutine __ANON__: called CC=1 SCAR=0.0
2741 }
2742 }
2743  
2744 841 ▶sub txn_commit {
Subroutine txn_commit: called CC=7 SCAR=23.4
Pod documented
2745 841 my $self = shift;
2746  
2747 841 ▶ $self->throw_exception("Unable to txn_commit() on a disconnected storage")
Branch: 1 branch
BranchTrueFalseTotal
unless $self->_seems_connected 0 841 841
2748 unless $self->_seems_connected;
2749  
2750 # esoteric case for folks using external $dbh handles
2751 841 ▶ if (! $self->transaction_depth and ! $self->_dbh->FETCH('AutoCommit') ) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($self->transaction_depth or $self->_dbh->FETCH("AutoCommit")) 0 841 841
Condition33%1/3
$self->transaction_depth or $self->_dbh->FETCH("AutoCommit")
l!l&&r!l&&!r
84100
MC/DC0%0/2
$self->transaction_depth or $self->_dbh->FETCH("AutoCommit")
$self->transaction_depth $self->_dbh->FETCH("AutoCommit")
Truth table33%1/3
A or B
A= $self->transaction_depthB= $self->_dbh->FETCH("AutoCommit")
ABresult
1X1
011
000
2752 0 carp "Storage transaction_depth 0 does not match "
2753 ."false AutoCommit of $self->{_dbh}, attempting COMMIT anyway";
2754 0 $self->transaction_depth(1);
2755 }
2756  
2757 841 $self->next::method(@_);
2758  
2759 # if AutoCommit is disabled txn_depth never goes to 0
2760 # as a new txn is started immediately on commit
2761 833 ▶ $self->transaction_depth(1) if (
Branch: 1 branch
BranchTrueFalseTotal
if not $self->transaction_depth and defined $self->_dbh_autocommit and not $self->_dbh_autocommit 0 833 833
Condition66%4/6
not $self->transaction_depth and defined $self->_dbh_autocommit and not $self->_dbh_autocommit
!ll&&!rl&&r
6921410
not $self->transaction_depth and defined $self->_dbh_autocommit
!ll&&!rl&&r
6920141
MC/DC0%0/3
not $self->transaction_depth and defined $self->_dbh_autocommit and not $self->_dbh_autocommit
not $self->transaction_depth defined $self->_dbh_autocommit not $self->_dbh_autocommit
Truth table50%2/4
not(A) and B and not(C)
A= not $self->transaction_depthB= defined $self->_dbh_autocommitC= not $self->_dbh_autocommit
ABCresult
0XX0
10X0
1100
1111
2762 !$self->transaction_depth
2763 and
2764 defined $self->_dbh_autocommit
2765 and
2766 ! $self->_dbh_autocommit
2767 );
2768 }
2769  
2770 4 ▶sub _exec_txn_commit {
Subroutine _exec_txn_commit: called CC=1 SCAR=0.0
2771 4 shift->_dbh->commit;
2772 }
2773  
2774 85 ▶sub txn_rollback {
Subroutine txn_rollback: called CC=7 SCAR=24.5
Pod documented
2775 85 my $self = shift;
2776  
2777 85 ▶ $self->throw_exception("Unable to txn_rollback() on a disconnected storage")
Branch: 1 branch
BranchTrueFalseTotal
unless $self->_seems_connected 0 85 85
2778 unless $self->_seems_connected;
2779  
2780 # esoteric case for folks using external $dbh handles
2781 85 ▶ if (! $self->transaction_depth and ! $self->_dbh->FETCH('AutoCommit') ) {
Branch: 1 branch
BranchTrueFalseTotal
unless ($self->transaction_depth or $self->_dbh->FETCH("AutoCommit")) 0 85 85
Condition66%2/3
$self->transaction_depth or $self->_dbh->FETCH("AutoCommit")
l!l&&r!l&&!r
8410
MC/DC0%0/2
$self->transaction_depth or $self->_dbh->FETCH("AutoCommit")
$self->transaction_depth $self->_dbh->FETCH("AutoCommit")
Truth table66%2/3
A or B
A= $self->transaction_depthB= $self->_dbh->FETCH("AutoCommit")
ABresult
1X1
011
000
2782 0 carp "Storage transaction_depth 0 does not match "
2783 ."false AutoCommit of $self->{_dbh}, attempting ROLLBACK anyway";
2784 0 $self->transaction_depth(1);
2785 }
2786  
2787 85 $self->next::method(@_);
2788  
2789 # if AutoCommit is disabled txn_depth never goes to 0
2790 # as a new txn is started immediately on commit
2791 67 ▶ $self->transaction_depth(1) if (
Branch: 1 branch
BranchTrueFalseTotal
if not $self->transaction_depth and defined $self->_dbh_autocommit and not $self->_dbh_autocommit 0 67 67
Condition33%2/6
not $self->transaction_depth and defined $self->_dbh_autocommit and not $self->_dbh_autocommit
!ll&&!rl&&r
0670
not $self->transaction_depth and defined $self->_dbh_autocommit
!ll&&!rl&&r
0067
MC/DC0%0/3
not $self->transaction_depth and defined $self->_dbh_autocommit and not $self->_dbh_autocommit
not $self->transaction_depth defined $self->_dbh_autocommit not $self->_dbh_autocommit
Truth table25%1/4
not(A) and B and not(C)
A= not $self->transaction_depthB= defined $self->_dbh_autocommitC= not $self->_dbh_autocommit
ABCresult
0XX0
10X0
1100
1111
2792 !$self->transaction_depth
2793 and
2794 defined $self->_dbh_autocommit
2795 and
2796 ! $self->_dbh_autocommit
2797 );
2798 }
2799  
2800 6 ▶sub _exec_txn_rollback {
Subroutine _exec_txn_rollback: called CC=1 SCAR=0.0
2801 6 shift->_dbh->rollback;
2802 }
2803  
2804 # The one routine that drops a handle without rolling back first: used for a
2805 # handle whose rollback just failed and for the old handle a retry replaces.
2806 # Not disconnect(): that would ask the handle for a rollback again.
2807 19 ▶sub _discard_dbh {
Subroutine _discard_dbh: called CC=2 SCAR=6.9
2808 19 my $self = shift;
2809  
2810 19 ▶ if (my $dbh = $self->_dbh) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $dbh = $self->_dbh) 19 0 19
2811 19 eval {
2812 19 local $dbh->{Warn} = 0;
2813 19 %{ $dbh->{CachedKids} } = ();
2814 19 $dbh->disconnect;
2815 17 1;
2816 };
2817 19 $self->_dbh(undef);
2818 }
2819  
2820 19 $self->{transaction_depth} = 0;
2821 19 $self->savepoints([]);
2822 19 $self->deferred_rollback(undef);
2823 }
2824  
2825 13 ▶sub _abandon_after_failed_rollback {
Subroutine _abandon_after_failed_rollback: called CC=1 SCAR=0.0
2826 13 shift->_discard_dbh;
2827 }
2828  
2829 # After a failed COMMIT DBI has AutoCommit on again, so the ROLLBACK the base
2830 # tries (karr k372) would warn "rollback ineffective with AutoCommit enabled"
2831 # although it is exactly what the server needs. The attempt is silenced; the
2832 # handle's own Warn attribute is put back afterwards.
2833 8 ▶sub _abandon_after_failed_commit {
Subroutine _abandon_after_failed_commit: called CC=2 SCAR=7.0
2834 8 my $self = shift;
2835  
2836 8 my $dbh = $self->_dbh;
2837 8 ▶ return $self->next::method(@_) unless $dbh;
Branch: 1 branch
BranchTrueFalseTotal
unless $dbh 0 8 8
2838  
2839 8 local $dbh->{Warn} = 0;
2840 8 return $self->next::method(@_);
2841 }
2842  
2843 24 ▶sub _abandon_handle_before_reconnect {
Subroutine _abandon_handle_before_reconnect: called CC=2 SCAR=6.9
2844 24 my $self = shift;
2845  
2846 24 ▶ return unless $self->_dbh;
Branch: 1 branch
BranchTrueFalseTotal
unless $self->_dbh 18 6 24
2847  
2848 6 carp 'Retrying on a new connection: the old handle is disconnected, so that '
2849 . 'the block does not run a second time next to the transaction the old '
2850 . 'handle still holds open';
2851  
2852 6 $self->_discard_dbh;
2853 }
2854  
2855 # generate the DBI-specific stubs, which then fallback to ::Storage proper
2856 344 quote_sub __PACKAGE__ . "::$_" => sprintf (<<'EOS', $_) for qw(svp_begin svp_release svp_rollback);
2857 $_[0]->throw_exception('Unable to %s() on a disconnected storage')
2858 unless $_[0]->_seems_connected;
2859 shift->next::method(@_);
2860 EOS
2861  
2862 # This used to be the top-half of _execute. It was split out to make it
2863 # easier to override in NoBindVars without duping the rest. It takes up
2864 # all of _execute's args, and emits $sql, @bind.
2865 6768 ▶sub _prep_for_execute {
Subroutine _prep_for_execute: called CC=1 SCAR=0.0
2866 #my ($self, $op, $ident, $args) = @_;
2867 6768 return shift->_gen_sql_bind(@_)
2868 }
2869  
2870 7703 ▶sub _gen_sql_bind {
Subroutine _gen_sql_bind: called CC=9 SCAR=22.5
2871 7703 my ($self, $op, $ident, $args) = @_;
2872  
2873 7703 my ($colinfos, $from);
2874 7703 ▶ if ( blessed($ident) ) {
Branch: 1 branch
BranchTrueFalseTotal
if (builtin::blessed($ident)) 4619 3084 7703
2875 4619 $from = $ident->from;
2876 4619 $colinfos = $ident->columns_info;
2877 }
2878  
2879 7703 my ($sql, $bind);
2880 7703 ▶ ($sql, @$bind) = $self->sql_maker->$op( ($from || $ident), @$args );
Condition66%2/3
$from || $ident
l!l&&r!l&&!r
461930840
MC/DC0%0/2
$from || $ident
$from $ident
Truth table66%2/3
A || B
A= $fromB= $ident
ABresult
1X1
011
000
2881  
2882 $bind = $self->_resolve_bindattrs(
2883 7697 ▶ $ident, [ @{$args->[2]{bind}||[]}, @$bind ], $colinfos
Condition100%2/2
$args->[2]{'bind'} || []
l!l
24275270
MC/DC100%1/1
$args->[2]{'bind'} || []
$args->[2]{'bind'}
Truth table100%2/2
A
A= $args->[2]{'bind'}
Aresult
11
00
2884 );
2885  
2886 7697 ▶ if (
Branch: 1 branch
BranchTrueFalseTotal
if (not $ENV{"DBIO_DT_SEARCH_OK"} and $op eq "select" and grep {length ref $_->[1] and builtin::blessed($_->[1]) and $_->[1]->isa("DateTime");} @$bind) 0 7697 7697
Condition66%4/6
not $ENV{"DBIO_DT_SEARCH_OK"} and $op eq "select" and grep {length ref $_->[1] and builtin::blessed($_->[1]) and $_->[1]->isa("DateTime");} @$bind
!ll&&!rl&&r
461330840
not $ENV{"DBIO_DT_SEARCH_OK"} and $op eq "select"
!ll&&!rl&&r
046133084
MC/DC0%0/3
not $ENV{"DBIO_DT_SEARCH_OK"} and $op eq "select" and grep {length ref $_->[1] and builtin::blessed($_->[1]) and $_->[1]->isa("DateTime");} @$bind
not $ENV{"DBIO_DT_SEARCH_OK"} $op eq "select" grep {length ref $_->[1] and builtin::blessed($_->[1]) and $_->[1]->isa("DateTime");} @$bind
Truth table50%2/4
not(A) and B and C
A= not $ENV{"DBIO_DT_SEARCH_OK"}B= $op eq "select"C= grep {length ref $_->[1] and builtin::blessed($_->[1]) and $_->[1]->isa("DateTime");} @$bind
ABCresult
0XX0
10X0
1100
1111
2887 ! $ENV{DBIO_DT_SEARCH_OK}
2888 and
2889 $op eq 'select'
2890 and
2891 grep {
2892 2948 ▶ length ref $_->[1]
Condition83%5/6
length ref $_->[1] && builtin::blessed($_->[1]) && $_->[1]->isa('DateTime')
!ll&&!rl&&r
294440
length ref $_->[1] and builtin::blessed($_->[1])
!ll&&!rl&&r
293954
MC/DC0%0/3
length ref $_->[1] && builtin::blessed($_->[1]) && $_->[1]->isa('DateTime')
length ref $_->[1] builtin::blessed($_->[1]) $_->[1]->isa('DateTime')
Truth table75%3/4
A and B && C
A= length ref $_->[1]B= builtin::blessed($_->[1])C= $_->[1]->isa('DateTime')
ABCresult
0XX0
10X0
1100
1111
2893 and
2894 blessed($_->[1])
2895 and
2896 $_->[1]->isa('DateTime')
2897 } @$bind
2898 ) {
2899 0 carp_unique 'DateTime objects passed to search() are not supported '
2900 . 'properly (InflateColumn::DateTime formats and settings are not '
2901 . 'respected.) See ".. format a DateTime object for searching?" in '
2902 . 'DBIO::Manual::FAQ. To disable this warning for good '
2903 . 'set $ENV{DBIO_DT_SEARCH_OK} to true'
2904 }
2905  
2906 7697 return( $sql, $bind );
2907 }
2908  
2909 7718 ▶sub _resolve_bindattrs {
Subroutine _resolve_bindattrs: called CC=9 SCAR=22.2
2910 7718 my ($self, $ident, $bind, $colinfos) = @_;
2911  
2912 10275 ▶ my $resolve_bindinfo = sub {
Subroutine __ANON__: called CC=9 SCAR=22.8
2913 #my $infohash = shift;
2914  
2915 10275 ▶ $colinfos ||= { %{ $self->_resolve_column_info($ident) } };
Condition100%2/2
$colinfos ||= {%{$self->_resolve_column_info($ident);}}
l!l
79782297
MC/DC100%1/1
$colinfos ||= {%{$self->_resolve_column_info($ident);}}
$colinfos
Truth table100%2/2
A
A= $colinfos
Aresult
11
00
2916  
2917 10275 my $ret;
2918 10275 ▶ if (my $col = $_[0]->{dbic_colname}) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $col = $_[0]{"dbic_colname"}) 10275 0 10275
2919 10275 $ret = { %{$_[0]} };
2920  
2921 $ret->{sqlt_datatype} ||= $colinfos->{$col}{data_type}
2922 10275 ▶ if $colinfos->{$col}{data_type};
Branch: 1 branch
BranchTrueFalseTotal
if $colinfos->{$col}{"data_type"} 10229 46 10275
Condition33%1/3
$ret->{"sqlt_datatype"} ||= $colinfos->{$col}{"data_type"}
l!l&&r!l&&!r
0102290
MC/DC0%0/2
$ret->{"sqlt_datatype"} ||= $colinfos->{$col}{"data_type"}
$ret->{"sqlt_datatype"} $colinfos->{$col}{"data_type"}
Truth table33%1/3
A ||= B
A= $ret->{"sqlt_datatype"}B= $colinfos->{$col}{"data_type"}
ABresult
1X1
011
000
2923  
2924 $ret->{sqlt_size} ||= $colinfos->{$col}{size}
2925 10275 ▶ if $colinfos->{$col}{size};
Branch: 1 branch
BranchTrueFalseTotal
if $colinfos->{$col}{"size"} 5368 4907 10275
Condition33%1/3
$ret->{"sqlt_size"} ||= $colinfos->{$col}{"size"}
l!l&&r!l&&!r
053680
MC/DC0%0/2
$ret->{"sqlt_size"} ||= $colinfos->{$col}{"size"}
$ret->{"sqlt_size"} $colinfos->{$col}{"size"}
Truth table33%1/3
A ||= B
A= $ret->{"sqlt_size"}B= $colinfos->{$col}{"size"}
ABresult
1X1
011
000
2926  
2927 # the trace shows the bind of an encoded column masked
2928 $ret->{redact} = 1
2929 10275 ▶ if $colinfos->{$col}{encode_column};
Branch: 1 branch
BranchTrueFalseTotal
if $colinfos->{$col}{"encode_column"} 10 10265 10275
2930 }
2931  
2932 10275 ▶ $ret || $_[0];
Branch: 1 branch
BranchTrueFalseTotal
$ret or $_[0] 10275 0 10275
2933 7718 };
2934  
2935 return [ map {
2936 7718 ( ref $_ ne 'ARRAY' or @$_ != 2 ) ? [ {}, $_ ]
2937 : ( ! defined $_->[0] ) ? [ {}, $_->[1] ]
2938 : (ref $_->[0] eq 'HASH') ? [(
2939 351 ▶ ! keys %{$_->[0]}
Branch: 1 branch
BranchTrueFalseTotal
ref $_->[0] eq 'SCALAR' ? : 4 10259 10263
2940 or
2941 exists $_->[0]{dbd_attrs}
2942 or
2943 $_->[0]{sqlt_datatype}
2944 ) ? $_->[0]
2945 : $resolve_bindinfo->($_->[0])
2946 , $_->[1]
2947 ]
2948 10633 ▶ : (ref $_->[0] eq 'SCALAR') ? [ { sqlt_datatype => ${$_->[0]} }, $_->[1] ]
Branch: 4 branches
BranchTrueFalseTotal
ref $_ ne 'ARRAY' || @$_ != 2 ? : 18 10615 10633
!defined($_->[0]) ? : 1 10614 10615
ref $_->[0] eq 'HASH' ? : 351 10263 10614
!keys(%{$$_[0];}) || exists $_->[0]{'dbd_attrs'} || $_->[0]{'sqlt_datatype'} ? : 335 16 351
Condition88%8/9
ref $_ ne "ARRAY" or @$_ != 2
l!l&&r!l&&!r
16210615
not keys %{$$_[0];} or exists $_->[0]{"dbd_attrs"} or $_->[0]{"sqlt_datatype"}
l!l&&r!l&&!r
533016
not keys %{$$_[0];} or exists $_->[0]{"dbd_attrs"}
l!l&&r!l&&!r
50346
MC/DC100%2/2
ref $_ ne "ARRAY" or @$_ != 2
ref $_ ne "ARRAY" @$_ != 2
MC/DC66%2/3
not keys %{$$_[0];} or exists $_->[0]{"dbd_attrs"} or $_->[0]{"sqlt_datatype"}
not keys %{$$_[0];} exists $_->[0]{"dbd_attrs"} $_->[0]{"sqlt_datatype"}
Truth table100%3/3
A or B
A= ref $_ ne "ARRAY"B= @$_ != 2
ABresult
1X1
011
000
Truth table75%3/4
not(A) or B or C
A= not keys %{$$_[0];}B= exists $_->[0]{"dbd_attrs"}C= $_->[0]{"sqlt_datatype"}
ABCresult
1XX1
01X1
0011
0000
2949 : [ $resolve_bindinfo->(
2950 { dbic_colname => $_->[0] }
2951 ), $_->[1] ]
2952 } @$bind ];
2953 }
2954  
2955 6894 ▶sub _format_for_trace {
Subroutine _format_for_trace: called CC=8 SCAR=20.8
2956 6894 my $self = $_[0];
2957  
2958 ### Turn @bind from something like this:
2959 ### ( [ "artist", 1 ], [ \%attrs, 3 ] )
2960 ### to this:
2961 ### ( "'1'", "'3'" )
2962 ###
2963 ### Bind values are traced from level 2 on (DBIO_TRACE=2, debug(2)); level 1
2964 ### traces the statement alone. Each value is run through the
2965 ### L</redact_bind_value> hook before interpolation so that credential / PII
2966 ### columns do not leak into the trace sink, then cut to 32 characters with
2967 ### '...' marking the cut. The hook receives the column name (or undef if no
2968 ### column metadata is attached to the bind slot), the raw value and the
2969 ### bind attribute hash, and must return the value to interpolate.
2970  
2971 6894 ▶ return () unless ($self->debug || 0) >= 2;
Branch: 1 branch
BranchTrueFalseTotal
unless ($self->debug || 0) >= 2 6858 36 6894
Condition100%2/2
$self->debug || 0
l!l
456849
MC/DC100%1/1
$self->debug || 0
$self->debug
Truth table100%2/2
A
A= $self->debug
Aresult
11
00
2972  
2973 36 my $redact = $self->redact_bind_value;
2974  
2975 map {
2976 34 ▶ my $val = $_ && $_->[1];
Condition66%2/3
$_ && $_->[1]
!ll&&!rl&&r
0232
MC/DC50%1/2
$_ && $_->[1]
$_ $_->[1]
Truth table66%2/3
A && B
A= $_B= $_->[1]
ABresult
0X0
100
111
2977 34 ▶ if (defined $val) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $val) { } 32 2 34
2978 my $colname = ( ref( $_->[0] ) eq 'HASH' )
2979 ? $_->[0]{dbic_colname}
2980 32 ▶ : undef;
Branch: 1 branch
BranchTrueFalseTotal
ref $_->[0] eq 'HASH' ? : 31 1 32
2981 32 my $shown = $redact->( $colname, $val, $_->[0] );
2982 32 ▶ $shown = substr($shown, 0, 32) . '...' if length($shown) > 32;
Branch: 1 branch
BranchTrueFalseTotal
if length $shown > 32 2 30 32
2983 32 qq{'$shown'};
2984 }
2985 else {
2986 2 q{NULL};
2987 }
2988 36 ▶ } @{$_[1] || []};
Condition50%1/2
$_[1] || []
l!l
360
MC/DC0%0/1
$_[1] || []
$_[1]
Truth table50%1/2
A
A= $_[1]
Aresult
11
00
2989 }
2990  
2991  
2992 # The statement of a connect action is traced as its fingerprint form: a secret
2993 # it carries shows as ***[sha256:<8 hex>] (karr k343 (3), k392).
2994 13776 ▶sub _trace_statement {
Subroutine _trace_statement: called CC=2 SCAR=6.9
2995 13776 my ($self, $sql) = @_;
2996 return defined $self->{_statement_in_flight}
2997 13776 ▶ ? mask_statement_fingerprint($sql)
Branch: 1 branch
BranchTrueFalseTotal
defined $self->{'_statement_in_flight'} ? : 103 13673 13776
2998 : $sql;
2999 }
3000  
3001 6899 ▶sub _query_start {
Subroutine _query_start: called CC=3 SCAR=11.0
3002 6899 my ( $self, $sql, $bind ) = @_;
3003 6899 $sql = $self->_trace_statement($sql);
3004  
3005 6899 ▶ if ($self->debug) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->debug) { } 31 6868 6899
3006 31 my @trace = $self->_format_for_trace($bind);
3007 # Always pass at least one element when debug is on so that
3008 # Statistics::query_start produces output even for no-bind queries
3009 31 ▶ $self->debugobj->query_start($sql, @trace ? @trace : '');
Branch: 1 branch
BranchTrueFalseTotal
@trace ? : 22 9 31
3010 } else {
3011 6868 $self->debugobj->query_start($sql);
3012 }
3013 }
3014  
3015 6877 ▶sub _query_end {
Subroutine _query_end: called CC=1 SCAR=0.0
3016 6877 my ( $self, $sql, $bind ) = @_;
3017 6877 $sql = $self->_trace_statement($sql);
3018  
3019 6877 $self->debugobj->query_end(
3020 $sql,
3021 $self->_format_for_trace($bind),
3022 );
3023 }
3024  
3025 31 ▶sub _dbi_attrs_for_bind {
Subroutine _dbi_attrs_for_bind: called CC=7 SCAR=27.6
3026 31 my ($self, $ident, $bind) = @_;
3027  
3028 31 my @attrs;
3029  
3030 31 for (map { $_->[0] } @$bind) {
3031 11 push @attrs, do {
3032 11 ▶ if (exists $_->{dbd_attrs}) {
Branch: 2 branches
BranchTrueFalseTotal
if (exists $_->{'dbd_attrs'}) { } 0 11 11
elsif ($_->{'sqlt_datatype'}) { } 0 11 11
3033 $_->{dbd_attrs}
3034 0 }
3035 elsif($_->{sqlt_datatype}) {
3036 # cache the result in the dbh_details hash, as it can not change unless
3037 # we connect to something else
3038 0 ▶ my $cache = $self->_dbh_details->{_datatype_map_cache} ||= {};
Condition0%0/2
$self->_dbh_details->{"_datatype_map_cache"} ||= {}
l!l
00
MC/DC0%0/1
$self->_dbh_details->{"_datatype_map_cache"} ||= {}
$self->_dbh_details->{"_datatype_map_cache"}
Truth table0%0/2
A
A= $self->_dbh_details->{"_datatype_map_cache"}
Aresult
11
00
3039 0 ▶ if (not exists $cache->{$_->{sqlt_datatype}}) {
Branch: 1 branch
BranchTrueFalseTotal
unless (exists $$cache{$_->{"sqlt_datatype"}}) 0 0 0
3040 0 ▶ $cache->{$_->{sqlt_datatype}} = $self->bind_attribute_by_data_type($_->{sqlt_datatype}) || undef;
Condition0%0/2
$self->bind_attribute_by_data_type($_->{'sqlt_datatype'}) || undef
l!l
00
MC/DC0%0/1
$self->bind_attribute_by_data_type($_->{'sqlt_datatype'}) || undef
$self->bind_attribute_by_data_type($_->{'sqlt_datatype'})
Truth table0%0/2
A
A= $self->bind_attribute_by_data_type($_->{'sqlt_datatype'})
Aresult
11
00
3041 }
3042 0 $cache->{$_->{sqlt_datatype}};
3043 }
3044 else {
3045 11 undef; # always push something at this position
3046 }
3047 }
3048 }
3049  
3050 31 return \@attrs;
3051 }
3052  
3053 16 ▶sub _execute {
Subroutine _execute: called CC=2 SCAR=6.9
3054 16 my ($self, $op, $ident, @args) = @_;
3055  
3056 16 my ($sql, $bind) = $self->_prep_for_execute($op, $ident, \@args);
3057  
3058 # not even a PID check - we do not care about the state of the _dbh.
3059 # All we need is to get the appropriate drivers loaded if they aren't
3060 # already so that the assumption in ad7c50fc26e holds
3061 16 ▶ $self->_populate_dbh unless $self->_dbh;
Branch: 1 branch
BranchTrueFalseTotal
unless $self->_dbh 8 8 16
3062  
3063 16 $self->dbh_do( _dbh_execute => # retry over disconnects
3064 $sql,
3065 $bind,
3066 $self->_dbi_attrs_for_bind($ident, $bind),
3067 );
3068 }
3069  
3070 32 ▶sub _dbh_execute {
Subroutine _dbh_execute: called CC=5 SCAR=17.6
3071 32 my ($self, $dbh, $sql, $bind, $bind_attrs) = @_;
3072  
3073 # for the error text of _dbi_handle_error: the statement in placeholder
3074 # form and the values bound to it (their number, and the values the hook
3075 # _mask_error_values takes out of the text of the engine)
3076 32 my ($shown_sql, $values) = $self->_error_form_of_bind($sql, $bind);
3077 32 local $self->{_exec_in_flight} = [ $shown_sql, $values ];
3078  
3079 32 $self->_query_start( $sql, $bind );
3080  
3081 32 my $sth = $self->_bind_sth_params(
3082 $self->_prepare_sth($dbh, $sql),
3083 $bind,
3084 $bind_attrs,
3085 );
3086  
3087 # Can this fail without throwing an exception anyways???
3088 31 my ($rv, $messages) = $self->_execute_sth($dbh, $sth);
3089 24 ▶ $self->throw_exception($self->_mask_error_values(
Branch: 1 branch
BranchTrueFalseTotal
unless $rv 0 24 24
Condition0%0/5
$sth->errstr || $sth->err || 'Unknown error: execute() returned false, but error flags were not set...'
l!l
00
$sth->errstr or $sth->err
l!l&&r!l&&!r
000
MC/DC0%0/2
$sth->errstr || $sth->err || 'Unknown error: execute() returned false, but error flags were not set...'
$sth->errstr $sth->err
Truth table0%0/3
A or B
A= $sth->errstrB= $sth->err
ABresult
1X1
011
000
3090 $sth->errstr || $sth->err || 'Unknown error: execute() returned false, but error flags were not set...',
3091 _plain_error_values(@$values),
3092 $shown_sql,
3093 )) if !$rv;
3094  
3095 24 $self->_server_messages($messages);
3096 24 $self->_query_end( $sql, $bind );
3097  
3098 24 ▶ return (wantarray ? ($rv, $sth, @$bind) : $rv);
Branch: 1 branch
BranchTrueFalseTotal
wantarray ? : 20 4 24
3099 }
3100  
3101  
3102 5806 ▶sub _execute_sth {
Subroutine _execute_sth: called CC=1 SCAR=0.0
3103 5806 my ($self, $dbh, $sth) = @_;
3104 5806 my $rv = $sth->execute;
3105 5800 return ($rv, undef);
3106 }
3107  
3108 # ADR 0040 section 6: the prepare-only half of _dbh_execute, for
3109 # L</_prepare_rendered> -- everything that method does except the one verb in
3110 # the middle.
3111 #
3112 # Deliberately NOT factored out of _dbh_execute. Calling this from there would
3113 # put _query_end *before* $sth->execute, and the start/end pair is what the
3114 # trace sink measures a statement's runtime with (DBIO::Storage::Debug::PrettyPrint
3115 # and every profiler built on DBIO::Storage::Statistics). Three shared lines are
3116 # cheaper than changing what a timing number on the hot path means.
3117 7 ▶sub _dbh_prepare {
Subroutine _dbh_prepare: called CC=1 SCAR=0.0
3118 7 my ($self, $dbh, $sql, $bind, $bind_attrs) = @_;
3119  
3120 7 my ($shown_sql, $values) = $self->_error_form_of_bind($sql, $bind);
3121 7 local $self->{_exec_in_flight} = [ $shown_sql, $values ];
3122  
3123 7 $self->_query_start( $sql, $bind );
3124  
3125 7 my $sth = $self->_bind_sth_params(
3126 $self->_prepare_sth($dbh, $sql),
3127 $bind,
3128 $bind_attrs,
3129 );
3130  
3131 6 $self->_query_end( $sql, $bind );
3132  
3133 6 return $sth;
3134 }
3135  
3136 33 ▶sub _prepare_sth {
Subroutine _prepare_sth: called CC=5 SCAR=20.1
3137 33 my ($self, $dbh, $sql) = @_;
3138  
3139 # 3 is the if_active parameter which avoids active sth re-use
3140 33 ▶ my $sth = $self->disable_sth_caching
Branch: 1 branch
BranchTrueFalseTotal
$self->disable_sth_caching ? : 1 32 33
3141 ? $dbh->prepare($sql)
3142 : $dbh->prepare_cached($sql, {}, 3);
3143  
3144 # XXX You would think RaiseError would make this impossible,
3145 # but apparently that's not true :(
3146 $self->throw_exception(
3147 $dbh->errstr
3148 ||
3149 sprintf( "\$dbh->prepare() of '%s' through %s failed *silently* without "
3150 .'an exception and/or setting $dbh->errstr',
3151 length ($sql) > 20
3152 ? substr($sql, 0, 20) . '...'
3153 : $sql
3154 ,
3155 'DBD::' . $dbh->{Driver}{Name},
3156 )
3157 31 ▶ ) if !$sth;
Branch: 2 branches
BranchTrueFalseTotal
unless $sth 0 31 31
length $sql > 20 ? : 0 0 0
Condition0%0/3
$dbh->errstr || sprintf(q[$dbh->prepare() of '%s' through %s failed *silently* without an exception and/or setting $dbh->errstr], length $sql > 20 ? substr($sql, 0, 20) . '...' : $sql, 'DBD::' . $dbh->{'Driver'}{'Name'})
l!l&&r!l&&!r
000
MC/DC0%0/2
$dbh->errstr || sprintf(q[$dbh->prepare() of '%s' through %s failed *silently* without an exception and/or setting $dbh->errstr], length $sql > 20 ? substr($sql, 0, 20) . '...' : $sql, 'DBD::' . $dbh->{'Driver'}{'Name'})
$dbh->errstr sprintf(q[$dbh->prepare() of '%s' through %s failed *silently* without an exception and/or setting $dbh->errstr], length $sql > 20 ? substr($sql, 0, 20) . '...' : $sql, 'DBD::' . $dbh->{'Driver'}{'Name'})
Truth table0%0/3
A || B
A= $dbh->errstrB= sprintf(q[$dbh->prepare() of '%s' through %s failed *silently* without an exception and/or setting $dbh->errstr], length $sql > 20 ? substr($sql, 0, 20) . '...' : $sql, 'DBD::' . $dbh->{'Driver'}{'Name'})
ABresult
1X1
011
000
3158  
3159 31 $sth;
3160 }
3161  
3162  
3163 32 ▶sub _adjust_bind_values { $_[2] }
Subroutine _adjust_bind_values: called CC=1 SCAR=0.0
3164  
3165 38 ▶sub _bind_sth_params {
Subroutine _bind_sth_params: called CC=6 SCAR=20.9
3166 38 my ($self, $sth, $bind, $bind_attrs) = @_;
3167  
3168 38 $bind = $self->_adjust_bind_values($sth, $bind, $bind_attrs);
3169  
3170 38 for my $i (0 .. $#$bind) {
3171 20 ▶ if (ref $bind->[$i][1] eq 'SCALAR') { # any scalarrefs are assumed to be bind_inouts
Branch: 1 branch
BranchTrueFalseTotal
if (ref $bind->[$i][1] eq 'SCALAR') { } 0 20 20
3172 $sth->bind_param_inout(
3173 $i + 1, # bind params counts are 1-based
3174 $bind->[$i][1],
3175 0 ▶ $bind->[$i][0]{dbd_size} || $self->_max_column_bytesize($bind->[$i][0]), # size
Condition0%0/3
$bind->[$i][0]{'dbd_size'} || $self->_max_column_bytesize($bind->[$i][0])
l!l&&r!l&&!r
000
MC/DC0%0/2
$bind->[$i][0]{'dbd_size'} || $self->_max_column_bytesize($bind->[$i][0])
$bind->[$i][0]{'dbd_size'} $self->_max_column_bytesize($bind->[$i][0])
Truth table0%0/3
A || B
A= $bind->[$i][0]{'dbd_size'}B= $self->_max_column_bytesize($bind->[$i][0])
ABresult
1X1
011
000
3176 $bind_attrs->[$i],
3177 );
3178 }
3179 else {
3180 # FIXME SUBOPTIMAL - DBI needs fixing to always stringify regardless of DBD
3181 20 ▶ my $v = ( length ref $bind->[$i][1] and is_plain_value $bind->[$i][1] )
Branch: 1 branch
BranchTrueFalseTotal
length ref $bind->[$i][1] && &is_plain_value($bind->[$i][1]) ? : 0 20 20
Condition66%2/3
length ref $bind->[$i][1] and &is_plain_value($bind->[$i][1])
!ll&&!rl&&r
1910
MC/DC0%0/2
length ref $bind->[$i][1] and &is_plain_value($bind->[$i][1])
length ref $bind->[$i][1] &is_plain_value($bind->[$i][1])
Truth table66%2/3
A and B
A= length ref $bind->[$i][1]B= &is_plain_value($bind->[$i][1])
ABresult
0X0
100
111
3182 ? "$bind->[$i][1]"
3183 : $bind->[$i][1]
3184 ;
3185  
3186 20 $sth->bind_param(
3187 $i + 1,
3188 # The temp-var is CRUCIAL - DO NOT REMOVE IT, breaks older DBD::SQLite RT#79576
3189 $v,
3190 $bind_attrs->[$i],
3191 );
3192 }
3193 }
3194  
3195 38 $sth;
3196 }
3197  
3198 3272 ▶sub _prefetch_autovalues {
Subroutine _prefetch_autovalues: called CC=10 SCAR=23.1
3199 3272 my ($self, $source, $colinfo, $to_insert) = @_;
3200  
3201 3272 my %values;
3202 3272 for my $col (keys %$colinfo) {
3203 13912 ▶ if (
Branch: 1 branch
BranchTrueFalseTotal
if ($colinfo->{$col}{"auto_nextval"} and !exists $to_insert->{$col} || &is_literal_value($to_insert->{$col})) 25 13887 13912
Condition100%6/6
$colinfo->{$col}{"auto_nextval"} and !exists $to_insert->{$col} || &is_literal_value($to_insert->{$col})
!ll&&!rl&&r
13882525
not exists $to_insert->{$col} or &is_literal_value($to_insert->{$col})
l!l&&r!l&&!r
2145
MC/DC100%3/3
$colinfo->{$col}{"auto_nextval"} and !exists $to_insert->{$col} || &is_literal_value($to_insert->{$col})
$colinfo->{$col}{"auto_nextval"} not exists $to_insert->{$col} &is_literal_value($to_insert->{$col})
Truth table100%4/4
A and not(B) or C
A= $colinfo->{$col}{"auto_nextval"}B= not exists $to_insert->{$col}C= &is_literal_value($to_insert->{$col})
ABCresult
0XX0
1000
11X1
1011
3204 $colinfo->{$col}{auto_nextval}
3205 and
3206 (
3207 ! exists $to_insert->{$col}
3208 or
3209 is_literal_value($to_insert->{$col})
3210 )
3211 ) {
3212 # Both methods are a driver's: one whose engine has no sequences brings
3213 # neither, and this class has none to fall back on. Whether they are
3214 # there is a fact about the class -- insert() has run the driver
3215 # determination by now -- so it is asked before _get_dbh below, and a
3216 # storage without sequences refuses without connecting (karr k302).
3217 25 ▶ if (my @missing = grep { ! $self->can($_) } (
Branch: 2 branches
BranchTrueFalseTotal
if (my(@missing) = grep({not $self->can($_);} "_sequence_fetch", $colinfo->{$col}{"sequence"} ? () : "_dbh_get_autoinc_seq")) 12 13 25
$colinfo->{$col}{'sequence'} ? : 13 12 25
3218 '_sequence_fetch',
3219 ( $colinfo->{$col}{sequence} ? () : '_dbh_get_autoinc_seq' ),
3220 )) {
3221 12 my $table = $source->name;
3222  
3223 $self->throw_exception( sprintf(
3224 "Unable to fetch a value for column '%s' of %s (table %s): it is "
3225 . 'marked auto_nextval, but the storage %s has no sequence support '
3226 . '(no %s). %s, or remove auto_nextval from its column info; for a '
3227 . 'GUID column see DBIO::Storage::DBI::UniqueIdentifier',
3228 $col,
3229 $source->source_name,
3230 ( ref $table eq 'SCALAR' ? $$table : $table ),
3231 ref $self,
3232 join(' and ', @missing),
3233 12 ▶ ( exists $to_insert->{$col}
Branch: 2 branches
BranchTrueFalseTotal
ref $table eq 'SCALAR' ? : 0 12 12
exists $to_insert->{$col} ? : 2 10 12
3234 ? 'Literal SQL for the column does not stand in for the sequence: '
3235 . 'give it a plain value'
3236 : 'Give the column a value on insert'
3237 ),
3238 ));
3239 }
3240  
3241 $values{$col} = $self->_sequence_fetch(
3242 'NEXTVAL',
3243 ( $colinfo->{$col}{sequence} ||=
3244 13 ▶ $self->_dbh_get_autoinc_seq($self->_get_dbh, $source, $col)
Condition66%2/3
$colinfo->{$col}{"sequence"} ||= $self->_dbh_get_autoinc_seq($self->_get_dbh, $source, $col)
l!l&&r!l&&!r
940
MC/DC0%0/2
$colinfo->{$col}{"sequence"} ||= $self->_dbh_get_autoinc_seq($self->_get_dbh, $source, $col)
$colinfo->{$col}{"sequence"} $self->_dbh_get_autoinc_seq($self->_get_dbh, $source, $col)
Truth table66%2/3
A ||= B
A= $colinfo->{$col}{"sequence"}B= $self->_dbh_get_autoinc_seq($self->_get_dbh, $source, $col)
ABresult
1X1
011
000
3245 ),
3246 );
3247 }
3248 }
3249  
3250 3260 \%values;
3251 }
3252  
3253 # ADR 0036: the optional $opts hashref is the atomic-upsert transport. It is
3254 # read (and written back to) by DBIO::ResultSet::upsert only -- a plain insert
3255 # passes nothing and behaves exactly as before.
3256 #
3257 # on_conflict => \%normalized the structure handed on to
3258 # sql_maker->insert as $options->{on_conflict};
3259 # only a driver SQLMaker understands it, so
3260 # the storage refuses to emit it unless the
3261 # driver declares the supports_upsert
3262 # capability -- and its optional 'where' key
3263 # (the conditional DO UPDATE) unless the
3264 # driver declares supports_upsert_where too
3265 # no_retrieve => 1 skip all identity retrieval (RETURNING tail,
3266 # last_insert_id, follow-up SELECT) -- one
3267 # round-trip, for result => 'void' / 'count'
3268 #
3269 # and on return:
3270 #
3271 # affected_rows => $rv the statement's return value
3272 0 ▶sub insert {
Subroutine insert: not called CC=43 SCAR=44.1
3273 1 my ($self, $source, $to_insert, $opts) = @_;
3274  
3275 3261 my $col_infos = $source->columns_info;
3276  
3277 3260 my $prefetched_values = $self->_prefetch_autovalues($source, $col_infos, $to_insert);
3278  
3279 # fuse the values, but keep a separate list of prefetched_values so that
3280 # they can be fused once again with the final return
3281 3261 $to_insert = { %$to_insert, %$prefetched_values };
3282  
3283 3261 my %pcols = map { $_ => 1 } $source->primary_columns;
3284  
3285 8 my (%retrieve_cols, $autoinc_supplied, $retrieve_autoinc_col, $pk_supplied);
3286  
3287 1 for my $col ($source->columns) {
3288  
3289 # first autoinc wins - this is why ->columns() in-order iteration is important
3290 #
3291 # FIXME - there ought to be a sanity-check for multiple is_auto_increment settings
3292 # or something...
3293 #
3294 3261 ▶ if ($col_infos->{$col}{is_auto_increment}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($col_infos->{$col}{"is_auto_increment"}) 2363 4266 6629
3295  
3296 # FIXME - we seem to assume undef values as non-supplied.
3297 # This is wrong.
3298 # Investigate what does it take to s/defined/exists/
3299 # ( fails t/cdbi/copy.t amoong other things )
3300 64 ▶ $autoinc_supplied ||= 1 if defined $to_insert->{$col};
Branch: 1 branch
BranchTrueFalseTotal
if defined $to_insert->{$col} 29 3231 3260
Condition100%3/3
$autoinc_supplied ||= 1
l!l
72432010
MC/DC100%1/1
$autoinc_supplied ||= 1
$autoinc_supplied
Truth table100%2/2
A
A= $autoinc_supplied
Aresult
11
00
3301  
3302 62 ▶ $retrieve_autoinc_col ||= $col unless $autoinc_supplied;
Branch: 1 branch
BranchTrueFalseTotal
unless $autoinc_supplied 0 3260 3260
Condition66%2/3
$retrieve_autoinc_col ||= $col
l!l&&r!l&&!r
236204266
MC/DC50%1/2
$retrieve_autoinc_col ||= $col
$retrieve_autoinc_col $col
Truth table66%2/3
A ||= B
A= $retrieve_autoinc_colB= $col
ABresult
1X1
011
000
3303 }
3304  
3305 # Track if any primary key column has a supplied value (including scalar references)
3306 61 ▶ if ($pcols{$col}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($pcols{$col}) 8 3253 3261
3307 $pk_supplied ||= 1 if (
3308 defined $to_insert->{$col}
3309 and
3310 (
3311 # not a ref - cheaper to check before a call to is_literal_value()
3312 ! length ref $to_insert->{$col}
3313 or
3314 # is a literal value (like scalar references for database functions)
3315 3258 ▶ is_literal_value( $to_insert->{$col} )
Branch: 1 branch
BranchTrueFalseTotal
if defined $to_insert->{$col} and !length(ref $to_insert->{$col}) || &is_literal_value($to_insert->{$col}) 0 7 7
Condition88%8/9
defined $to_insert->{$col} and !length(ref $to_insert->{$col}) || &is_literal_value($to_insert->{$col})
!ll&&!rl&&r
31963529
not length ref $to_insert->{$col} or &is_literal_value($to_insert->{$col})
l!l&&r!l&&!r
3240200
$pk_supplied ||= 1
l!l
239684420
MC/DC0%0/3
defined $to_insert->{$col} and !length(ref $to_insert->{$col}) || &is_literal_value($to_insert->{$col})
defined $to_insert->{$col} not length ref $to_insert->{$col} &is_literal_value($to_insert->{$col})
MC/DC100%1/1
$pk_supplied ||= 1
$pk_supplied
Truth table0%0/4
A and not(B) or C
A= defined $to_insert->{$col}B= not length ref $to_insert->{$col}C= &is_literal_value($to_insert->{$col})
ABCresult
0XX0
1000
11X1
1011
Truth table100%2/2
A
A= $pk_supplied
Aresult
11
00
3316 )
3317 );
3318 }
3319  
3320 # nothing to retrieve when explicit values are supplied
3321 next if (
3322 # FIXME - we seem to assume undef values as non-supplied.
3323 # This is wrong.
3324 # Investigate what does it take to s/defined/exists/
3325 # ( fails t/cdbi/copy.t amoong other things )
3326 defined $to_insert->{$col}
3327 and
3328 (
3329 # not a ref - cheaper to check before a call to is_literal_value()
3330 ! length ref $to_insert->{$col}
3331 or
3332 # not a literal we *MAY* need to pull out ( see check below )
3333 3242 ▶ ! is_literal_value( $to_insert->{$col} )
Branch: 1 branch
BranchTrueFalseTotal
if defined $to_insert->{$col} and not length ref $to_insert->{$col} && &is_literal_value($to_insert->{$col}) 64 3196 3260
Condition50%3/6
defined $to_insert->{$col} and not length ref $to_insert->{$col} && &is_literal_value($to_insert->{$col})
!ll&&!rl&&r
502346864
length ref $to_insert->{$col} && &is_literal_value($to_insert->{$col})
!ll&&!rl&&r
000
MC/DC0%0/3
defined $to_insert->{$col} and not length ref $to_insert->{$col} && &is_literal_value($to_insert->{$col})
defined $to_insert->{$col} length ref $to_insert->{$col} &is_literal_value($to_insert->{$col})
Truth table0%0/4
A and not(B && C)
A= defined $to_insert->{$col}B= length ref $to_insert->{$col}C= &is_literal_value($to_insert->{$col})
ABCresult
0XX0
1110
10X1
1101
3334 )
3335 );
3336  
3337 # the 'scalar keys' is a trick to preserve the ->columns declaration order
3338 $retrieve_cols{$col} = scalar keys %retrieve_cols if (
3339 $pcols{$col}
3340 or
3341 $col_infos->{$col}{retrieve_on_insert}
3342 3241 ▶ );
Branch: 1 branch
BranchTrueFalseTotal
if $pcols{$col} or $col_infos->{$col}{"retrieve_on_insert"} 64 3196 3260
Condition0%0/3
$pcols{$col} or $col_infos->{$col}{"retrieve_on_insert"}
l!l&&r!l&&!r
000
MC/DC0%0/2
$pcols{$col} or $col_infos->{$col}{"retrieve_on_insert"}
$pcols{$col} $col_infos->{$col}{"retrieve_on_insert"}
Truth table0%0/3
A or B
A= $pcols{$col}B= $col_infos->{$col}{"retrieve_on_insert"}
ABresult
1X1
011
000
3343 };
3344  
3345 # An upsert asking for result => 'void' / 'count' wants exactly one
3346 # round-trip and no identity work (ADR 0036 section 4).
3347 3241 ▶ if ($opts and $opts->{no_retrieve}) {
Branch: 1 branch
BranchTrueFalseTotal
if ($opts and $opts->{"no_retrieve"}) 2 62 64
Condition100%3/3
$opts and $opts->{"no_retrieve"}
!ll&&!rl&&r
91423397
MC/DC100%2/2
$opts and $opts->{"no_retrieve"}
$opts $opts->{"no_retrieve"}
Truth table100%3/3
A and B
A= $optsB= $opts->{"no_retrieve"}
ABresult
0X0
100
111
3348 7 %retrieve_cols = ();
3349 7 undef $retrieve_autoinc_col;
3350 }
3351  
3352 # corner case of a non-supplied PK which is *not* declared as autoinc
3353 7 ▶ if (
Branch: 1 branch
BranchTrueFalseTotal
if (not $autoinc_supplied || defined $retrieve_autoinc_col || $pk_supplied and ($retrieve_autoinc_col) = grep({$pcols{$_} and not $col_infos->{$_}{"retrieve_on_insert"} and not defined $col_infos->{$_}{"is_auto_increment"};} (sort {$retrieve_cols{$a} <=> $retrieve_cols{$b};} keys %retrieve_cols))) 1 61 62
Condition100%3/3
not $autoinc_supplied || defined $retrieve_autoinc_col || $pk_supplied and ($retrieve_autoinc_col) = grep({$pcols{$_} and not $col_infos->{$_}{"retrieve_on_insert"} and not defined $col_infos->{$_}{"is_auto_increment"};} (sort {$retrieve_cols{$a} <=> $retrieve_cols{$b};} keys %retrieve_cols))
!ll&&!rl&&r
5561
MC/DC100%2/2
not $autoinc_supplied || defined $retrieve_autoinc_col || $pk_supplied and ($retrieve_autoinc_col) = grep({$pcols{$_} and not $col_infos->{$_}{"retrieve_on_insert"} and not defined $col_infos->{$_}{"is_auto_increment"};} (sort {$retrieve_cols{$a} <=> $retrieve_cols{$b};} keys %retrieve_cols))
not $autoinc_supplied || defined $retrieve_autoinc_col || $pk_supplied ($retrieve_autoinc_col) = grep({$pcols{$_} and not $col_infos->{$_}{"retrieve_on_insert"} and not defined $col_infos->{$_}{"is_auto_increment"};} (sort {$retrieve_cols{$a} <=> $retrieve_cols{$b};} keys %retrieve_cols))
Truth table100%3/3
not(A) and B
A= not $autoinc_supplied || defined $retrieve_autoinc_col || $pk_suppliedB= ($retrieve_autoinc_col) = grep({$pcols{$_} and not $col_infos->{$_}{"retrieve_on_insert"} and not defined $col_infos->{$_}{"is_auto_increment"};} (sort {$retrieve_cols{$a} <=> $retrieve_cols{$b};} keys %retrieve_cols))
ABresult
0X0
100
111
3354 ! $autoinc_supplied
3355 and
3356 ! defined $retrieve_autoinc_col
3357 and
3358 ! $pk_supplied
3359 and
3360 # FIXME - first come-first serve, suboptimal...
3361 ($retrieve_autoinc_col) = ( grep
3362 {
3363 $pcols{$_}
3364 and
3365 ! $col_infos->{$_}{retrieve_on_insert}
3366 and
3367 ! defined $col_infos->{$_}{is_auto_increment}
3368 3234 }
3369 sort
3370 2326 { $retrieve_cols{$a} <=> $retrieve_cols{$b} }
3371 keys %retrieve_cols
3372 )
3373 ) {
3374 2326 carp_unique(
3375 "Missing value for primary key column '$retrieve_autoinc_col' on "
3376 2326 . "@{[ $source->source_name ]} - perhaps you forgot to set its "
3377 . "'is_auto_increment' attribute during add_columns()? Treating "
3378 . "'$retrieve_autoinc_col' implicitly as an autoinc, and attempting "
3379 . 'value retrieval'
3380 );
3381 }
3382  
3383 2326 local $self->{_autoinc_supplied_for_op} = $autoinc_supplied;
3384 2326 local $self->{_perform_autoinc_retrieval} = $retrieve_autoinc_col;
3385  
3386 2326 my ($sqla_opts, @ir_container);
3387 3234 ▶ if (%retrieve_cols and $self->_use_insert_returning) {
Branch: 1 branch
BranchTrueFalseTotal
if (%retrieve_cols and $self->_use_insert_returning) 58 3183 3241
3388 $sqla_opts->{returning_container} = \@ir_container
3389 0 ▶ if $self->_use_insert_returning_bound;
Branch: 1 branch
BranchTrueFalseTotal
if $self->_use_insert_returning_bound 7 3234 3241
3390  
3391 $sqla_opts->{returning} = [
3392 0 sort { $retrieve_cols{$a} <=> $retrieve_cols{$b} } keys %retrieve_cols
3393 ];
3394 }
3395  
3396 # ADR 0036: the conflict clause rides the same options transport as
3397 # RETURNING. The base SQLMaker does not understand it, so a driver that has
3398 # not declared the capability must never be handed the structure.
3399 0 ▶ if (my $on_conflict = $opts ? $opts->{on_conflict} : undef) {
Branch: 2 branches
BranchTrueFalseTotal
if (my $on_conflict = $opts ? $opts->{"on_conflict"} : undef) 7 0 7
$opts ? : 6 1 7
3400 0 ▶ $self->throw_exception(
Branch: 1 branch
BranchTrueFalseTotal
unless $self->_use_supports_upsert 2326 908 3234
3401 sprintf(
3402 "%s does not declare the supports_upsert capability -- refusing to "
3403 . "emit an ON CONFLICT clause its SQL generator cannot render",
3404 ref $self,
3405 )
3406 ) unless $self->_use_supports_upsert;
3407  
3408 # The conditional conflict branch is the one part of the structure a
3409 # driver can drop without any symptom: the statement stays valid and
3410 # writes unconditionally, i.e. it does the overwrite the condition was
3411 # written to prevent. Hence its own capability (ADR 0036 section 3).
3412 $self->throw_exception(
3413 sprintf(
3414 "%s does not declare the supports_upsert_where capability -- refusing "
3415 . "to emit a conditional DO UPDATE its SQL generator would silently "
3416 . "drop, leaving an unconditional overwrite",
3417 ref $self,
3418 )
3419 0 ▶ ) if defined $on_conflict->{where} and ! $self->_use_supports_upsert_where;
Branch: 1 branch
BranchTrueFalseTotal
if defined $on_conflict->{"where"} and not $self->_use_supports_upsert_where 0 2326 2326
3420  
3421 0 $sqla_opts->{on_conflict} = $on_conflict;
3422 }
3423  
3424 3241 my ($rv, $sth) = $self->_execute('insert', $source, $to_insert, $sqla_opts);
3425  
3426 7 ▶ $opts->{affected_rows} = $rv if $opts;
Branch: 1 branch
BranchTrueFalseTotal
if $opts 0 2326 2326
3427  
3428 8 my %returned_cols = %$to_insert;
3429 8 ▶ if (my $retlist = $sqla_opts->{returning}) { # if IR is supported - we will get everything in one set
Branch: 1 branch
BranchTrueFalseTotal
if (my $retlist = $sqla_opts->{'returning'}) { } 0 3234 3234
3430  
3431 0 ▶ unless( @ir_container ) {
Branch: 1 branch
BranchTrueFalseTotal
unless (@ir_container) 0 0 0
3432 try {
3433  
3434 # FIXME - need to investigate why Caelum silenced this in 4d4dc518
3435 local $SIG{__WARN__} = sub {};
3436  
3437 @ir_container = $sth->fetchrow_array;
3438 $sth->finish;
3439  
3440 } catch {
3441 # Evict the $sth from the cache in case we got here, since the finish()
3442 # is crucial, at least on older Firebirds, possibly on other engines too
3443 #
3444 # It would be too complex to make this a proper subclass override,
3445 # and besides we already take the try{} penalty, adding a catch that
3446 # triggers infrequently is a no-brainer
3447 #
3448 if( my $kids = $self->_dbh->{CachedKids} ) {
3449 $kids->{$_} == $sth and delete $kids->{$_}
3450 for keys %$kids
3451 }
3452 0 };
3453 }
3454  
3455 ▶ @returned_cols{@$retlist} = @ir_container if @ir_container;
Branch: 1 branch
BranchTrueFalseTotal
if @ir_container 0 0 0
3456 }
3457 else {
3458 # pull in PK if needed and then everything else
3459 ▶ if (my @missing_pri = grep { $pcols{$_} } keys %retrieve_cols) {
Branch: 1 branch
BranchTrueFalseTotal
if (my(@missing_pri) = grep({$pcols{$_};} keys %retrieve_cols)) 0 0 0
3460  
3461 ▶ $self->throw_exception( "Missing primary key but Storage doesn't support last_insert_id" )
Branch: 1 branch
BranchTrueFalseTotal
unless $self->can("last_insert_id") 0 0 0
3462 unless $self->can('last_insert_id');
3463  
3464 my @pri_values = $self->last_insert_id($source, @missing_pri);
3465  
3466 $self->throw_exception( "Can't get last insert id" )
3467 unless (@pri_values == @missing_pri);
3468  
3469 @returned_cols{@missing_pri} = @pri_values;
3470 delete @retrieve_cols{@missing_pri};
3471 }
3472  
3473 # if there is more left to pull
3474 if (%retrieve_cols) {
3475 $self->throw_exception(
3476 'Unable to retrieve additional columns without a Primary Key on ' . $source->source_name
3477 ) unless %pcols;
3478  
3479 my @left_to_fetch = sort { $retrieve_cols{$a} <=> $retrieve_cols{$b} } keys %retrieve_cols;
3480  
3481 my $cur = DBIO::ResultSet->new($source, {
3482 where => { map { $_ => $returned_cols{$_} } (keys %pcols) },
3483 select => \@left_to_fetch,
3484 })->cursor;
3485  
3486 @returned_cols{@left_to_fetch} = $cur->next;
3487  
3488 $self->throw_exception('Duplicate row returned for PK-search after fresh insert')
3489 if scalar $cur->next;
3490 }
3491 }
3492  
3493 return { %$prefetched_values, %returned_cols };
3494 }
3495  
3496 0 ▶sub insert_bulk {
Subroutine insert_bulk: not called CC=3 SCAR=24.8
Pod undocumented
3497 0 carp_unique(
3498 'insert_bulk() should have never been exposed as a public method and '
3499 . 'calling it is depecated as of Aug 2014. If you believe having a genuine '
3500 . 'use for this method please contact the development team via '
3501 . help_url()
3502 );
3503  
3504 0 ▶ return '0E0' unless @{$_[3]||[]};
Branch: 1 branch
BranchTrueFalseTotal
unless @{$_[3] or [];} 0 0 0
Condition0%0/2
$_[3] || []
l!l
00
MC/DC0%0/1
$_[3] || []
$_[3]
Truth table0%0/2
A
A= $_[3]
Aresult
11
00
3505  
3506 0 shift->_insert_bulk(@_);
3507 }
3508  
3509 sub _insert_bulk {
3510 my ($self, $source, $cols, $data) = @_;
3511  
3512 $self->throw_exception('Calling _insert_bulk without a dataset to process makes no sense')
3513 unless @{$data||[]};
3514  
3515 my $colinfos = $source->columns_info($cols);
3516  
3517 local $self->{_autoinc_supplied_for_op} =
3518 (grep { $_->{is_auto_increment} } values %$colinfos)
3519 ? 1
3520 : 0
3521 ;
3522  
3523 # get a slice type index based on first row of data
3524 # a "column" in this context may refer to more than one bind value
3525 # e.g. \[ '?, ?', [...], [...] ]
3526 #
3527 # construct the value type index - a description of values types for every
3528 # per-column slice of $data:
3529 #
3530 # nonexistent - nonbind literal
3531 # 0 - regular value
3532 # [] of bindattrs - resolved attribute(s) of bind(s) passed via literal+bind \[] combo
3533 #
3534 # also construct the column hash to pass to the SQL generator. For plain
3535 # (non literal) values - convert the members of the first row into a
3536 # literal+bind combo, with extra positional info in the bind attr hashref.
3537 # This will allow us to match the order properly, and is so contrived
3538 # because a user-supplied literal/bind (or something else specific to a
3539 # resultsource and/or storage driver) can inject extra binds along the
3540 # way, so one can't rely on "shift positions" ordering at all. Also we
3541 # can't just hand SQLMaker a set of some known "values" (e.g. hashrefs that
3542 # can be later matched up by address), because we want to supply a real
3543 # value on which perhaps e.g. datatype checks will be performed
3544 my ($proto_data, $serialized_bind_type_by_col_idx);
3545 for my $col_idx (0..$#$cols) {
3546 my $colname = $cols->[$col_idx];
3547 if (ref $data->[0][$col_idx] eq 'SCALAR') {
3548 # no bind value at all - no type
3549  
3550 $proto_data->{$colname} = $data->[0][$col_idx];
3551 }
3552 elsif (ref $data->[0][$col_idx] eq 'REF' and ref ${$data->[0][$col_idx]} eq 'ARRAY' ) {
3553 # repack, so we don't end up mangling the original \[]
3554 my ($sql, @bind) = @${$data->[0][$col_idx]};
3555  
3556 # normalization of user supplied stuff
3557 my $resolved_bind = $self->_resolve_bindattrs(
3558 $source, \@bind, $colinfos,
3559 );
3560  
3561 # store value-less (attrs only) bind info - we will be comparing all
3562 # supplied binds against this for sanity
3563 $serialized_bind_type_by_col_idx->{$col_idx} = serialize [ map { $_->[0] } @$resolved_bind ];
3564  
3565 $proto_data->{$colname} = \[ $sql, map { [
3566 # inject slice order to use for $proto_bind construction
3567 { %{$resolved_bind->[$_][0]}, _bind_data_slice_idx => $col_idx, _literal_bind_subindex => $_+1 }
3568 =>
3569 $resolved_bind->[$_][1]
3570 ] } (0 .. $#bind)
3571 ];
3572 }
3573 else {
3574 $serialized_bind_type_by_col_idx->{$col_idx} = undef;
3575  
3576 $proto_data->{$colname} = \[ '?', [
3577 { dbic_colname => $colname, _bind_data_slice_idx => $col_idx }
3578 =>
3579 $data->[0][$col_idx]
3580 ] ];
3581 }
3582 }
3583  
3584 my ($sql, $proto_bind) = $self->_prep_for_execute (
3585 'insert',
3586 $source,
3587 [ $proto_data ],
3588 );
3589  
3590 if (! @$proto_bind and keys %$serialized_bind_type_by_col_idx) {
3591 # if the bindlist is empty and we had some dynamic binds, this means the
3592 # storage ate them away (e.g. the NoBindVars component) and interpolated
3593 # them directly into the SQL. This obviously can't be good for multi-inserts
3594 $self->throw_exception('Unable to invoke fast-path insert without storage placeholder support');
3595 }
3596  
3597 # sanity checks
3598 # FIXME - devise a flag "no babysitting" or somesuch to shut this off
3599 #
3600 # use an error reporting closure for convenience (less to pass)
3601 my $bad_slice_report_cref = sub {
3602 my ($msg, $r_idx, $c_idx) = @_;
3603 # the row and the columns, never a value (ADR 0075)
3604 $self->throw_exception(sprintf
3605 "%s for column '%s' in row %d of the populate data (columns: %s)",
3606 $msg,
3607 $cols->[$c_idx],
3608 $r_idx + 1,
3609 join(', ', @$cols),
3610 );
3611 };
3612  
3613 for my $col_idx (0..$#$cols) {
3614 my $reference_val = $data->[0][$col_idx];
3615  
3616 for my $row_idx (1..$#$data) { # we are comparing against what we got from [0] above, hence start from 1
3617 my $val = $data->[$row_idx][$col_idx];
3618  
3619 if (! exists $serialized_bind_type_by_col_idx->{$col_idx}) { # literal no binds
3620 if (ref $val ne 'SCALAR') {
3621 $bad_slice_report_cref->(
3622 "Incorrect value (expecting SCALAR-ref \\'$$reference_val')",
3623 $row_idx,
3624 $col_idx,
3625 );
3626 }
3627 elsif ($$val ne $$reference_val) {
3628 $bad_slice_report_cref->(
3629 "Inconsistent literal SQL value (expecting \\'$$reference_val')",
3630 $row_idx,
3631 $col_idx,
3632 );
3633 }
3634 }
3635 elsif (! defined $serialized_bind_type_by_col_idx->{$col_idx} ) { # regular non-literal value
3636 if (is_literal_value($val)) {
3637 $bad_slice_report_cref->("Literal SQL found where a plain bind value is expected", $row_idx, $col_idx);
3638 }
3639 }
3640 else { # binds from a \[], compare type and attrs
3641 if (ref $val ne 'REF' or ref $$val ne 'ARRAY') {
3642 $bad_slice_report_cref->(
3643 "Incorrect value (expecting ARRAYREF-ref \\['${$reference_val}->[0]', ... ])",
3644 $row_idx,
3645 $col_idx,
3646 );
3647 }
3648 # start drilling down and bail out early on identical refs
3649 elsif (
3650 $reference_val != $val
3651 or
3652 $$reference_val != $$val
3653 ) {
3654 if (${$val}->[0] ne ${$reference_val}->[0]) {
3655 $bad_slice_report_cref->(
3656 "Inconsistent literal/bind SQL (expecting \\['${$reference_val}->[0]', ... ])",
3657 $row_idx,
3658 $col_idx,
3659 );
3660 }
3661 # need to check the bind attrs - a bind will happen only once for
3662 # the entire dataset, so any changes further down will be ignored.
3663 elsif (
3664 $serialized_bind_type_by_col_idx->{$col_idx}
3665 ne
3666 serialize [
3667 map
3668 { $_->[0] }
3669 @{$self->_resolve_bindattrs(
3670 $source, [ @{$$val}[1 .. $#$$val] ], $colinfos,
3671 )}
3672 ]
3673 ) {
3674 $bad_slice_report_cref->(
3675 'Differing bind attributes on literal/bind values not supported',
3676 $row_idx,
3677 $col_idx,
3678 );
3679 }
3680 }
3681 }
3682 }
3683 }
3684  
3685 # neither _dbh_execute_for_fetch, nor _dbh_execute_inserts_with_no_binds
3686 # are atomic (even if execute_for_fetch is a single call). Thus a safety
3687 # scope guard
3688 my $guard = $self->txn_scope_guard;
3689  
3690 $self->_query_start( $sql, @$proto_bind ? [[undef => '__BULK_INSERT__' ]] : () );
3691 my $sth = $self->_prepare_sth($self->_dbh, $sql);
3692 my $rv = do {
3693 if (@$proto_bind) {
3694 # proto bind contains the information on which pieces of $data to pull
3695 # $cols is passed in only for prettier error-reporting
3696 $self->_dbh_execute_for_fetch( $source, $sth, $proto_bind, $cols, $data );
3697 }
3698 else {
3699 # bind_param_array doesn't work if there are no binds
3700 $self->_dbh_execute_inserts_with_no_binds( $sth, scalar @$data );
3701 }
3702 };
3703  
3704 $self->_query_end( $sql, @$proto_bind ? [[ undef => '__BULK_INSERT__' ]] : () );
3705  
3706 $guard->commit;
3707  
3708 return wantarray ? ($rv, $sth, @$proto_bind) : $rv;
3709 }
3710  
3711 # execute_for_fetch is capable of returning data just fine (it means it
3712 # can be used for INSERT...RETURNING and UPDATE...RETURNING. Since this
3713 # is the void-populate fast-path we will just ignore this altogether
3714 # for the time being.
3715 3 ▶sub _dbh_execute_for_fetch {
Subroutine _dbh_execute_for_fetch: called CC=13 SCAR=27.2
3716 3 my ($self, $source, $sth, $proto_bind, $cols, $data) = @_;
3717  
3718 # If we have any bind attributes to take care of, we will bind the
3719 # proto-bind data (which will never be used by execute_for_fetch)
3720 # However since column bindtypes are "sticky", this is sufficient
3721 # to get the DBD to apply the bindtype to all values later on.
3722 # Only the attributes stay this way; the values of each row are run
3723 # through _adjust_bind_values below, as _bind_sth_params does
3724 3 my $bind_attrs = $self->_dbi_attrs_for_bind($source, $proto_bind);
3725  
3726 3 for my $i (0 .. $#$proto_bind) {
3727 6 ▶ $sth->bind_param (
Branch: 1 branch
BranchTrueFalseTotal
if defined $bind_attrs->[$i] 0 6 6
3728 $i+1, # DBI bind indexes are 1-based
3729 $proto_bind->[$i][1],
3730 $bind_attrs->[$i],
3731 ) if defined $bind_attrs->[$i];
3732 }
3733  
3734 # At this point $data slots named in the _bind_data_slice_idx of
3735 # each piece of $proto_bind are either \[]s or plain values to be
3736 # passed in. Construct the dispensing coderef. *NOTE* the order
3737 # of $data will differ from this of the ?s in the SQL (due to
3738 # alphabetical ordering by colname). We actually do want to
3739 # preserve this behavior so that prepare_cached has a better
3740 # chance of matching on unrelated calls
3741  
3742 3 my $fetch_row_idx = -1; # saner loop this way
3743 11 ▶ my $fetch_tuple = sub {
Subroutine __ANON__: called CC=5 SCAR=17.1
3744 11 ▶ return undef if ++$fetch_row_idx > $#$data;
Branch: 1 branch
BranchTrueFalseTotal
if ++$fetch_row_idx > $data->$#* 3 8 11
3745  
3746 my $row_bind = [ map {
3747 [
3748 $_,
3749 ! defined $_->{_literal_bind_subindex}
3750  
3751 ? $data->[ $fetch_row_idx ]->[ $_->{_bind_data_slice_idx} ]
3752  
3753 # There are no attributes to resolve here - we already did everything
3754 # when we constructed proto_bind. However we still want to sanity-check
3755 # what the user supplied, so pass stuff through to the resolver *anyway*
3756 : $self->_resolve_bindattrs (
3757 undef, # a fake rsrc
3758 0 ▶ [ ${ $data->[ $fetch_row_idx ]->[ $_->{_bind_data_slice_idx} ]}->[ $_->{_literal_bind_subindex} ] ],
Branch: 1 branch
BranchTrueFalseTotal
!defined($_->{'_literal_bind_subindex'}) ? : 16 0 16
3759 {}, # a fake column_info bag
3760 )->[0][1]
3761 ]
3762 8 } map { $_->[0] } @$proto_bind ];
3763  
3764 return [ map {
3765 16 my $v = $_->[1];
3766  
3767 # FIXME SUBOPTIMAL - DBI needs fixing to always stringify regardless of DBD
3768 # For the time being forcibly stringify whatever is stringifiable
3769 16 ▶ (length ref $v and is_plain_value $v)
Branch: 1 branch
BranchTrueFalseTotal
length ref $v && &is_plain_value($v) ? : 0 16 16
Condition33%1/3
length ref $v and &is_plain_value($v)
!ll&&!rl&&r
1600
MC/DC0%0/2
length ref $v and &is_plain_value($v)
length ref $v &is_plain_value($v)
Truth table33%1/3
A and B
A= length ref $vB= &is_plain_value($v)
ABresult
0X0
100
111
3770 ? "$v"
3771 : $v
3772 ;
3773 8 } @{ $self->_adjust_bind_values($sth, $row_bind, $bind_attrs) } ];
3774 3 };
3775  
3776 3 my $tuple_status = [];
3777 3 my ($rv, $err);
3778 {
3779 # an error the handle reports while the rows run is masked with the
3780 # values of every row: which row it is, the handle does not say
3781 3 local $self->{_values_in_flight} = [ map { $self->_populate_row_values($_) } @$data ];
3782  
3783 3 ▶ try {
Subroutine __ANON__: called CC=1 SCAR=0.0
3784 3 $rv = $sth->execute_for_fetch(
3785 $fetch_tuple,
3786 $tuple_status,
3787 );
3788 }
3789 2 ▶ catch {
Subroutine __ANON__: called CC=1 SCAR=0.0
3790 2 $err = shift;
3791 3 };
3792 }
3793  
3794 # Not all DBDs are create equal. Some throw on error, some return
3795 # an undef $rv, and some set $sth->err - try whatever we can
3796 3 ▶ $err = ($sth->errstr || 'UNKNOWN ERROR ($sth->errstr is unset)') if (
Branch: 1 branch
BranchTrueFalseTotal
if not defined $err and !defined($rv) || $sth->err 0 3 3
Condition37%3/8
not defined $err and !defined($rv) || $sth->err
!ll&&!rl&&r
210
not defined $rv or $sth->err
l!l&&r!l&&!r
001
$sth->errstr || 'UNKNOWN ERROR ($sth->errstr is unset)'
l!l
00
MC/DC0%0/3
not defined $err and !defined($rv) || $sth->err
not defined $err not defined $rv $sth->err
MC/DC0%0/1
$sth->errstr || 'UNKNOWN ERROR ($sth->errstr is unset)'
$sth->errstr
Truth table0%0/4
not(A) and not(B) or C
A= not defined $errB= not defined $rvC= $sth->err
ABCresult
0XX0
1000
11X1
1011
Truth table0%0/2
A
A= $sth->errstr
Aresult
11
00
3797 ! defined $err
3798 and
3799 ( !defined $rv or $sth->err )
3800 );
3801  
3802 # Statement must finish even if there was an exception.
3803 3 ▶ try {
Subroutine __ANON__: called CC=1 SCAR=0.0
3804 3 $sth->finish
3805 }
3806 0 ▶ catch {
Subroutine __ANON__: not called CC=2 SCAR=17.9
3807 0 ▶ $err = shift unless defined $err
Branch: 1 branch
BranchTrueFalseTotal
unless defined $err 0 0 0
3808 3 };
3809  
3810 3 ▶ if (defined $err) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $err) 2 1 3
3811 2 my $i = 0;
3812 2 ▶ ++$i while $i <= $#$tuple_status && !ref $tuple_status->[$i];
Branch: 1 branch
BranchTrueFalseTotal
$i <= $tuple_status->$#* and not ref $tuple_status->[$i] and do { ++$i } 4 2 6
Condition100%3/3
$i <= $tuple_status->$#* and not ref $tuple_status->[$i]
!ll&&!rl&&r
114
MC/DC100%2/2
$i <= $tuple_status->$#* and not ref $tuple_status->[$i]
$i <= $tuple_status->$#* not ref $tuple_status->[$i]
Truth table100%3/3
A and not(B)
A= $i <= $tuple_status->$#*B= not ref $tuple_status->[$i]
ABresult
0X0
100
111
3813  
3814 # the engine text loses the values of the row that failed; where no
3815 # row is known, those of every row (ADR 0075)
3816 my $values = _plain_error_values(
3817 $i > $#$tuple_status
3818 2 ▶ ? ( map { $self->_populate_row_values($_) } @$data )
Branch: 1 branch
BranchTrueFalseTotal
$i > $tuple_status->$#* ? : 1 1 2
3819 : $self->_populate_row_values($data->[$i])
3820 );
3821  
3822 2 ▶ $self->throw_exception(
Branch: 1 branch
BranchTrueFalseTotal
if $i > $tuple_status->$#* 1 1 2
3823 'Unexpected populate error: '
3824 . $self->_mask_error_values("$err", $values, undef)
3825 ) if ($i > $#$tuple_status);
3826  
3827 1 ▶ $self->throw_exception(sprintf
Condition33%1/3
$tuple_status->[$i][1] || $err
l!l&&r!l&&!r
100
MC/DC0%0/2
$tuple_status->[$i][1] || $err
$tuple_status->[$i][1] $err
Truth table33%1/3
A || B
A= $tuple_status->[$i][1]B= $err
ABresult
1X1
011
000
3828 "execute_for_fetch() aborted with '%s' at row %d of the populate data (columns: %s)",
3829 $self->_mask_error_values(
3830 '' . ($tuple_status->[$i][1] || $err), $values, undef,
3831 ),
3832 $i + 1,
3833 join(', ', @$cols),
3834 );
3835 }
3836  
3837 1 return $rv;
3838 }
3839  
3840 # The values a row of populate data binds, raw: a plain cell is its own value,
3841 # a \[ $sql, @bind ] cell holds the values of its binds, a literal \$sql none.
3842 12 ▶sub _populate_row_values {
Subroutine _populate_row_values: called CC=7 SCAR=29.2
3843 12 my ($self, $row) = @_;
3844  
3845 return map {
3846 ( ref $_ eq 'REF' and ref $$_ eq 'ARRAY' )
3847 0 ▶ ? ( map { ref $_ eq 'ARRAY' && @$_ == 2 ? $_->[1] : $_ } @{$$_}[ 1 .. $#{$$_} ] )
Branch: 3 branches
BranchTrueFalseTotal
ref $_ eq 'REF' && ref $$_ eq 'ARRAY' ? : 0 24 24
ref $_ eq 'ARRAY' && @$_ == 2 ? : 0 0 0
ref $_ eq 'SCALAR' ? : 0 24 24
Condition16%1/6
ref $_ eq "REF" and ref $$_ eq "ARRAY"
!ll&&!rl&&r
2400
ref $_ eq "ARRAY" and @$_ == 2
!ll&&!rl&&r
000
MC/DC0%0/2
ref $_ eq "REF" and ref $$_ eq "ARRAY"
ref $_ eq "REF" ref $$_ eq "ARRAY"
MC/DC0%0/2
ref $_ eq "ARRAY" and @$_ == 2
ref $_ eq "ARRAY" @$_ == 2
Truth table33%1/3
A and B
A= ref $_ eq "REF"B= ref $$_ eq "ARRAY"
ABresult
0X0
100
111
Truth table0%0/3
A and B
A= ref $_ eq "ARRAY"B= @$_ == 2
ABresult
0X0
100
111
3848 : ref $_ eq 'SCALAR' ? ()
3849 : $_
3850 12 ▶ } @{ $row || [] };
Condition50%1/2
$row || []
l!l
120
MC/DC0%0/1
$row || []
$row
Truth table50%1/2
A
A= $row
Aresult
11
00
3851 }
3852  
3853 0 ▶sub _dbh_execute_inserts_with_no_binds {
Subroutine _dbh_execute_inserts_with_no_binds: not called CC=3 SCAR=24.8
3854 0 my ($self, $sth, $count) = @_;
3855  
3856 0 my $err;
3857 0 ▶ try {
Subroutine __ANON__: not called CC=2 SCAR=17.9
3858 0 my $dbh = $self->_get_dbh;
3859 0 local $dbh->{RaiseError} = 1;
3860 0 local $dbh->{PrintError} = 0;
3861  
3862 0 $sth->execute foreach 1..$count;
3863 }
3864 0 ▶ catch {
Subroutine __ANON__: not called CC=1 SCAR=6.9
3865 0 $err = shift;
3866 0 };
3867  
3868 # Make sure statement is finished even if there was an exception.
3869 0 ▶ try {
Subroutine __ANON__: not called CC=1 SCAR=6.9
3870 0 $sth->finish
3871 }
3872 0 ▶ catch {
Subroutine __ANON__: not called CC=2 SCAR=17.9
3873 0 ▶ $err = shift unless defined $err;
Branch: 1 branch
BranchTrueFalseTotal
unless defined $err 0 0 0
3874 0 };
3875  
3876 # the statements carry no bound value; the hook is asked all the same, a
3877 # driver's own rules apply to the text of the engine
3878 0 ▶ $self->throw_exception(
Branch: 2 branches
BranchTrueFalseTotal
if defined $err 0 0 0
ref $err ? : 0 0 0
3879 ref $err ? $err : $self->_mask_error_values($err, [], undef)
3880 ) if defined $err;
3881  
3882 0 return $count;
3883 }
3884  
3885 0 ▶sub update {
Subroutine update: not called CC=1 SCAR=0.0
3886 #my ($self, $source, @args) = @_;
3887 2 shift->_execute('update', @_);
3888 }
3889  
3890  
3891 sub delete {
3892 #my ($self, $source, @args) = @_;
3893 shift->_execute('delete', @_);
3894 }
3895  
3896 18 ▶sub _select {
Subroutine _select: called CC=1 SCAR=0.0
3897 18 my $self = shift;
3898 18 $self->_execute($self->_select_args(@_));
3899 }
3900  
3901 936 ▶sub _select_args_to_query {
Subroutine _select_args_to_query: called CC=4 SCAR=14.2
3902 936 my $self = shift;
3903  
3904 $self->throw_exception(
3905 "Unable to generate limited query representation with 'software_limit' enabled"
3906 936 ▶ ) if ($_[3]->{software_limit} and ($_[3]->{offset} or $_[3]->{rows}) );
Branch: 1 branch
BranchTrueFalseTotal
if $_[3]{"software_limit"} and $_[3]{"offset"} || $_[3]{"rows"} 1 935 936
Condition50%3/6
$_[3]{"software_limit"} and $_[3]{"offset"} || $_[3]{"rows"}
!ll&&!rl&&r
93501
$_[3]{"offset"} or $_[3]{"rows"}
l!l&&r!l&&!r
010
MC/DC33%1/3
$_[3]{"software_limit"} and $_[3]{"offset"} || $_[3]{"rows"}
$_[3]{"software_limit"} $_[3]{"offset"} $_[3]{"rows"}
Truth table50%2/4
A and B or C
A= $_[3]{"software_limit"}B= $_[3]{"offset"}C= $_[3]{"rows"}
ABCresult
0XX0
1000
11X1
1011
3907  
3908 # my ($op, $ident, $select, $cond, $rs_attrs, $rows, $offset)
3909 # = $self->_select_args($ident, $select, $cond, $attrs);
3910 935 my ($op, $ident, @args) =
3911 $self->_select_args(@_);
3912  
3913 # my ($sql, $prepared_bind) = $self->_gen_sql_bind($op, $ident, [ $select, $cond, $rs_attrs, $rows, $offset ]);
3914 935 my ($sql, $bind) = $self->_gen_sql_bind($op, $ident, \@args);
3915  
3916 # reuse the bind arrayref
3917 933 unshift @{$bind}, "($sql)";
3918 933 \$bind;
3919 }
3920  
3921 2177 ▶sub _select_args {
Subroutine _select_args: called CC=26 SCAR=32.7
3922 2177 my ($self, $ident, $select, $where, $orig_attrs) = @_;
3923  
3924 # FIXME - that kind of caching would be nice to have
3925 # however currently we *may* pass the same $orig_attrs
3926 # with different ident/select/where
3927 # the whole interface needs to be rethought, since it
3928 # was centered around the flawed SQLMaker API. We can do
3929 # soooooo much better now. But that is also another
3930 # battle...
3931 #return (
3932 # 'select', $orig_attrs->{!args_as_stored_at_the_end_of_this_method!}
3933 #) if $orig_attrs->{!args_as_stored_at_the_end_of_this_method!};
3934  
3935 2177 my $sql_maker = $self->sql_maker;
3936  
3937 2176 my $attrs = {
3938 %$orig_attrs,
3939 select => $select,
3940 from => $ident,
3941 where => $where,
3942 };
3943  
3944 # Sanity check the attributes (SQLMaker does it too, but
3945 # in case of a software_limit we'll never reach there)
3946 2176 ▶ if (defined $attrs->{offset}) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $attrs->{"offset"}) 48 2128 2176
3947 $self->throw_exception('A supplied offset attribute must be a non-negative integer')
3948 48 ▶ if ( $attrs->{offset} =~ /\D/ or $attrs->{offset} < 0 );
Branch: 1 branch
BranchTrueFalseTotal
if $attrs->{"offset"} =~ /\D/ or $attrs->{"offset"} < 0 1 47 48
Condition66%2/3
$attrs->{"offset"} =~ /\D/ or $attrs->{"offset"} < 0
l!l&&r!l&&!r
1047
MC/DC50%1/2
$attrs->{"offset"} =~ /\D/ or $attrs->{"offset"} < 0
$attrs->{"offset"} =~ /\D/ $attrs->{"offset"} < 0
Truth table66%2/3
A or B
A= $attrs->{"offset"} =~ /\D/B= $attrs->{"offset"} < 0
ABresult
1X1
011
000
3949 }
3950  
3951 2175 ▶ if (defined $attrs->{rows}) {
Branch: 2 branches
BranchTrueFalseTotal
if (defined $attrs->{'rows'}) { } 218 1957 2175
elsif ($attrs->{'offset'}) { } 4 1953 1957
3952 $self->throw_exception("The rows attribute must be a positive integer if present")
3953 218 ▶ if ( $attrs->{rows} =~ /\D/ or $attrs->{rows} <= 0 );
Branch: 1 branch
BranchTrueFalseTotal
if $attrs->{"rows"} =~ /\D/ or $attrs->{"rows"} <= 0 1 217 218
Condition66%2/3
$attrs->{"rows"} =~ /\D/ or $attrs->{"rows"} <= 0
l!l&&r!l&&!r
01217
MC/DC50%1/2
$attrs->{"rows"} =~ /\D/ or $attrs->{"rows"} <= 0
$attrs->{"rows"} =~ /\D/ $attrs->{"rows"} <= 0
Truth table66%2/3
A or B
A= $attrs->{"rows"} =~ /\D/B= $attrs->{"rows"} <= 0
ABresult
1X1
011
000
3954 }
3955 elsif ($attrs->{offset}) {
3956 # MySQL actually recommends this approach. I cringe.
3957 4 $attrs->{rows} = $sql_maker->__max_int;
3958 }
3959  
3960 # see if we will need to tear the prefetch apart to satisfy group_by == select
3961 # this is *extremely tricky* to get right, I am still not sure I did
3962 #
3963 2174 my ($prefetch_needs_subquery, @limit_args);
3964  
3965 2174 ▶ if ( $attrs->{_grouped_by_distinct} and $attrs->{collapse} ) {
Branch: 3 branches
BranchTrueFalseTotal
if ($attrs->{'_grouped_by_distinct'} and $attrs->{'collapse'}) { } 5 2169 2174
elsif ($prefetch_needs_subquery || !$attrs->{'_simple_passthrough_construction'} and $attrs->{'group_by'} and @{$attrs->{'group_by'};} and my $grp_aliases = &try(sub { $self->_resolve_aliastypes_from_select_args({'from', $attrs->{'from'}, 'group_by', $attrs->{'group_by'}}); } )) { } 3 2166 2169
elsif ($attrs->{'rows'} and $attrs->{'collapse'}) { } 12 4103 4115
Condition100%3/3
$attrs->{"_grouped_by_distinct"} and $attrs->{"collapse"}
!ll&&!rl&&r
2139305
MC/DC100%2/2
$attrs->{"_grouped_by_distinct"} and $attrs->{"collapse"}
$attrs->{"_grouped_by_distinct"} $attrs->{"collapse"}
Truth table100%3/3
A and B
A= $attrs->{"_grouped_by_distinct"}B= $attrs->{"collapse"}
ABresult
0X0
100
111
3966 # we already know there is a valid group_by (we made it) and we know it is
3967 # intended to be based *only* on non-multi stuff
3968 # short circuit the group_by parsing below
3969 5 $prefetch_needs_subquery = 1;
3970 }
3971 ▶ elsif (
Condition75%9/12
$prefetch_needs_subquery || !$attrs->{"_simple_passthrough_construction"} and $attrs->{"group_by"} and @{$attrs->{"group_by"};} and my $grp_aliases = &try(sub { $self->_resolve_aliastypes_from_select_args({"from", $attrs->{"from"}, "group_by", $attrs->{"group_by"}}); } )
!ll&&!rl&&r
216603
$prefetch_needs_subquery || !$attrs->{"_simple_passthrough_construction"} and $attrs->{"group_by"} and @{$attrs->{"group_by"};}
!ll&&!rl&&r
216603
$prefetch_needs_subquery || !$attrs->{"_simple_passthrough_construction"} and $attrs->{"group_by"}
!ll&&!rl&&r
2070963
$prefetch_needs_subquery or not $attrs->{"_simple_passthrough_construction"}
l!l&&r!l&&!r
0992070
MC/DC40%2/5
$prefetch_needs_subquery || !$attrs->{"_simple_passthrough_construction"} and $attrs->{"group_by"} and @{$attrs->{"group_by"};} and my $grp_aliases = &try(sub { $self->_resolve_aliastypes_from_select_args({"from", $attrs->{"from"}, "group_by", $attrs->{"group_by"}}); } )
$prefetch_needs_subquery not $attrs->{"_simple_passthrough_construction"} $attrs->{"group_by"} @{$attrs->{"group_by"};} my $grp_aliases = &try(sub { $self->_resolve_aliastypes_from_select_args({"from", $attrs->{"from"}, "group_by", $attrs->{"group_by"}}); } )
Truth table33%3/9
A or not(B) and C and D and E
A= $prefetch_needs_subqueryB= not $attrs->{"_simple_passthrough_construction"}C= $attrs->{"group_by"}D= @{$attrs->{"group_by"};}E= my $grp_aliases = &try(sub { $self->_resolve_aliastypes_from_select_args({"from", $attrs->{"from"}, "group_by", $attrs->{"group_by"}}); } )
ABCDEresult
00XXX0
1X0XX0
010XX0
1X10X0
0110X0
1X1100
011100
1X1111
011111
3972 # The rationale is that even if we do *not* have collapse, we still
3973 # need to wrap the core grouped select/group_by in a subquery
3974 # so that databases that care about group_by/select equivalence
3975 # are happy (this includes MySQL in strict_mode)
3976 # If any of the other joined tables are referenced in the group_by
3977 # however - the user is on their own
3978 ( $prefetch_needs_subquery or ! $attrs->{_simple_passthrough_construction} )
3979 and
3980 $attrs->{group_by}
3981 and
3982 3 @{$attrs->{group_by}}
3983 and
3984 3 ▶ my $grp_aliases = try { # try{} because $attrs->{from} may be unreadable
Subroutine __ANON__: called CC=1 SCAR=0.0
3985 $self->_resolve_aliastypes_from_select_args({ from => $attrs->{from}, group_by => $attrs->{group_by} })
3986 3 }
3987 ) {
3988 # no aliases other than our own in group_by
3989 # if there are - do not allow subquery even if limit is present
3990 3 ▶ $prefetch_needs_subquery = ! scalar grep { $_ ne $attrs->{alias} } keys %{ $grp_aliases->{grouping} || {} };
Condition50%1/2
$grp_aliases->{'grouping'} || {}
l!l
30
MC/DC0%0/1
$grp_aliases->{'grouping'} || {}
$grp_aliases->{'grouping'}
Truth table50%1/2
A
A= $grp_aliases->{'grouping'}
Aresult
11
00
3991 }
3992 ▶ elsif ( $attrs->{rows} && $attrs->{collapse} ) {
Condition100%3/3
$attrs->{"rows"} and $attrs->{"collapse"}
!ll&&!rl&&r
194920512
MC/DC100%2/2
$attrs->{"rows"} and $attrs->{"collapse"}
$attrs->{"rows"} $attrs->{"collapse"}
Truth table100%3/3
A and B
A= $attrs->{"rows"}B= $attrs->{"collapse"}
ABresult
0X0
100
111
3993 # active collapse with a limit - that one is a no-brainer unless
3994 # overruled by a group_by above
3995 12 $prefetch_needs_subquery = 1;
3996 }
3997  
3998 2174 ▶ if ($prefetch_needs_subquery) {
Branch: 2 branches
BranchTrueFalseTotal
if ($prefetch_needs_subquery) { } 20 2154 2174
elsif (not $attrs->{'software_limit'}) { } 2145 9 2154
3999 20 $attrs = $self->_adjust_select_args_for_complex_prefetch ($attrs);
4000 }
4001 elsif (! $attrs->{software_limit} ) {
4002 push @limit_args, (
4003 $attrs->{rows} || (),
4004 2145 ▶ $attrs->{offset} || (),
Condition83%5/6
$attrs->{'rows'} || ()
l!l&&r!l&&!r
19701948
$attrs->{'offset'} || ()
l!l&&r!l&&!r
381591948
MC/DC50%1/2
$attrs->{'rows'} || ()
$attrs->{'rows'} ()
MC/DC100%2/2
$attrs->{'offset'} || ()
$attrs->{'offset'} ()
Truth table66%2/3
A || B
A= $attrs->{'rows'}B= ()
ABresult
1X1
011
000
Truth table100%3/3
A || B
A= $attrs->{'offset'}B= ()
ABresult
1X1
011
000
4005 );
4006 }
4007  
4008 # try to simplify the joinmap further (prune unreferenced type-single joins)
4009 2173 ▶ if (
Branch: 1 branch
BranchTrueFalseTotal
if (not $prefetch_needs_subquery and ref $attrs->{"from"} and builtin::reftype($attrs->{"from"}) eq "ARRAY" and @{$attrs->{"from"};} != 1) 117 2056 2173
Condition100%9/9
not $prefetch_needs_subquery and ref $attrs->{"from"} and builtin::reftype($attrs->{"from"}) eq "ARRAY" and @{$attrs->{"from"};} != 1
!ll&&!rl&&r
801976117
not $prefetch_needs_subquery and ref $attrs->{"from"} and builtin::reftype($attrs->{"from"}) eq "ARRAY"
!ll&&!rl&&r
7642093
not $prefetch_needs_subquery and ref $attrs->{"from"}
!ll&&!rl&&r
19572097
MC/DC100%4/4
not $prefetch_needs_subquery and ref $attrs->{"from"} and builtin::reftype($attrs->{"from"}) eq "ARRAY" and @{$attrs->{"from"};} != 1
not $prefetch_needs_subquery ref $attrs->{"from"} builtin::reftype($attrs->{"from"}) eq "ARRAY" @{$attrs->{"from"};} != 1
Truth table100%5/5
not(A) and B and C and D
A= not $prefetch_needs_subqueryB= ref $attrs->{"from"}C= builtin::reftype($attrs->{"from"}) eq "ARRAY"D= @{$attrs->{"from"};} != 1
ABCDresult
0XXX0
10XX0
110X0
11100
11111
4010 ! $prefetch_needs_subquery # already pruned
4011 and
4012 ref $attrs->{from}
4013 and
4014 reftype $attrs->{from} eq 'ARRAY'
4015 and
4016 2093 @{$attrs->{from}} != 1
4017 ) {
4018 117 ($attrs->{from}, $attrs->{_aliastypes}) = $self->_prune_unused_joins ($attrs);
4019 }
4020  
4021 # FIXME this is a gross, inefficient, largely incorrect and fragile hack
4022 # during the result inflation stage we *need* to know what was the aliastype
4023 # map as sqla saw it when the final pieces of SQL were being assembled
4024 # Originally we simply carried around the entirety of $attrs, but this
4025 # resulted in resultsets that are being reused growing continuously, as
4026 # the hash in question grew deeper and deeper.
4027 # Instead hand-pick what to take with us here (we actually don't need much
4028 # at this point just the map itself)
4029 2173 $orig_attrs->{_last_sqlmaker_alias_map} = $attrs->{_aliastypes};
4030  
4031 ###
4032 # my $alias2source = $self->_resolve_ident_sources ($ident);
4033 #
4034 # This would be the point to deflate anything found in $attrs->{where}
4035 # (and leave $attrs->{bind} intact). Problem is - inflators historically
4036 # expect a result object. And all we have is a resultsource (it is trivial
4037 # to extract deflator coderefs via $alias2source above).
4038 #
4039 # I don't see a way forward other than changing the way deflators are
4040 # invoked, and that's just bad...
4041 ###
4042  
4043 2173 return ( 'select', @{$attrs}{qw(from select where)}, $attrs, @limit_args );
4044 }
4045  
4046 # Returns a counting SELECT for a simple count
4047 # query. Abstracted so that a storage could override
4048 # this to { count => 'firstcol' } or whatever makes
4049 # sense as a performance optimization
4050 182 ▶sub _count_select {
Subroutine _count_select: called CC=1 SCAR=0.0
4051 #my ($self, $source, $rs_attrs) = @_;
4052 182 return { count => '*' };
4053 }
4054  
4055  
4056 sub select {
4057 my $self = shift;
4058 my ($ident, $select, $condition, $attrs) = @_;
4059 return $self->cursor_class->new($self, \@_, $attrs);
4060 }
4061  
4062 sub select_single {
4063 my $self = shift;
4064 my ($rv, $sth, @bind) = $self->_select(@_);
4065 my @row = $sth->fetchrow_array;
4066 my @nextrow = $sth->fetchrow_array if @row;
4067 if(@row && @nextrow) {
4068 carp "Query returned more than one row. SQL that returns multiple rows is DEPRECATED for ->find and ->single";
4069 }
4070 # Need to call finish() to work round broken DBDs
4071 $sth->finish();
4072 return @row;
4073 }
4074  
4075 0 ▶sub _dbh_columns_info_for {
Subroutine _dbh_columns_info_for: not called CC=12 SCAR=50.5
4076 0 my ($self, $dbh, $table) = @_;
4077  
4078 0 ▶ if ($dbh->can('column_info')) {
Branch: 1 branch
BranchTrueFalseTotal
if ($dbh->can("column_info")) 0 0 0
4079 0 my %result;
4080 my $caught;
4081 0 ▶ try {
Subroutine __ANON__: not called CC=4 SCAR=30.0
4082 0 ▶ my ($schema,$tab) = $table =~ /^(.+?)\.(.+)$/ ? ($1,$2) : (undef,$table);
Branch: 1 branch
BranchTrueFalseTotal
$table =~ /^(.+?)\.(.+)$/ ? : 0 0 0
4083 0 my $sth = $dbh->column_info( undef,$schema, $tab, '%' );
4084 0 $sth->execute();
4085 0 ▶ while ( my $info = $sth->fetchrow_hashref() ){
Branch: 1 branch
BranchTrueFalseTotal
if (my $info = $sth->fetchrow_hashref) 0 0 0
4086 0 my %column_info;
4087 0 $column_info{data_type} = $info->{TYPE_NAME};
4088 0 $column_info{size} = $info->{COLUMN_SIZE};
4089 0 ▶ $column_info{is_nullable} = $info->{NULLABLE} ? 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
$info->{'NULLABLE'} ? : 0 0 0
4090 0 $column_info{default_value} = $info->{COLUMN_DEF};
4091 0 my $col_name = $info->{COLUMN_NAME};
4092 0 $col_name =~ s/^\"(.*)\"$/$1/;
4093  
4094 0 $result{$col_name} = \%column_info;
4095 }
4096 0 ▶ } catch {
Subroutine __ANON__: not called CC=1 SCAR=6.9
4097 0 $caught = 1;
4098 0 };
4099 0 ▶ return \%result if !$caught && scalar keys %result;
Branch: 1 branch
BranchTrueFalseTotal
if not $caught and scalar keys %result 0 0 0
Condition0%0/2
not $caught and scalar keys %result
!ll
00
MC/DC0%0/1
not $caught and scalar keys %result
not $caught
Truth table0%0/2
not(A)
A= not $caught
Aresult
00
11
4100 }
4101  
4102 0 my %result;
4103 0 my $sth = $dbh->prepare($self->sql_maker->select($table, undef, \'1 = 0'));
4104 0 $sth->execute;
4105 0 my @columns = @{$sth->{NAME_lc}};
4106 0 for my $i ( 0 .. $#columns ){
4107 0 my %column_info;
4108 0 $column_info{data_type} = $sth->{TYPE}->[$i];
4109 0 $column_info{size} = $sth->{PRECISION}->[$i];
4110 0 ▶ $column_info{is_nullable} = $sth->{NULLABLE}->[$i] ? 1 : 0;
Branch: 1 branch
BranchTrueFalseTotal
$sth->{'NULLABLE'}[$i] ? : 0 0 0
4111  
4112 0 ▶ if ($column_info{data_type} =~ m/^(.*?)\((.*?)\)$/) {
Branch: 1 branch
BranchTrueFalseTotal
if ($column_info{"data_type"} =~ /^(.*?)\((.*?)\)$/) 0 0 0
4113 0 $column_info{data_type} = $1;
4114 0 $column_info{size} = $2;
4115 }
4116  
4117 0 $result{$columns[$i]} = \%column_info;
4118 }
4119 0 $sth->finish;
4120  
4121 0 foreach my $col (keys %result) {
4122 0 my $colinfo = $result{$col};
4123 0 my $type_num = $colinfo->{data_type};
4124 0 my $type_name;
4125 0 ▶ if(defined $type_num && $dbh->can('type_info')) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $type_num and $dbh->can("type_info")) 0 0 0
Condition0%0/3
defined $type_num and $dbh->can("type_info")
!ll&&!rl&&r
000
MC/DC0%0/2
defined $type_num and $dbh->can("type_info")
defined $type_num $dbh->can("type_info")
Truth table0%0/3
A and B
A= defined $type_numB= $dbh->can("type_info")
ABresult
0X0
100
111
4126 0 my $type_info = $dbh->type_info($type_num);
4127 0 ▶ $type_name = $type_info->{TYPE_NAME} if $type_info;
Branch: 1 branch
BranchTrueFalseTotal
if $type_info 0 0 0
4128 0 ▶ $colinfo->{data_type} = $type_name if $type_name;
Branch: 1 branch
BranchTrueFalseTotal
if $type_name 0 0 0
4129 }
4130 }
4131  
4132 0 return \%result;
4133 }
4134  
4135 0 ▶sub columns_info_for {
Subroutine columns_info_for: not called CC=1 SCAR=6.9
Pod documented
4136 0 my ($self, $table) = @_;
4137 0 $self->_dbh_columns_info_for ($self->_get_dbh, $table);
4138 }
4139  
4140  
4141 0 ▶sub _dbh_last_insert_id {
Subroutine _dbh_last_insert_id: not called CC=2 SCAR=17.9
4142 0 my ($self, $dbh, $source, $col) = @_;
4143  
4144 0 ▶ my $id = try { $dbh->last_insert_id (undef, undef, $source->name, $col) };
Subroutine __ANON__: not called CC=1 SCAR=6.9
4145  
4146 0 ▶ return $id if defined $id;
Branch: 1 branch
BranchTrueFalseTotal
if defined $id 0 0 0
4147  
4148 0 my $class = ref $self;
4149 0 $self->throw_exception ("No storage specific _dbh_last_insert_id() method implemented in $class, and the generic DBI::last_insert_id() failed");
4150 }
4151  
4152 0 ▶sub last_insert_id {
Subroutine last_insert_id: not called CC=1 SCAR=6.9
Pod documented
4153 0 my $self = shift;
4154 0 $self->_dbh_last_insert_id ($self->_dbh, @_);
4155 }
4156  
4157  
4158 sub _random_function { 'RANDOM()' }
4159  
4160  
4161 sub _explain_query {
4162 my ($self, $sql, $bind) = @_;
4163  
4164 my (undef, $sth) = $self->_execute_rendered("EXPLAIN $sql", $bind);
4165  
4166 return $sth->fetchall_arrayref;
4167 }
4168  
4169  
4170 sub _exists_value_sql { "SELECT CASE WHEN EXISTS $_[1] THEN 1 ELSE 0 END" }
4171  
4172  
4173 344 my %SET_OPERATION_KEYWORD = (
4174 union => 'UNION',
4175 union_all => 'UNION ALL',
4176 intersect => 'INTERSECT',
4177 intersect_all => 'INTERSECT ALL',
4178 except => 'EXCEPT',
4179 except_all => 'EXCEPT ALL',
4180 );
4181  
4182 sub _set_operation_keyword {
4183 my ($self, $op) = @_;
4184  
4185 my $keyword = defined $op ? $SET_OPERATION_KEYWORD{$op} : undef;
4186  
4187 $self->throw_exception(
4188 "Unknown set operation '" . (defined $op ? $op : '(undef)') . "' -- "
4189 . 'valid operations are: ' . join(', ', sort keys %SET_OPERATION_KEYWORD)
4190 ) unless defined $keyword;
4191  
4192 return $keyword;
4193 }
4194  
4195  
4196 9 ▶sub _execute_rendered {
Subroutine _execute_rendered: called CC=2 SCAR=7.0
4197 9 my ($self, $sql, $bind) = @_;
4198  
4199 9 ($sql, $bind) = $self->_prep_rendered_for_execute($sql, $bind);
4200  
4201 9 ▶ $self->_populate_dbh unless $self->_dbh;
Branch: 1 branch
BranchTrueFalseTotal
unless $self->_dbh 0 9 9
4202  
4203 9 $self->dbh_do( _dbh_execute => # retry over disconnects
4204 $sql,
4205 $bind,
4206 $self->_dbi_attrs_for_bind(undef, $bind),
4207 );
4208 }
4209  
4210  
4211 6 ▶sub _prepare_rendered {
Subroutine _prepare_rendered: called CC=2 SCAR=7.0
4212 6 my ($self, $sql, $bind) = @_;
4213  
4214 6 ($sql, $bind) = $self->_prep_rendered_for_execute($sql, $bind);
4215  
4216 6 ▶ $self->_populate_dbh unless $self->_dbh;
Branch: 1 branch
BranchTrueFalseTotal
unless $self->_dbh 0 6 6
4217  
4218 6 my $sth = $self->dbh_do( _dbh_prepare => # retry over disconnects
4219 $sql,
4220 $bind,
4221 $self->_dbi_attrs_for_bind(undef, $bind),
4222 );
4223  
4224 6 return $sth;
4225 }
4226  
4227  
4228 64 ▶sub _prep_rendered_for_execute { return ($_[1], $_[2]) }
Subroutine _prep_rendered_for_execute: called CC=1 SCAR=0.0
4229  
4230 # Check if placeholders are supported at all
4231 0 ▶sub _determine_supports_placeholders {
Subroutine _determine_supports_placeholders: not called CC=1 SCAR=6.9
4232 0 my $self = shift;
4233 0 my $dbh = $self->_get_dbh;
4234  
4235 # some drivers provide a $dbh attribute (e.g. Sybase and $dbh->{syb_dynamic_supported})
4236 # but it is inaccurate more often than not
4237 0 ▶ return try {
Subroutine __ANON__: not called CC=1 SCAR=6.9
4238 0 local $dbh->{PrintError} = 0;
4239 0 local $dbh->{RaiseError} = 1;
4240 0 $dbh->do('select ?', {}, 1);
4241 0 1;
4242 }
4243 0 ▶ catch {
Subroutine __ANON__: not called CC=1 SCAR=6.9
4244 0 0;
4245 0 };
4246 }
4247  
4248 # Check if placeholders bound to non-string types throw exceptions
4249 #
4250 0 ▶sub _determine_supports_typeless_placeholders {
Subroutine _determine_supports_typeless_placeholders: not called CC=1 SCAR=6.9
4251 0 my $self = shift;
4252 0 my $dbh = $self->_get_dbh;
4253  
4254 0 ▶ return try {
Subroutine __ANON__: not called CC=1 SCAR=6.9
4255 0 local $dbh->{PrintError} = 0;
4256 0 local $dbh->{RaiseError} = 1;
4257 # this specifically tests a bind that is NOT a string
4258 0 $dbh->do('select 1 where 1 = ?', {}, 1);
4259 0 1;
4260 }
4261 0 ▶ catch {
Subroutine __ANON__: not called CC=1 SCAR=6.9
4262 0 0;
4263 0 };
4264 }
4265  
4266  
4267 sub sqlt_type {
4268 shift->_get_dbh->{Driver}->{Name};
4269 }
4270  
4271  
4272 0 ▶sub bind_attribute_by_data_type {
Subroutine bind_attribute_by_data_type: not called CC=1 SCAR=6.9
Pod documented
4273 0 return;
4274 }
4275  
4276  
4277 58 ▶sub is_datatype_numeric {
Subroutine is_datatype_numeric: called CC=2 SCAR=7.2
Pod documented
4278 #my ($self, $dt) = @_;
4279  
4280 58 ▶ return 0 unless $_[1];
Branch: 1 branch
BranchTrueFalseTotal
unless $_[1] 0 58 58
4281  
4282 58 $_[1] =~ /^ (?:
4283 numeric | int(?:eger)? | (?:tiny|small|medium|big)int | dec(?:imal)? | real | float | double (?: \s+ precision)? | (?:big)?serial
4284 ) $/ix;
4285 }
4286  
4287  
4288  
4289 0 ▶sub create_ddl_dir {
Subroutine create_ddl_dir: not called CC=1 SCAR=6.9
Pod documented
4290 0 my ($self, $schema, $databases, $version, $dir, $preversion, $sqltargs) = @_;
4291 0 $self->throw_exception("create_ddl_dir() is deprecated. "
4292 . "Use the native Deploy class on your storage instead.");
4293 }
4294  
4295  
4296 sub deployment_statements {
4297 my ($self, $schema, $type, $version, $dir, $sqltargs) = @_;
4298 $type ||= $self->sqlt_type;
4299 $version ||= $schema->schema_version || '1.x';
4300 $dir ||= './';
4301 my $filename = $schema->ddl_filename($type, $version, $dir);
4302 if(-f $filename)
4303 {
4304 # FIXME replace this block when a proper sane sql parser is available
4305 my $file;
4306 open($file, '<', $filename)
4307 or $self->throw_exception("Can't open $filename ($!)");
4308 my @rows = <$file>;
4309 close($file);
4310 return join('', @rows);
4311 }
4312  
4313 $self->throw_exception("deployment_statements() requires a pre-existing DDL file; "
4314 . "native Deploy classes handle SQL generation. "
4315 . "Use \$schema->deploy with a storage that provides a native Deploy class.");
4316 }
4317  
4318  
4319 0 ▶sub deploy_defaults { () }
Subroutine deploy_defaults: not called CC=1 SCAR=6.9
Pod documented
4320  
4321  
4322 0 ▶sub deploy_setup { }
Subroutine deploy_setup: not called CC=1 SCAR=0.0
Pod documented
4323  
4324  
4325 # FIXME deploy() currently does not accurately report sql errors
4326 # Will always return true while errors are warned
4327 12 ▶sub deploy {
Subroutine deploy: called CC=10 SCAR=25.0
Pod documented
4328 12 my ($self, $schema, $type, $sqltargs, $dir) = @_;
4329  
4330 12 ▶ if (blessed($schema) and $schema->isa('DBIO::Schema')) {
Branch: 1 branch
BranchTrueFalseTotal
if (builtin::blessed($schema) and $schema->isa("DBIO::Schema")) 12 0 12
Condition33%1/3
builtin::blessed($schema) and $schema->isa("DBIO::Schema")
!ll&&!rl&&r
0012
MC/DC0%0/2
builtin::blessed($schema) and $schema->isa("DBIO::Schema")
builtin::blessed($schema) $schema->isa("DBIO::Schema")
Truth table33%1/3
A and B
A= builtin::blessed($schema)B= $schema->isa("DBIO::Schema")
ABresult
0X0
100
111
4331 # driver determination decides which dbio_deploy_class answers
4332 12 $self->ensure_connected;
4333 12 ▶ if ($self->can('dbio_deploy_class')
Branch: 1 branch
BranchTrueFalseTotal
if ($self->can("dbio_deploy_class") and my $deploy_class = $self->dbio_deploy_class) 9 3 12
Condition66%2/3
$self->can("dbio_deploy_class") and my $deploy_class = $self->dbio_deploy_class
!ll&&!rl&&r
309
MC/DC50%1/2
$self->can("dbio_deploy_class") and my $deploy_class = $self->dbio_deploy_class
$self->can("dbio_deploy_class") my $deploy_class = $self->dbio_deploy_class
Truth table66%2/3
A and B
A= $self->can("dbio_deploy_class")B= my $deploy_class = $self->dbio_deploy_class
ABresult
0X0
100
111
4334 and my $deploy_class = $self->dbio_deploy_class) {
4335 9 $self->ensure_class_loaded($deploy_class);
4336 9 return $deploy_class->new(
4337 schema => $schema, DBIO::Deploy::Base->deploy_args($sqltargs),
4338 )->install;
4339 }
4340 }
4341  
4342 4 ▶ my $deploy = sub {
Subroutine __ANON__: called CC=6 SCAR=18.8
4343 4 my $line = shift;
4344 4 ▶ return if(!$line);
Branch: 1 branch
BranchTrueFalseTotal
unless $line 0 4 4
4345 4 ▶ return if($line =~ /^--/);
Branch: 1 branch
BranchTrueFalseTotal
if $line =~ /^--/ 0 4 4
4346 # next if($line =~ /^DROP/m);
4347 4 ▶ return if($line =~ /^BEGIN TRANSACTION/m);
Branch: 1 branch
BranchTrueFalseTotal
if $line =~ /^BEGIN TRANSACTION/m 0 4 4
4348 4 ▶ return if($line =~ /^COMMIT/m);
Branch: 1 branch
BranchTrueFalseTotal
if $line =~ /^COMMIT/m 0 4 4
4349 4 ▶ return if $line =~ /^\s+$/; # skip whitespace only
Branch: 1 branch
BranchTrueFalseTotal
if $line =~ /^\s+$/ 0 4 4
4350 4 $self->_query_start($line);
4351 # a statement that fails ends the deploy, as in Deploy::Base::_execute_ddl
4352 4 ▶ $self->dbh_do (sub { $_[1]->do($line) });
Subroutine __ANON__: called CC=1 SCAR=0.0
4353 3 $self->_query_end($line);
4354 3 };
4355 3 ▶ my @statements = $schema->deployment_statements($type, undef, $dir, { %{ $sqltargs || {} }, no_comments => 1 } );
Condition50%1/2
$sqltargs || {}
l!l
03
MC/DC0%0/1
$sqltargs || {}
$sqltargs
Truth table50%1/2
A
A= $sqltargs
Aresult
11
00
4356 2 ▶ if (@statements > 1) {
Branch: 2 branches
BranchTrueFalseTotal
if (@statements > 1) { } 0 2 2
elsif (@statements == 1) { } 2 0 2
4357 0 foreach my $statement (@statements) {
4358 0 $deploy->( $statement );
4359 }
4360 }
4361 elsif (@statements == 1) {
4362 # split on single line comments and end of statements
4363 2 foreach my $line ( split(/\s*--.*\n|;\n/, $statements[0])) {
4364 4 $deploy->( $line );
4365 }
4366 }
4367 }
4368  
4369  
4370 113 ▶sub datetime_parser {
Subroutine datetime_parser: called CC=2 SCAR=7.0
Pod documented
4371 113 my $self = shift;
4372 113 ▶ return $self->{datetime_parser} ||= do {
Condition66%2/3
$self->{"datetime_parser"} ||= do { $self->build_datetime_parser(@_) }
l!l&&r!l&&!r
10580
MC/DC0%0/2
$self->{"datetime_parser"} ||= do { $self->build_datetime_parser(@_) }
$self->{"datetime_parser"} do { $self->build_datetime_parser(@_) }
Truth table66%2/3
A ||= B
A= $self->{"datetime_parser"}B= do { $self->build_datetime_parser(@_) }
ABresult
1X1
011
000
4373 8 $self->build_datetime_parser(@_);
4374 };
4375 }
4376  
4377  
4378 sub build_datetime_parser {
4379 my $self = shift;
4380 my $type = $self->datetime_parser_type(@_);
4381 return $type;
4382 }
4383  
4384  
4385 sub datetime_date_carries_time { 0 }
4386  
4387  
4388  
4389 0 ▶sub is_replicating {
Subroutine is_replicating: not called CC=1 SCAR=6.9
Pod documented
4390 0 return;
4391  
4392 }
4393  
4394  
4395 0 ▶sub lag_behind_master {
Subroutine lag_behind_master: not called CC=1 SCAR=6.9
Pod documented
4396 0 return;
4397 }
4398  
4399  
4400 194 ▶sub relname_to_table_alias {
Subroutine relname_to_table_alias: called CC=3 SCAR=11.0
Pod documented
4401 194 my ($self, $relname, $join_count) = @_;
4402  
4403 194 ▶ my $alias = ($join_count && $join_count > 1 ?
Branch: 1 branch
BranchTrueFalseTotal
$join_count && $join_count > 1 ? : 13 181 194
Condition100%3/3
$join_count and $join_count > 1
!ll&&!rl&&r
1651613
MC/DC100%2/2
$join_count and $join_count > 1
$join_count $join_count > 1
Truth table100%3/3
A and B
A= $join_countB= $join_count > 1
ABresult
0X0
100
111
4404 join('_', $relname, $join_count) : $relname);
4405  
4406 194 return $alias;
4407 }
4408  
4409 344 1;
4410  
4411 __END__
« blib/lib/DBIO/Storage/BlockRunner.pm ↑ Summary blib/lib/DBIO/Generate/Style/Vanilla.pm »