X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FDBIx%2FClass%2FStorage.pm;h=6e17e9e624a53ba49c00a07723b6e0609b9ac601;hb=0c11ad0ee5c8407f6b87d6e15c62a1b445076dc0;hp=df4434ece19c888cf6829df56cbee95af655998d;hpb=ed213e857791d1cfb0f1a0e32674e81358e19564;p=dbsrgits%2FDBIx-Class.git diff --git a/lib/DBIx/Class/Storage.pm b/lib/DBIx/Class/Storage.pm index df4434e..6e17e9e 100644 --- a/lib/DBIx/Class/Storage.pm +++ b/lib/DBIx/Class/Storage.pm @@ -4,34 +4,28 @@ use strict; use warnings; use base qw/DBIx::Class/; +use mro 'c3'; -use Scalar::Util qw/weaken/; -use Carp::Clan qw/^DBIx::Class/; -use IO::File; +{ + package # Hide from PAUSE + DBIx::Class::Storage::NESTED_ROLLBACK_EXCEPTION; + use base 'DBIx::Class::Exception'; +} + +use DBIx::Class::Carp; +use DBIx::Class::Storage::BlockRunner; +use Scalar::Util qw/blessed weaken/; use DBIx::Class::Storage::TxnScopeGuard; +use Try::Tiny; +use namespace::clean; -__PACKAGE__->mk_group_accessors('simple' => qw/debug debugobj schema/); -__PACKAGE__->mk_group_accessors('inherited' => 'cursor_class'); +__PACKAGE__->mk_group_accessors(simple => qw/debug schema transaction_depth auto_savepoint savepoints/); +__PACKAGE__->mk_group_accessors(component_class => 'cursor_class'); __PACKAGE__->cursor_class('DBIx::Class::Cursor'); sub cursor { shift->cursor_class(@_); } -package # Hide from PAUSE - DBIx::Class::Storage::NESTED_ROLLBACK_EXCEPTION; - -use overload '"' => sub { - 'DBIx::Class::Storage::NESTED_ROLLBACK_EXCEPTION' -}; - -sub new { - my $class = shift; - my $self = {}; - return bless $self, $class; -} - -package DBIx::Class::Storage; - =head1 NAME DBIx::Class::Storage - Generic Storage Handler @@ -56,18 +50,14 @@ sub new { $self = ref $self if ref $self; - my $new = {}; - bless $new, $self; + my $new = bless( { + transaction_depth => 0, + savepoints => [], + }, $self); $new->set_schema($schema); - $new->debugobj(new DBIx::Class::Storage::Statistics()); - - #my $fh; - - my $debug_env = $ENV{DBIX_CLASS_STORAGE_DBI_DEBUG} - || $ENV{DBIC_TRACE}; - - $new->debug(1) if $debug_env; + $new->debug(1) + if $ENV{DBIX_CLASS_STORAGE_DBI_DEBUG} || $ENV{DBIC_TRACE}; $new; } @@ -82,7 +72,7 @@ storage object, such as during L. sub set_schema { my ($self, $schema) = @_; $self->schema($schema); - weaken($self->{schema}) if ref $self->{schema}; + weaken $self->{schema} if ref $self->{schema}; } =head2 connected @@ -119,8 +109,12 @@ Throws an exception - croaks. sub throw_exception { my $self = shift; - $self->schema->throw_exception(@_) if $self->schema; - croak @_; + if (ref $self and $self->schema) { + $self->schema->throw_exception(@_); + } + else { + DBIx::Class::Exception->throw(@_); + } } =head2 txn_do @@ -153,16 +147,16 @@ For example, }; my $rs; - eval { + try { $rs = $schema->txn_do($coderef); - }; - - if ($@) { # Transaction failed - die "something terrible has happened!" # - if ($@ =~ /Rollback failed/); # Rollback failed + } catch { + my $error = shift; + # Transaction failed + die "something terrible has happened!" + if ($error =~ /Rollback failed/); # Rollback failed deal_with_failed_transaction(); - } + }; In a nested transaction (calling txn_do() from within a txn_do() coderef) only the outermost transaction will issue a L, and txn_do() can be @@ -180,57 +174,16 @@ transaction failure. =cut sub txn_do { - my ($self, $coderef, @args) = @_; - - ref $coderef eq 'CODE' or $self->throw_exception - ('$coderef must be a CODE reference'); - - my (@return_values, $return_value); - - $self->txn_begin; # If this throws an exception, no rollback is needed - - my $wantarray = wantarray; # Need to save this since the context - # inside the eval{} block is independent - # of the context that called txn_do() - eval { - - # Need to differentiate between scalar/list context to allow for - # returning a list in scalar context to get the size of the list - if ($wantarray) { - # list context - @return_values = $coderef->(@args); - } elsif (defined $wantarray) { - # scalar context - $return_value = $coderef->(@args); - } else { - # void context - $coderef->(@args); - } - $self->txn_commit; - }; - - if ($@) { - my $error = $@; - - eval { - $self->txn_rollback; - }; - - if ($@) { - my $rollback_error = $@; - my $exception_class = "DBIx::Class::Storage::NESTED_ROLLBACK_EXCEPTION"; - $self->throw_exception($error) # propagate nested rollback - if $rollback_error =~ /$exception_class/; - - $self->throw_exception( - "Transaction aborted: $error. Rollback failed: ${rollback_error}" - ); - } else { - $self->throw_exception($error); # txn failed but rollback succeeded - } - } - - return $wantarray ? @return_values : $return_value; + my $self = shift; + my $coderef = shift; + + DBIx::Class::Storage::BlockRunner->new( + storage => $self, + run_code => $coderef, + run_args => \@_, # take a ref instead of a copy, to preserve coderef @_ aliasing semantics + wrap_txn => 1, + retry_handler => sub { ! ( $_[0]->retried_count or $_[0]->storage->connected ) }, + )->run; } =head2 txn_begin @@ -242,15 +195,46 @@ an entire code block to be executed transactionally. =cut -sub txn_begin { die "Virtual method!" } +sub txn_begin { + my $self = shift; + + if($self->transaction_depth == 0) { + $self->debugobj->txn_begin() + if $self->debug; + $self->_exec_txn_begin; + } + elsif ($self->auto_savepoint) { + $self->svp_begin; + } + $self->{transaction_depth}++; + +} =head2 txn_commit Issues a commit of the current transaction. +It does I perform an actual storage commit unless there's a DBIx::Class +transaction currently in effect (i.e. you called L). + =cut -sub txn_commit { die "Virtual method!" } +sub txn_commit { + my $self = shift; + + if ($self->transaction_depth == 1) { + $self->debugobj->txn_commit() if $self->debug; + $self->_exec_txn_commit; + $self->{transaction_depth}--; + } + elsif($self->transaction_depth > 1) { + $self->{transaction_depth}--; + $self->svp_release if $self->auto_savepoint; + } + else { + $self->throw_exception( 'Refusing to commit without a started transaction' ); + } +} =head2 txn_rollback @@ -260,7 +244,31 @@ which allows the rollback to propagate to the outermost transaction. =cut -sub txn_rollback { die "Virtual method!" } +sub txn_rollback { + my $self = shift; + + if ($self->transaction_depth == 1) { + $self->debugobj->txn_rollback() if $self->debug; + $self->_exec_txn_rollback; + $self->{transaction_depth}--; + } + elsif ($self->transaction_depth > 1) { + $self->{transaction_depth}--; + + if ($self->auto_savepoint) { + $self->svp_rollback; + $self->svp_release; + } + else { + DBIx::Class::Storage::NESTED_ROLLBACK_EXCEPTION->throw( + "A txn_rollback in nested transaction is ineffective! (depth $self->{transaction_depth})" + ); + } + } + else { + $self->throw_exception( 'Refusing to roll back without a started transaction' ); + } +} =head2 svp_begin @@ -271,7 +279,30 @@ is provided, a random name will be used. =cut -sub svp_begin { die "Virtual method!" } +sub svp_begin { + my ($self, $name) = @_; + + $self->throw_exception ("You can't use savepoints outside a transaction") + unless $self->transaction_depth; + + my $exec = $self->can('_exec_svp_begin') + or $self->throw_exception ("Your Storage implementation doesn't support savepoints"); + + $name = $self->_svp_generate_name + unless defined $name; + + push @{ $self->{savepoints} }, $name; + + $self->debugobj->svp_begin($name) if $self->debug; + + $exec->($self, $name); +} + +sub _svp_generate_name { + my ($self) = @_; + return 'savepoint_'.scalar(@{ $self->{'savepoints'} }); +} + =head2 svp_release @@ -283,7 +314,35 @@ release all savepoints created after the one explicitly released as well. =cut -sub svp_release { die "Virtual method!" } +sub svp_release { + my ($self, $name) = @_; + + $self->throw_exception ("You can't use savepoints outside a transaction") + unless $self->transaction_depth; + + my $exec = $self->can('_exec_svp_release') + or $self->throw_exception ("Your Storage implementation doesn't support savepoints"); + + if (defined $name) { + my @stack = @{ $self->savepoints }; + my $svp; + + do { $svp = pop @stack } until $svp eq $name; + + $self->throw_exception ("Savepoint '$name' does not exist") + unless $svp; + + $self->savepoints(\@stack); # put back what's left + } + else { + $name = pop @{ $self->savepoints } + or $self->throw_exception('No savepoints to release');; + } + + $self->debugobj->svp_release($name) if $self->debug; + + $exec->($self, $name); +} =head2 svp_rollback @@ -295,13 +354,59 @@ release all savepoints created after the savepoint we rollback to. =cut -sub svp_rollback { die "Virtual method!" } +sub svp_rollback { + my ($self, $name) = @_; + + $self->throw_exception ("You can't use savepoints outside a transaction") + unless $self->transaction_depth; -=for comment + my $exec = $self->can('_exec_svp_rollback') + or $self->throw_exception ("Your Storage implementation doesn't support savepoints"); + + if (defined $name) { + my @stack = @{ $self->savepoints }; + my $svp; + + # a rollback doesn't remove the named savepoint, + # only everything after it + while (@stack and $stack[-1] ne $name) { + pop @stack + }; + + $self->throw_exception ("Savepoint '$name' does not exist") + unless @stack; + + $self->savepoints(\@stack); # put back what's left + } + else { + $name = $self->savepoints->[-1] + or $self->throw_exception('No savepoints to rollback');; + } + + $self->debugobj->svp_rollback($name) if $self->debug; + + $exec->($self, $name); +} =head2 txn_scope_guard -Return an object that does stuff. +An alternative way of transaction handling based on +L: + + my $txn_guard = $storage->txn_scope_guard; + + $row->col1("val1"); + $row->update; + + $txn_guard->commit; + +If an exception occurs, or the guard object otherwise leaves the scope +before C<< $txn_guard->commit >> is called, the transaction will be rolled +back by an explicit L call. In essence this is akin to +using a L/L pair, without having to worry +about calling L at the right places. Note that since there +is no defined code closure, there will be no retries and other magic upon +database disconnection. If you need such functionality see L. =cut @@ -312,7 +417,7 @@ sub txn_scope_guard { =head2 sql_maker Returns a C object - normally an object of class -C. +C. =cut @@ -320,8 +425,8 @@ sub sql_maker { die "Virtual method!" } =head2 debug -Causes trace information to be emitted on the C object. -(or C if C has not specifically been set). +Causes trace information to be emitted on the L object. +(or C if L has not specifically been set). This is the equivalent to setting L in your shell environment. @@ -329,7 +434,7 @@ shell environment. =head2 debugfh Set or retrieve the filehandle used for trace/debug output. This should be -an IO::Handle compatible ojbect (only the C method is used. Initially +an IO::Handle compatible object (only the C method is used. Initially set to be STDERR - although see information on the L environment variable. @@ -350,13 +455,49 @@ of L that is compatible with the original method of using a coderef as a callback. See the aforementioned Statistics class for more information. +=cut + +sub debugobj { + my $self = shift; + + if (@_) { + return $self->{debugobj} = $_[0]; + } + + $self->{debugobj} ||= do { + if (my $profile = $ENV{DBIC_TRACE_PROFILE}) { + require DBIx::Class::Storage::Debug::PrettyPrint; + if ($profile =~ /^\.?\//) { + require Config::Any; + + my $cfg = try { + Config::Any->load_files({ files => [$profile], use_ext => 1 }); + } catch { + # sanitize the error message a bit + $_ =~ s/at \s+ .+ Storage\.pm \s line \s \d+ $//x; + $self->throw_exception("Failure processing \$ENV{DBIC_TRACE_PROFILE}: $_"); + }; + + DBIx::Class::Storage::Debug::PrettyPrint->new(values %{$cfg->[0]}); + } + else { + DBIx::Class::Storage::Debug::PrettyPrint->new({ profile => $profile }); + } + } + else { + require DBIx::Class::Storage::Statistics; + DBIx::Class::Storage::Statistics->new + } + }; +} + =head2 debugcb Sets a callback to be executed each time a statement is run; takes a sub reference. Callback is executed as $sub->($op, $info) where $op is SELECT/INSERT/UPDATE/DELETE and $info is what would normally be printed. -See L for a better way. +See L for a better way. =cut @@ -438,15 +579,6 @@ only. sub select_single { die "Virtual method!" } -=head2 reload_row ($row) - -given a L object, 'reloads' it from the storage. This will -destroy any existing changes you have not yet saved. - -=cut - -sub reload_row { die "Virtual method!" } - =head2 columns_info_for Returns metadata for the given source's columns. This @@ -462,16 +594,26 @@ sub columns_info_for { die "Virtual method!" } =head2 DBIC_TRACE If C is set then trace information -is produced (as when the L method is set). +is produced (as when the L method is set). If the value is of the form C<1=/path/name> then the trace output is written to the file C. This environment variable is checked when the storage object is first -created (when you call connect on your schema). So, run-time changes -to this environment variable will not take effect unless you also +created (when you call connect on your schema). So, run-time changes +to this environment variable will not take effect unless you also re-connect on your schema. +=head2 DBIC_TRACE_PROFILE + +If C is set, L +will be used to format the output from C. The value it +is set to is the C that it will be used. If the value is a +filename the file is read with L and the results are +used as the configuration for tracing. See L +for what that structure should look like. + + =head2 DBIX_CLASS_STORAGE_DBI_DEBUG Old name for DBIC_TRACE @@ -481,11 +623,9 @@ Old name for DBIC_TRACE L - reference storage implementation using SQL::Abstract and DBI. -=head1 AUTHORS - -Matt S. Trout +=head1 AUTHOR AND CONTRIBUTORS -Andy Grundman +See L and L in DBIx::Class =head1 LICENSE