X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FDBIx%2FClass%2FStorage%2FDBI.pm;h=355edf942b762ac17004e798810f20ed6384a177;hb=90a63099ad8b0269a300f6aa1c48d336e9e6c21e;hp=84969f62eb8ce19aa51b15f0b2dc8c5972b1cac7;hpb=086901c30dcd1c87b678c44bfd1d42ace0b5e18f;p=dbsrgits%2FDBIx-Class.git diff --git a/lib/DBIx/Class/Storage/DBI.pm b/lib/DBIx/Class/Storage/DBI.pm index 84969f6..355edf9 100644 --- a/lib/DBIx/Class/Storage/DBI.pm +++ b/lib/DBIx/Class/Storage/DBI.pm @@ -437,12 +437,24 @@ sub connect_info { } } - %attrs = () if (ref $args[0] eq 'CODE'); # _connect() never looks past $args[0] in this case + if (ref $args[0] eq 'CODE') { + # _connect() never looks past $args[0] in this case + %attrs = () + } else { + %attrs = ( + %{ $self->_default_dbi_connect_attributes || {} }, + %attrs, + ); + } $self->_dbi_connect_info([@args, keys %attrs ? \%attrs : ()]); $self->_connect_info; } +sub _default_dbi_connect_attributes { + return { AutoCommit => 1 }; +} + =head2 on_connect_do This method is deprecated in favour of setting via L. @@ -589,7 +601,7 @@ sub txn_do { my $exception = $@; if(!$exception) { return $want_array ? @result : $result[0] } - if($tried++ > 0 || $self->connected) { + if($tried++ || $self->connected) { eval { $self->txn_rollback }; my $rollback_exception = $@; if($rollback_exception) { @@ -621,7 +633,7 @@ database is not in C mode. sub disconnect { my ($self) = @_; - if( $self->connected ) { + if( $self->_dbh ) { my @actions; push @actions, ( $self->on_disconnect_call || () ); @@ -629,7 +641,8 @@ sub disconnect { $self->_do_connection_actions(disconnect_call_ => $_) for @actions; - $self->_dbh->rollback unless $self->_dbh_autocommit; + $self->_dbh_rollback unless $self->_dbh_autocommit; + $self->_dbh->disconnect; $self->_dbh(undef); $self->{_dbh_gen}++; @@ -658,6 +671,22 @@ sub with_deferred_fk_checks { $sub->(); } +=head2 connected + +=over + +=item Arguments: none + +=item Return Value: 1|0 + +=back + +Verifies that the the current database handle is active and ready to execute +an SQL statement (i.e. the connection did not get stale, server is still +answering, etc.) This method is used internally by L. + +=cut + sub connected { my ($self) = @_; @@ -709,21 +738,48 @@ sub ensure_connected { =head2 dbh -Returns the dbh - a data base handle of class L. +Returns a C<$dbh> - a data base handle of class L. The returned handle +is guaranteed to be healthy by implicitly calling L, and if +necessary performing a reconnection before returning. =cut sub dbh { my ($self) = @_; - $self->ensure_connected; + if (not $self->_dbh) { + $self->_populate_dbh; + } else { + $self->ensure_connected; + } + return $self->_dbh; +} + +=head2 last_dbh + +This returns the B available C<$dbh> if any, or attempts to +connect and returns the resulting handle. This method differs from +L by not validating if a preexisting handle is still healthy +via L. Make sure you take appropriate precautions +when using this method, as the C<$dbh> may be useless at this point. + +=cut + +sub last_dbh { + my $self = shift; + $self->_populate_dbh unless $self->_dbh; return $self->_dbh; } sub _sql_maker_args { my ($self) = @_; - return ( bindtype=>'columns', array_datatypes => 1, limit_dialect => $self->dbh, %{$self->_sql_maker_opts} ); + return ( + bindtype=>'columns', + array_datatypes => 1, + limit_dialect => $self->last_dbh, + %{$self->_sql_maker_opts} + ); } sub sql_maker { @@ -740,6 +796,7 @@ sub _rebless {} sub _populate_dbh { my ($self) = @_; + my @info = @{$self->_dbi_connect_info || []}; $self->_dbh($self->_connect(@info)); @@ -752,6 +809,11 @@ sub _populate_dbh { # there is no transaction in progress by definition $self->{transaction_depth} = $self->_dbh_autocommit ? 0 : 1; + $self->_run_connection_actions unless $self->{_in_determine_driver}; +} + +sub _run_connection_actions { + my $self = shift; my @actions; push @actions, ( $self->on_connect_call || () ); @@ -764,15 +826,18 @@ sub _determine_driver { my ($self) = @_; if (not $self->_driver_determined) { + my $started_unconnected = 0; + local $self->{_in_determine_driver} = 1; + if (ref($self) eq __PACKAGE__) { my $driver; - if ($self->_dbh) { # we are connected $driver = $self->_dbh->{Driver}{Name}; } else { # try to use dsn to not require being connected, the driver may still # force a connection in _rebless to determine version ($driver) = $self->_dbi_connect_info->[0] =~ /dbi:([^:]+):/i; + $started_unconnected = 1; } my $storage_class = "DBIx::Class::Storage::DBI::${driver}"; @@ -784,6 +849,9 @@ sub _determine_driver { } $self->_driver_determined(1); + + $self->_run_connection_actions + if $started_unconnected && defined $self->_dbh; } } @@ -983,27 +1051,34 @@ sub _svp_generate_name { sub txn_begin { my $self = shift; - $self->ensure_connected(); if($self->{transaction_depth} == 0) { $self->debugobj->txn_begin() if $self->debug; - # this isn't ->_dbh-> because - # we should reconnect on begin_work - # for AutoCommit users - $self->dbh->begin_work; - } elsif ($self->auto_savepoint) { + $self->_dbh_begin_work; + } + elsif ($self->auto_savepoint) { $self->svp_begin; } $self->{transaction_depth}++; } +sub _dbh_begin_work { + my $self = shift; + # being here implies we have AutoCommit => 1 + # if the user is utilizing txn_do - good for + # him, otherwise we need to ensure that the + # $dbh is healthy on BEGIN + my $dbh_method = $self->{_in_dbh_do} ? '_dbh' : 'dbh'; + $self->$dbh_method->begin_work; +} + sub txn_commit { my $self = shift; if ($self->{transaction_depth} == 1) { my $dbh = $self->_dbh; $self->debugobj->txn_commit() if ($self->debug); - $dbh->commit; + $self->_dbh_commit; $self->{transaction_depth} = 0 if $self->_dbh_autocommit; } @@ -1014,6 +1089,11 @@ sub txn_commit { } } +sub _dbh_commit { + my $self = shift; + $self->_dbh->commit; +} + sub txn_rollback { my $self = shift; my $dbh = $self->_dbh; @@ -1023,7 +1103,7 @@ sub txn_rollback { if ($self->debug); $self->{transaction_depth} = 0 if $self->_dbh_autocommit; - $dbh->rollback; + $self->_dbh_rollback; } elsif($self->{transaction_depth} > 1) { $self->{transaction_depth}--; @@ -1046,6 +1126,11 @@ sub txn_rollback { } } +sub _dbh_rollback { + my $self = shift; + $self->_dbh->rollback; +} + # This used to be the top-half of _execute. It was split out to make it # easier to override in NoBindVars without duping the rest. It takes up # all of _execute's args, and emits $sql, @bind. @@ -1162,7 +1247,11 @@ sub insert { my $col_info = $source->column_info($col); if ( $col_info->{auto_nextval} ) { - $updated_cols->{$col} = $to_insert->{$col} = $self->_sequence_fetch( 'nextval', $col_info->{sequence} || $self->_dbh_get_autoinc_seq($self->dbh, $source) ); + $updated_cols->{$col} = $to_insert->{$col} = $self->_sequence_fetch( + 'nextval', + $col_info->{sequence} || + $self->_dbh_get_autoinc_seq($self->last_dbh, $source) + ); } } } @@ -1183,6 +1272,8 @@ sub insert_bulk { @colvalues{@$cols} = (0..$#$cols); my ($sql, @bind) = $self->sql_maker->insert($table, \%colvalues); + $self->_determine_driver; + $self->_query_start( $sql, @bind ); my $sth = $self->sth($sql); @@ -1242,6 +1333,7 @@ sub insert_bulk { sub update { my $self = shift @_; my $source = shift @_; + $self->_determine_driver; my $bind_attributes = $self->source_bind_attributes($source); return $self->_execute('update' => [], $source, $bind_attributes, @_); @@ -1251,7 +1343,7 @@ sub update { sub delete { my $self = shift @_; my $source = shift @_; - + $self->_determine_driver; my $bind_attrs = $self->source_bind_attributes($source); return $self->_execute('delete' => [], $source, $bind_attrs, @_); @@ -1708,7 +1800,7 @@ sub _resolve_ident_sources { # also note: this adds -result_source => $rsrc to the column info # # usage: -# my $col_sources = $self->_resolve_column_info($ident, [map $_->[0], @{$bind}]); +# my $col_sources = $self->_resolve_column_info($ident, @column_names); sub _resolve_column_info { my ($self, $ident, $colnames) = @_; my ($alias2src, $root_alias) = $self->_resolve_ident_sources($ident); @@ -1716,29 +1808,39 @@ sub _resolve_column_info { my $sep = $self->_sql_maker_opts->{name_sep} || '.'; $sep = "\Q$sep\E"; - my (%return, %converted); + my (%return, %seen_cols); - if (not $colnames) { - $colnames = [ map { - my $alias = $_; - my $source = $alias2src->{$alias}; - map "${alias}${sep}$_", $source->columns - } keys %$alias2src ]; - -# also add unqualified columns for 'me' table - push @$colnames, $alias2src->{$root_alias}->columns; + # compile a global list of column names, to be able to properly + # disambiguate unqualified column names (if at all possible) + for my $alias (keys %$alias2src) { + my $rsrc = $alias2src->{$alias}; + for my $colname ($rsrc->columns) { + push @{$seen_cols{$colname}}, $alias; + } } + COLUMN: foreach my $col (@$colnames) { my ($alias, $colname) = $col =~ m/^ (?: ([^$sep]+) $sep)? (.+) $/x; - # deal with unqualified cols - we assume the main alias for all - # unqualified ones, ugly but can't think of anything better right now - $alias ||= $root_alias; + unless ($alias) { + # see if the column was seen exactly once (so we know which rsrc it came from) + if ($seen_cols{$colname} and @{$seen_cols{$colname}} == 1) { + $alias = $seen_cols{$colname}[0]; + } + else { + next COLUMN; + } + } my $rsrc = $alias2src->{$alias}; - $return{$col} = $rsrc && { %{$rsrc->column_info($colname)}, -result_source => $rsrc }; + $return{$col} = $rsrc && { + %{$rsrc->column_info($colname)}, + -result_source => $rsrc, + -source_alias => $alias, + }; } + return \%return; } @@ -1766,6 +1868,21 @@ sub _subq_count_select { return @pcols ? \@pcols : [ 1 ]; } +# +# Returns an ordered list of column names before they are used +# in a SELECT statement. By default simply returns the list +# passed in. +# +# This may be overridden in a specific storage when there are +# requirements such as moving BLOB columns to the end of the +# SELECT list. +sub _order_select_columns { + #my ($self, $source, $columns) = @_; + return @{$_[2]}; +} + + + sub source_bind_attributes { my ($self, $source) = @_; @@ -1938,7 +2055,7 @@ Returns the database driver name. =cut -sub sqlt_type { shift->dbh->{Driver}->{Name} } +sub sqlt_type { shift->last_dbh->{Driver}->{Name} } =head2 bind_attribute_by_data_type @@ -2185,7 +2302,7 @@ See L for a list of values for C<$sqlt_args>. sub deployment_statements { my ($self, $schema, $type, $version, $dir, $sqltargs) = @_; # Need to be connected to get the correct sqlt_type - $self->ensure_connected() unless $type; + $self->last_dbh() unless $type; $type ||= $self->sqlt_type; $version ||= $schema->schema_version || '1.x'; $dir ||= './'; @@ -2230,7 +2347,10 @@ sub deploy { return if $line =~ /^\s+$/; # skip whitespace only $self->_query_start($line); eval { - $self->dbh->do($line); # shouldn't be using ->dbh ? + # a previous error may invalidate $dbh - thus we need to use dbh() + # to guarantee a healthy $dbh (this is temporary until we get + # proper error handling on deploy() ) + $self->dbh->do($line); }; if ($@) { carp qq{$@ (running "${line}")}; @@ -2259,7 +2379,7 @@ Returns the datetime parser class sub datetime_parser { my $self = shift; return $self->{datetime_parser} ||= do { - $self->ensure_connected; + $self->last_dbh; $self->build_datetime_parser(@_); }; } @@ -2343,7 +2463,7 @@ sub DESTROY { DBIx::Class can do some wonderful magic with handling exceptions, disconnections, and transactions when you use C<< AutoCommit => 1 >> -combined with C for transaction support. +(the default) combined with C for transaction support. If you set C<< AutoCommit => 0 >> in your connect info, then you are always in an assumed transaction between commits, and you're telling us you'd @@ -2355,7 +2475,6 @@ cases if you choose the C<< AutoCommit => 0 >> path, just as you would be with raw DBI. - =head1 AUTHORS Matt S. Trout