DBIx/Class/Storage.pm

filter: Statementstmt 82.1% 133 / 162 Branchbran 76.9% 60 / 78 Conditioncond 66.6% 8 / 12 MC/DCmcdc 37.5% 3 / 8 Subroutinesub 61.3% 27 / 44 Podpod 96.3% 26 / 27 totaltotal 77.6% 257 / 331 CC 44 SCAR 14.8
CC
44
Cov
80%
debugobj
10.4
svp_rollback
9.3
svp_release
8.1
CRAP 4.4
« DBIx/Class/CDBICompat/ColumnCase.pm ↑ Summary DBIx/Class/UTF8Columns.pm »
1 package DBIx::Class::Storage;
2  
3 267 ▶use strict;
Subroutine BEGIN: called CC=1 SCAR=0.0
4 267 ▶use warnings;
Subroutine BEGIN: called CC=1 SCAR=0.0
5  
6 267 ▶use base qw/DBIx::Class/;
Subroutine BEGIN: called CC=1 SCAR=0.0
7 267 ▶use mro 'c3';
Subroutine BEGIN: called CC=1 SCAR=0.0
8  
9 {
10 package # Hide from PAUSE
11 DBIx::Class::Storage::NESTED_ROLLBACK_EXCEPTION;
12 267 ▶ use base 'DBIx::Class::Exception';
Subroutine BEGIN: called CC=1 SCAR=0.0
13 }
14  
15 267 ▶use DBIx::Class::Carp;
Subroutine BEGIN: called CC=1 SCAR=0.0
16 267 ▶use DBIx::Class::Storage::BlockRunner;
Subroutine BEGIN: called CC=1 SCAR=0.0
17 267 ▶use Scalar::Util qw/blessed weaken/;
Subroutine BEGIN: called CC=1 SCAR=0.0
18 267 ▶use DBIx::Class::Storage::TxnScopeGuard;
Subroutine BEGIN: called CC=1 SCAR=0.0
19 267 ▶use Try::Tiny;
Subroutine BEGIN: called CC=1 SCAR=0.0
20 267 ▶use namespace::clean;
Subroutine BEGIN: called CC=1 SCAR=0.0
21  
22 267 __PACKAGE__->mk_group_accessors(simple => qw/debug schema transaction_depth auto_savepoint savepoints/);
23 267 __PACKAGE__->mk_group_accessors(component_class => 'cursor_class');
24  
25 267 __PACKAGE__->cursor_class('DBIx::Class::Cursor');
26  
27 0 ▶sub cursor { shift->cursor_class(@_); }
Subroutine cursor: not called CC=1 SCAR=6.9
Pod undocumented
28  
29 =head1 NAME
30  
31 DBIx::Class::Storage - Generic Storage Handler
32  
33 =head1 DESCRIPTION
34  
35 A base implementation of common Storage methods. For specific
36 information about L<DBI>-based storage, see L<DBIx::Class::Storage::DBI>.
37  
38 =head1 METHODS
39  
40 =head2 new
41  
42 Arguments: $schema
43  
44 Instantiates the Storage object.
45  
46 =cut
47  
48 456 ▶sub new {
Subroutine new: called CC=4 SCAR=14.0
Pod documented
49 456 my ($self, $schema) = @_;
50  
51 456 ▶ $self = ref $self if ref $self;
Branch: 1 branch
BranchTrueFalseTotal
if ref $self 0 456 456
52  
53 456 my $new = bless( {
54 transaction_depth => 0,
55 savepoints => [],
56 }, $self);
57  
58 456 $new->set_schema($schema);
59 $new->debug(1)
60 456 ▶ if $ENV{DBIX_CLASS_STORAGE_DBI_DEBUG} || $ENV{DBIC_TRACE};
Branch: 1 branch
BranchTrueFalseTotal
if $ENV{"DBIX_CLASS_STORAGE_DBI_DEBUG"} or $ENV{"DBIC_TRACE"} 1 455 456
Condition66%2/3
$ENV{"DBIX_CLASS_STORAGE_DBI_DEBUG"} or $ENV{"DBIC_TRACE"}
l!l&&r!l&&!r
01455
MC/DC50%1/2
$ENV{"DBIX_CLASS_STORAGE_DBI_DEBUG"} or $ENV{"DBIC_TRACE"}
$ENV{"DBIX_CLASS_STORAGE_DBI_DEBUG"} $ENV{"DBIC_TRACE"}
Truth table66%2/3
A or B
A= $ENV{"DBIX_CLASS_STORAGE_DBI_DEBUG"}B= $ENV{"DBIC_TRACE"}
ABresult
1X1
011
000
61  
62 456 $new;
63 }
64  
65 =head2 set_schema
66  
67 Used to reset the schema class or object which owns this
68 storage object, such as during L<DBIx::Class::Schema/clone>.
69  
70 =cut
71  
72 463 ▶sub set_schema {
Subroutine set_schema: called CC=2 SCAR=6.9
Pod documented
73 463 my ($self, $schema) = @_;
74 463 $self->schema($schema);
75 463 ▶ weaken $self->{schema} if ref $self->{schema};
Branch: 1 branch
BranchTrueFalseTotal
if ref $self->{"schema"} 449 14 463
76 }
77  
78 =head2 connected
79  
80 Returns true if we have an open storage connection, false
81 if it is not (yet) open.
82  
83 =cut
84  
85 0 ▶sub connected { die "Virtual method!" }
Subroutine connected: not called CC=1 SCAR=6.9
Pod documented
86  
87 =head2 disconnect
88  
89 Closes any open storage connection unconditionally.
90  
91 =cut
92  
93 0 ▶sub disconnect { die "Virtual method!" }
Subroutine disconnect: not called CC=1 SCAR=6.9
Pod documented
94  
95 =head2 ensure_connected
96  
97 Initiate a connection to the storage if one isn't already open.
98  
99 =cut
100  
101 0 ▶sub ensure_connected { die "Virtual method!" }
Subroutine ensure_connected: not called CC=1 SCAR=6.9
Pod documented
102  
103 =head2 throw_exception
104  
105 Throws an exception - croaks.
106  
107 =cut
108  
109 670 ▶sub throw_exception {
Subroutine throw_exception: called CC=3 SCAR=11.0
Pod documented
110 670 my $self = shift;
111  
112 670 ▶ if (ref $self and $self->schema) {
Branch: 1 branch
BranchTrueFalseTotal
if (ref $self and $self->schema) { } 669 1 670
Condition66%2/3
ref $self and $self->schema
!ll&&!rl&&r
01669
MC/DC50%1/2
ref $self and $self->schema
ref $self $self->schema
Truth table66%2/3
A and B
A= ref $selfB= $self->schema
ABresult
0X0
100
111
113 669 $self->schema->throw_exception(@_);
114 }
115 else {
116 1 DBIx::Class::Exception->throw(@_);
117 }
118 }
119  
120 =head2 txn_do
121  
122 =over 4
123  
124 =item Arguments: C<$coderef>, @coderef_args?
125  
126 =item Return Value: The return value of $coderef
127  
128 =back
129  
130 Executes C<$coderef> with (optional) arguments C<@coderef_args> atomically,
131 returning its result (if any). If an exception is caught, a rollback is issued
132 and the exception is rethrown. If the rollback fails, (i.e. throws an
133 exception) an exception is thrown that includes a "Rollback failed" message.
134  
135 For example,
136  
137 my $author_rs = $schema->resultset('Author')->find(1);
138 my @titles = qw/Night Day It/;
139  
140 my $coderef = sub {
141 # If any one of these fails, the entire transaction fails
142 $author_rs->create_related('books', {
143 title => $_
144 }) foreach (@titles);
145  
146 return $author->books;
147 };
148  
149 my $rs;
150 try {
151 $rs = $schema->txn_do($coderef);
152 } catch {
153 my $error = shift;
154 # Transaction failed
155 die "something terrible has happened!"
156 if ($error =~ /Rollback failed/); # Rollback failed
157  
158 deal_with_failed_transaction();
159 };
160  
161 In a nested transaction (calling txn_do() from within a txn_do() coderef) only
162 the outermost transaction will issue a L</txn_commit>, and txn_do() can be
163 called in void, scalar and list context and it will behave as expected.
164  
165 Please note that all of the code in your coderef, including non-DBIx::Class
166 code, is part of a transaction. This transaction may fail out halfway, or
167 it may get partially double-executed (in the case that our DB connection
168 failed halfway through the transaction, in which case we reconnect and
169 restart the txn). Therefore it is best that any side-effects in your coderef
170 are idempotent (that is, can be re-executed multiple times and get the
171 same result), and that you check up on your side-effects in the case of
172 transaction failure.
173  
174 =cut
175  
176 472 ▶sub txn_do {
Subroutine txn_do: called CC=1 SCAR=0.1
Pod documented
177 472 my $self = shift;
178  
179 DBIx::Class::Storage::BlockRunner->new(
180 storage => $self,
181 wrap_txn => 1,
182 16 ▶ retry_handler => sub {
Subroutine __ANON__: called CC=2 SCAR=7.6
183 16 ▶ $_[0]->failed_attempt_count == 1
Branch: 1 branch
BranchTrueFalseTotal
$_[0]->failed_attempt_count == 1 and not $_[0]->storage->connected 16 0 16
184 and
185 ! $_[0]->storage->connected
186 },
187 472 )->run(@_);
188 }
189  
190 =head2 txn_begin
191  
192 Starts a transaction.
193  
194 See the preferred L</txn_do> method, which allows for
195 an entire code block to be executed transactionally.
196  
197 =cut
198  
199 9380 ▶sub txn_begin {
Subroutine txn_begin: called CC=4 SCAR=13.9
Pod documented
200 9380 my $self = shift;
201  
202 9380 ▶ if($self->transaction_depth == 0) {
Branch: 2 branches
BranchTrueFalseTotal
if ($self->transaction_depth == 0) { } 8664 716 9380
elsif ($self->auto_savepoint) { } 4 712 716
203 8664 ▶ $self->debugobj->txn_begin()
Branch: 1 branch
BranchTrueFalseTotal
if $self->debug 18 8646 8664
204 if $self->debug;
205 8664 $self->_exec_txn_begin;
206 }
207 elsif ($self->auto_savepoint) {
208 4 $self->svp_begin;
209 }
210 9380 $self->{transaction_depth}++;
211  
212 }
213  
214 =head2 txn_commit
215  
216 Issues a commit of the current transaction.
217  
218 It does I<not> perform an actual storage commit unless there's a DBIx::Class
219 transaction currently in effect (i.e. you called L</txn_begin>).
220  
221 =cut
222  
223 9098 ▶sub txn_commit {
Subroutine txn_commit: called CC=5 SCAR=16.2
Pod documented
224 9098 my $self = shift;
225  
226 9098 ▶ if ($self->transaction_depth == 1) {
Branch: 2 branches
BranchTrueFalseTotal
if ($self->transaction_depth == 1) { } 8498 600 9098
elsif ($self->transaction_depth > 1) { } 600 0 600
227 8498 ▶ $self->debugobj->txn_commit() if $self->debug;
Branch: 1 branch
BranchTrueFalseTotal
if $self->debug 16 8482 8498
228 8498 $self->_exec_txn_commit;
229 8498 $self->{transaction_depth}--;
230 8498 $self->savepoints([]);
231 }
232 elsif($self->transaction_depth > 1) {
233 600 $self->{transaction_depth}--;
234 600 ▶ $self->svp_release if $self->auto_savepoint;
Branch: 1 branch
BranchTrueFalseTotal
if $self->auto_savepoint 2 598 600
235 }
236 else {
237 0 $self->throw_exception( 'Refusing to commit without a started transaction' );
238 }
239 }
240  
241 =head2 txn_rollback
242  
243 Issues a rollback of the current transaction. A nested rollback will
244 throw a L<DBIx::Class::Storage::NESTED_ROLLBACK_EXCEPTION> exception,
245 which allows the rollback to propagate to the outermost transaction.
246  
247 =cut
248  
249 244 ▶sub txn_rollback {
Subroutine txn_rollback: called CC=5 SCAR=16.1
Pod documented
250 244 my $self = shift;
251  
252 244 ▶ if ($self->transaction_depth == 1) {
Branch: 2 branches
BranchTrueFalseTotal
if ($self->transaction_depth == 1) { } 130 114 244
elsif ($self->transaction_depth > 1) { } 114 0 114
253 130 ▶ $self->debugobj->txn_rollback() if $self->debug;
Branch: 1 branch
BranchTrueFalseTotal
if $self->debug 2 128 130
254 130 $self->_exec_txn_rollback;
255 130 $self->{transaction_depth}--;
256 130 $self->savepoints([]);
257 }
258 elsif ($self->transaction_depth > 1) {
259 114 $self->{transaction_depth}--;
260  
261 114 ▶ if ($self->auto_savepoint) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->auto_savepoint) { } 2 112 114
262 2 $self->svp_rollback;
263 2 $self->svp_release;
264 }
265 else {
266 112 DBIx::Class::Storage::NESTED_ROLLBACK_EXCEPTION->throw(
267 "A txn_rollback in nested transaction is ineffective! (depth $self->{transaction_depth})"
268 );
269 }
270 }
271 else {
272 0 $self->throw_exception( 'Refusing to roll back without a started transaction' );
273 }
274 }
275  
276 =head2 svp_begin
277  
278 Arguments: $savepoint_name?
279  
280 Created a new savepoint using the name provided as argument. If no name
281 is provided, a random name will be used.
282  
283 =cut
284  
285 21 ▶sub svp_begin {
Subroutine svp_begin: called CC=5 SCAR=16.2
Pod documented
286 21 my ($self, $name) = @_;
287  
288 21 ▶ $self->throw_exception ("You can't use savepoints outside a transaction")
Branch: 1 branch
BranchTrueFalseTotal
unless $self->transaction_depth 0 21 21
289 unless $self->transaction_depth;
290  
291 21 ▶ my $exec = $self->can('_exec_svp_begin')
Branch: 1 branch
BranchTrueFalseTotal
my $exec = $self->can("_exec_svp_begin") or $self->throw_exception("Your Storage implementation doesn't support savepoints") 21 0 21
292 or $self->throw_exception ("Your Storage implementation doesn't support savepoints");
293  
294 21 ▶ $name = $self->_svp_generate_name
Branch: 1 branch
BranchTrueFalseTotal
unless defined $name 17 4 21
295 unless defined $name;
296  
297 21 push @{ $self->{savepoints} }, $name;
298  
299 21 ▶ $self->debugobj->svp_begin($name) if $self->debug;
Branch: 1 branch
BranchTrueFalseTotal
if $self->debug 9 12 21
300  
301 21 $exec->($self, $name);
302 }
303  
304 17 ▶sub _svp_generate_name {
Subroutine _svp_generate_name: called CC=1 SCAR=0.0
305 17 my ($self) = @_;
306 17 return 'savepoint_'.scalar(@{ $self->{'savepoints'} });
307 }
308  
309  
310 =head2 svp_release
311  
312 Arguments: $savepoint_name?
313  
314 Release the savepoint provided as argument. If none is provided,
315 release the savepoint created most recently. This will implicitly
316 release all savepoints created after the one explicitly released as well.
317  
318 =cut
319  
320 10 ▶sub svp_release {
Subroutine svp_release: called CC=8 SCAR=20.9
Pod documented
321 10 my ($self, $name) = @_;
322  
323 10 ▶ $self->throw_exception ("You can't use savepoints outside a transaction")
Branch: 1 branch
BranchTrueFalseTotal
unless $self->transaction_depth 0 10 10
324 unless $self->transaction_depth;
325  
326 10 ▶ my $exec = $self->can('_exec_svp_release')
Branch: 1 branch
BranchTrueFalseTotal
my $exec = $self->can("_exec_svp_release") or $self->throw_exception("Your Storage implementation doesn't support savepoints") 10 0 10
327 or $self->throw_exception ("Your Storage implementation doesn't support savepoints");
328  
329 10 ▶ if (defined $name) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $name) { } 2 8 10
330 2 my @stack = @{ $self->savepoints };
331 2 my $svp = '';
332  
333 2 ▶ while( $svp ne $name ) {
Branch: 1 branch
BranchTrueFalseTotal
if ($svp ne $name) 3 1 4
334  
335 3 ▶ $self->throw_exception ("Savepoint '$name' does not exist")
Branch: 1 branch
BranchTrueFalseTotal
unless @stack 1 2 3
336 unless @stack;
337  
338 2 $svp = pop @stack;
339 }
340  
341 1 $self->savepoints(\@stack); # put back what's left
342 }
343 else {
344 8 ▶ $name = pop @{ $self->savepoints }
Branch: 1 branch
BranchTrueFalseTotal
$name = pop @{$self->savepoints;} or $self->throw_exception("No savepoints to release") 8 0 8
345 or $self->throw_exception('No savepoints to release');;
346 }
347  
348 9 ▶ $self->debugobj->svp_release($name) if $self->debug;
Branch: 1 branch
BranchTrueFalseTotal
if $self->debug 5 4 9
349  
350 9 $exec->($self, $name);
351 }
352  
353 =head2 svp_rollback
354  
355 Arguments: $savepoint_name?
356  
357 Rollback to the savepoint provided as argument. If none is provided,
358 rollback to the savepoint created most recently. This will implicitly
359 release all savepoints created after the savepoint we rollback to.
360  
361 =cut
362  
363 14 ▶sub svp_rollback {
Subroutine svp_rollback: called CC=9 SCAR=22.3
Pod documented
364 14 my ($self, $name) = @_;
365  
366 14 ▶ $self->throw_exception ("You can't use savepoints outside a transaction")
Branch: 1 branch
BranchTrueFalseTotal
unless $self->transaction_depth 0 14 14
367 unless $self->transaction_depth;
368  
369 14 ▶ my $exec = $self->can('_exec_svp_rollback')
Branch: 1 branch
BranchTrueFalseTotal
my $exec = $self->can("_exec_svp_rollback") or $self->throw_exception("Your Storage implementation doesn't support savepoints") 14 0 14
370 or $self->throw_exception ("Your Storage implementation doesn't support savepoints");
371  
372 14 ▶ if (defined $name) {
Branch: 1 branch
BranchTrueFalseTotal
if (defined $name) { } 2 12 14
373 2 my @stack = @{ $self->savepoints };
374 2 my $svp;
375  
376 # a rollback doesn't remove the named savepoint,
377 # only everything after it
378 2 ▶ while (@stack and $stack[-1] ne $name) {
Branch: 1 branch
BranchTrueFalseTotal
if (@stack and $stack[-1] ne $name) 2 2 4
Condition66%2/3
@stack and $stack[-1] ne $name
!ll&&!rl&&r
022
MC/DC50%1/2
@stack and $stack[-1] ne $name
@stack $stack[-1] ne $name
Truth table66%2/3
A and B
A= @stackB= $stack[-1] ne $name
ABresult
0X0
100
111
379 pop @stack
380 2 };
381  
382 2 ▶ $self->throw_exception ("Savepoint '$name' does not exist")
Branch: 1 branch
BranchTrueFalseTotal
unless @stack 0 2 2
383 unless @stack;
384  
385 2 $self->savepoints(\@stack); # put back what's left
386 }
387 else {
388 12 ▶ $name = $self->savepoints->[-1]
Branch: 1 branch
BranchTrueFalseTotal
$name = $self->savepoints->[-1] or $self->throw_exception("No savepoints to rollback") 12 0 12
389 or $self->throw_exception('No savepoints to rollback');;
390 }
391  
392 14 ▶ $self->debugobj->svp_rollback($name) if $self->debug;
Branch: 1 branch
BranchTrueFalseTotal
if $self->debug 6 8 14
393  
394 14 $exec->($self, $name);
395 }
396  
397 =head2 txn_scope_guard
398  
399 An alternative way of transaction handling based on
400 L<DBIx::Class::Storage::TxnScopeGuard>:
401  
402 my $txn_guard = $storage->txn_scope_guard;
403  
404 $result->col1("val1");
405 $result->update;
406  
407 $txn_guard->commit;
408  
409 If an exception occurs, or the guard object otherwise leaves the scope
410 before C<< $txn_guard->commit >> is called, the transaction will be rolled
411 back by an explicit L</txn_rollback> call. In essence this is akin to
412 using a L</txn_begin>/L</txn_commit> pair, without having to worry
413 about calling L</txn_rollback> at the right places. Note that since there
414 is no defined code closure, there will be no retries and other magic upon
415 database disconnection. If you need such functionality see L</txn_do>.
416  
417 =cut
418  
419 8911 ▶sub txn_scope_guard {
Subroutine txn_scope_guard: called CC=1 SCAR=0.0
Pod documented
420 8911 return DBIx::Class::Storage::TxnScopeGuard->new($_[0]);
421 }
422  
423 =head2 sql_maker
424  
425 Returns a C<sql_maker> object - normally an object of class
426 C<DBIx::Class::SQLMaker>.
427  
428 =cut
429  
430 0 ▶sub sql_maker { die "Virtual method!" }
Subroutine sql_maker: not called CC=1 SCAR=6.9
Pod documented
431  
432 =head2 debug
433  
434 Causes trace information to be emitted on the L</debugobj> object.
435 (or C<STDERR> if L</debugobj> has not specifically been set).
436  
437 This is the equivalent to setting L</DBIC_TRACE> in your
438 shell environment.
439  
440 =head2 debugfh
441  
442 An opportunistic proxy to L<< ->debugobj->debugfh(@_)
443 |DBIx::Class::Storage::Statistics/debugfh >>
444 If the currently set L</debugobj> does not have a L</debugfh> method, caling
445 this is a no-op.
446  
447 =cut
448  
449 5 ▶sub debugfh {
Subroutine debugfh: called CC=2 SCAR=7.1
Pod documented
450 5 my $self = shift;
451  
452 5 ▶ if ($self->debugobj->can('debugfh')) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->debugobj->can("debugfh")) 5 0 5
453 5 return $self->debugobj->debugfh(@_);
454 }
455 }
456  
457 =head2 debugobj
458  
459 Sets or retrieves the object used for metric collection. Defaults to an instance
460 of L<DBIx::Class::Storage::Statistics> that is compatible with the original
461 method of using a coderef as a callback. See the aforementioned Statistics
462 class for more information.
463  
464 =cut
465  
466 374 ▶sub debugobj {
Subroutine debugobj: called CC=5 SCAR=23.4
Pod documented
467 374 my $self = shift;
468  
469 374 ▶ if (@_) {
Branch: 1 branch
BranchTrueFalseTotal
if (@_) 4 370 374
470 4 return $self->{debugobj} = $_[0];
471 }
472  
473 370 ▶ $self->{debugobj} ||= do {
Condition66%2/3
$self->{"debugobj"} ||= do { if (my $profile = $ENV{"DBIC_TRACE_PROFILE"}) { require DBIx::Class::Storage::Debug::PrettyTrace; my @pp_args; if ($profile =~ m[^\.?/]) { require Config::Any; my $cfg = &try(sub { "Config::Any"->load_files({"files", [$profile], "use_ext", 1}); } , &catch(sub { $_ =~ s/at \s+ .+ Storage\.pm \s line \s \d+ $//x; $self->throw_exception("Failure processing \$ENV{DBIC_TRACE_PROFILE}: $_"); } )); @pp_args = values %{$$cfg[0];}; } else { @pp_args = {"profile", $profile}; } ; &try(sub { "DBIx::Class::Storage::Debug::PrettyTrace"->new(@pp_args); } , &catch(sub { $self->throw_exception($_); } )); } else { require DBIx::Class::Storage::Statistics; "DBIx::Class::Storage::Statistics"->new; } }
l!l&&r!l&&!r
36550
MC/DC0%0/2
$self->{"debugobj"} ||= do { if (my $profile = $ENV{"DBIC_TRACE_PROFILE"}) { require DBIx::Class::Storage::Debug::PrettyTrace; my @pp_args; if ($profile =~ m[^\.?/]) { require Config::Any; my $cfg = &try(sub { "Config::Any"->load_files({"files", [$profile], "use_ext", 1}); } , &catch(sub { $_ =~ s/at \s+ .+ Storage\.pm \s line \s \d+ $//x; $self->throw_exception("Failure processing \$ENV{DBIC_TRACE_PROFILE}: $_"); } )); @pp_args = values %{$$cfg[0];}; } else { @pp_args = {"profile", $profile}; } ; &try(sub { "DBIx::Class::Storage::Debug::PrettyTrace"->new(@pp_args); } , &catch(sub { $self->throw_exception($_); } )); } else { require DBIx::Class::Storage::Statistics; "DBIx::Class::Storage::Statistics"->new; } }
$self->{"debugobj"} do { if (my $profile = $ENV{"DBIC_TRACE_PROFILE"}) { require DBIx::Class::Storage::Debug::PrettyTrace; my @pp_args; if ($profile =~ m[^\.?/]) { require Config::Any; my $cfg = &try(sub { "Config::Any"->load_files({"files", [$profile], "use_ext", 1}); } , &catch(sub { $_ =~ s/at \s+ .+ Storage\.pm \s line \s \d+ $//x; $self->throw_exception("Failure processing \$ENV{DBIC_TRACE_PROFILE}: $_"); } )); @pp_args = values %{$$cfg[0];}; } else { @pp_args = {"profile", $profile}; } ; &try(sub { "DBIx::Class::Storage::Debug::PrettyTrace"->new(@pp_args); } , &catch(sub { $self->throw_exception($_); } )); } else { require DBIx::Class::Storage::Statistics; "DBIx::Class::Storage::Statistics"->new; } }
Truth table66%2/3
A ||= B
A= $self->{"debugobj"}B= do { if (my $profile = $ENV{"DBIC_TRACE_PROFILE"}) { require DBIx::Class::Storage::Debug::PrettyTrace; my @pp_args; if ($profile =~ m[^\.?/]) { require Config::Any; my $cfg = &try(sub { "Config::Any"->load_files({"files", [$profile], "use_ext", 1}); } , &catch(sub { $_ =~ s/at \s+ .+ Storage\.pm \s line \s \d+ $//x; $self->throw_exception("Failure processing \$ENV{DBIC_TRACE_PROFILE}: $_"); } )); @pp_args = values %{$$cfg[0];}; } else { @pp_args = {"profile", $profile}; } ; &try(sub { "DBIx::Class::Storage::Debug::PrettyTrace"->new(@pp_args); } , &catch(sub { $self->throw_exception($_); } )); } else { require DBIx::Class::Storage::Statistics; "DBIx::Class::Storage::Statistics"->new; } }
ABresult
1X1
011
000
474 5 ▶ if (my $profile = $ENV{DBIC_TRACE_PROFILE}) {
Branch: 1 branch
BranchTrueFalseTotal
if (my $profile = $ENV{'DBIC_TRACE_PROFILE'}) { } 0 5 5
475 0 require DBIx::Class::Storage::Debug::PrettyTrace;
476 0 my @pp_args;
477  
478 0 ▶ if ($profile =~ /^\.?\//) {
Branch: 1 branch
BranchTrueFalseTotal
if ($profile =~ m[^\.?/]) { } 0 0 0
479 0 require Config::Any;
480  
481 0 ▶ my $cfg = try {
Subroutine __ANON__: not called CC=1 SCAR=6.9
482 0 Config::Any->load_files({ files => [$profile], use_ext => 1 });
483 0 ▶ } catch {
Subroutine __ANON__: not called CC=1 SCAR=6.9
484 # sanitize the error message a bit
485 0 $_ =~ s/at \s+ .+ Storage\.pm \s line \s \d+ $//x;
486 0 $self->throw_exception("Failure processing \$ENV{DBIC_TRACE_PROFILE}: $_");
487 0 };
488  
489 0 @pp_args = values %{$cfg->[0]};
490 }
491 else {
492 0 @pp_args = { profile => $profile };
493 }
494  
495 # FIXME - FRAGILE
496 # Hash::Merge is a sorry piece of shit and tramples all over $@
497 # *without* throwing an exception
498 # This is a rather serious problem in the debug codepath
499 # Insulate the condition here with a try{} until a review of
500 # DBIx::Class::Storage::Debug::PrettyTrace takes place
501 # we do rethrow the error unconditionally, the only reason
502 # to try{} is to preserve the precise state of $@ (down
503 # to the scalar (if there is one) address level)
504 #
505 # Yes I am aware this is fragile and TxnScopeGuard needs
506 # a better fix. This is another yak to shave... :(
507 0 ▶ try {
Subroutine __ANON__: not called CC=1 SCAR=6.9
508 0 DBIx::Class::Storage::Debug::PrettyTrace->new(@pp_args);
509 0 ▶ } catch {
Subroutine __ANON__: not called CC=1 SCAR=6.9
510 0 $self->throw_exception($_);
511 }
512 0 }
513 else {
514 5 require DBIx::Class::Storage::Statistics;
515 5 DBIx::Class::Storage::Statistics->new
516 }
517 };
518 }
519  
520 =head2 debugcb
521  
522 Sets a callback to be executed each time a statement is run; takes a sub
523 reference. Callback is executed as $sub->($op, $info) where $op is
524 SELECT/INSERT/UPDATE/DELETE and $info is what would normally be printed.
525  
526 See L</debugobj> for a better way.
527  
528 =cut
529  
530 5 ▶sub debugcb {
Subroutine debugcb: called CC=2 SCAR=7.1
Pod documented
531 5 my $self = shift;
532  
533 5 ▶ if ($self->debugobj->can('callback')) {
Branch: 1 branch
BranchTrueFalseTotal
if ($self->debugobj->can("callback")) 5 0 5
534 5 return $self->debugobj->callback(@_);
535 }
536 }
537  
538 =head2 cursor_class
539  
540 The cursor class for this Storage object.
541  
542 =cut
543  
544 =head2 deploy
545  
546 Deploy the tables to storage (CREATE TABLE and friends in a SQL-based
547 Storage class). This would normally be called through
548 L<DBIx::Class::Schema/deploy>.
549  
550 =cut
551  
552 0 ▶sub deploy { die "Virtual method!" }
Subroutine deploy: not called CC=1 SCAR=6.9
Pod documented
553  
554 =head2 connect_info
555  
556 The arguments of C<connect_info> are always a single array reference,
557 and are Storage-handler specific.
558  
559 This is normally accessed via L<DBIx::Class::Schema/connection>, which
560 encapsulates its argument list in an arrayref before calling
561 C<connect_info> here.
562  
563 =cut
564  
565 0 ▶sub connect_info { die "Virtual method!" }
Subroutine connect_info: not called CC=1 SCAR=6.9
Pod documented
566  
567 =head2 select
568  
569 Handle a select statement.
570  
571 =cut
572  
573 0 ▶sub select { die "Virtual method!" }
Subroutine select: not called CC=1 SCAR=6.9
Pod documented
574  
575 =head2 insert
576  
577 Handle an insert statement.
578  
579 =cut
580  
581 0 ▶sub insert { die "Virtual method!" }
Subroutine insert: not called CC=1 SCAR=6.9
Pod documented
582  
583 =head2 update
584  
585 Handle an update statement.
586  
587 =cut
588  
589 0 ▶sub update { die "Virtual method!" }
Subroutine update: not called CC=1 SCAR=6.9
Pod documented
590  
591 =head2 delete
592  
593 Handle a delete statement.
594  
595 =cut
596  
597 0 ▶sub delete { die "Virtual method!" }
Subroutine delete: not called CC=1 SCAR=6.9
Pod documented
598  
599 =head2 select_single
600  
601 Performs a select, fetch and return of data - handles a single row
602 only.
603  
604 =cut
605  
606 0 ▶sub select_single { die "Virtual method!" }
Subroutine select_single: not called CC=1 SCAR=6.9
Pod documented
607  
608 =head2 columns_info_for
609  
610 Returns metadata for the given source's columns. This
611 is *deprecated*, and will be removed before 1.0. You should
612 be specifying the metadata yourself if you need it.
613  
614 =cut
615  
616 0 ▶sub columns_info_for { die "Virtual method!" }
Subroutine columns_info_for: not called CC=1 SCAR=6.9
Pod documented
617  
618 =head1 ENVIRONMENT VARIABLES
619  
620 =head2 DBIC_TRACE
621  
622 If C<DBIC_TRACE> is set then trace information
623 is produced (as when the L</debug> method is set).
624  
625 If the value is of the form C<1=/path/name> then the trace output is
626 written to the file C</path/name>.
627  
628 This environment variable is checked when the storage object is first
629 created (when you call connect on your schema). So, run-time changes
630 to this environment variable will not take effect unless you also
631 re-connect on your schema.
632  
633 =head2 DBIC_TRACE_PROFILE
634  
635 If C<DBIC_TRACE_PROFILE> is set, L<DBIx::Class::Storage::Debug::PrettyTrace>
636 will be used to format the output from C<DBIC_TRACE>. The value it
637 is set to is the C<profile> that it will be used. If the value is a
638 filename the file is read with L<Config::Any> and the results are
639 used as the configuration for tracing. See L<SQL::Abstract::Tree/new>
640 for what that structure should look like.
641  
642 =head2 DBIX_CLASS_STORAGE_DBI_DEBUG
643  
644 Old name for DBIC_TRACE
645  
646 =head1 SEE ALSO
647  
648 L<DBIx::Class::Storage::DBI> - reference storage implementation using
649 DBI and a subclass of SQL::Abstract::Classic ( or similar )
650  
651 =head1 FURTHER QUESTIONS?
652  
653 Check the list of L<additional DBIC resources|DBIx::Class/GETTING HELP/SUPPORT>.
654  
655 =head1 COPYRIGHT AND LICENSE
656  
657 This module is free software L<copyright|DBIx::Class/COPYRIGHT AND LICENSE>
658 by the L<DBIx::Class (DBIC) authors|DBIx::Class/AUTHORS>. You can
659 redistribute it and/or modify it under the same terms as the
660 L<DBIx::Class library|DBIx::Class/COPYRIGHT AND LICENSE>.
661  
662 =cut
663  
664 267 1;
« DBIx/Class/CDBICompat/ColumnCase.pm ↑ Summary DBIx/Class/UTF8Columns.pm »