X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FDBIx%2FClass%2FStorage%2FDBI.pm;h=9fbcc97aae5773eb68475e8339e1bf0a98336102;hb=c9c9297bde6db8d9bc299bbbf12d3480943257cd;hp=e4e67284bf9855ab51a24cd22ec8820b75ff2baf;hpb=c080561b566a9d8764ef64b3b7d61c130139d9b9;p=dbsrgits%2FDBIx-Class.git diff --git a/lib/DBIx/Class/Storage/DBI.pm b/lib/DBIx/Class/Storage/DBI.pm index e4e6728..9fbcc97 100644 --- a/lib/DBIx/Class/Storage/DBI.pm +++ b/lib/DBIx/Class/Storage/DBI.pm @@ -13,6 +13,12 @@ use DBIx::Class::Storage::DBI::Cursor; use DBIx::Class::Storage::Statistics; use Scalar::Util(); use List::Util(); +use Data::Dumper::Concise(); + +# what version of sqlt do we require if deploy() without a ddl_dir is invoked +# when changing also adjust the corresponding author_require in Makefile.PL +my $minimum_sqlt_version = '0.11002'; + __PACKAGE__->mk_group_accessors('simple' => qw/_connect_info _dbi_connect_info _dbh _sql_maker _sql_maker_opts _conn_pid @@ -35,6 +41,38 @@ __PACKAGE__->mk_group_accessors('inherited' => qw/sql_maker_class/); __PACKAGE__->sql_maker_class('DBIx::Class::SQLAHacks'); +# Each of these methods need _determine_driver called before itself +# in order to function reliably. This is a purely DRY optimization +my @rdbms_specific_methods = qw/ + sqlt_type + build_datetime_parser + datetime_parser_type + + insert + insert_bulk + update + delete + select + select_single +/; + +for my $meth (@rdbms_specific_methods) { + + my $orig = __PACKAGE__->can ($meth) + or next; + + no strict qw/refs/; + no warnings qw/redefine/; + *{__PACKAGE__ ."::$meth"} = sub { + if (not $_[0]->_driver_determined) { + $_[0]->_determine_driver; + goto $_[0]->can($meth); + } + $orig->(@_); + }; +} + + =head1 NAME DBIx::Class::Storage::DBI - DBI storage handler @@ -707,7 +745,6 @@ in MySQL's case disabled entirely. # Storage subclasses should override this sub with_deferred_fk_checks { my ($self, $sub) = @_; - $sub->(); } @@ -873,13 +910,14 @@ sub _determine_driver { my ($self) = @_; if ((not $self->_driver_determined) && (not $self->{_in_determine_driver})) { - my $started_unconnected = 0; + my $started_connected = 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}; + $started_connected = 1; } else { # if connect_info is a CODEREF, we have no choice but to connect if (ref $self->_dbi_connect_info->[0] && @@ -891,7 +929,6 @@ sub _determine_driver { # 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; } } @@ -908,7 +945,7 @@ sub _determine_driver { $self->_init; # run driver-specific initializations $self->_run_connection_actions - if $started_unconnected && defined $self->_dbh; + if !$started_connected && defined $self->_dbh; } } @@ -1002,6 +1039,8 @@ sub _connect { $weak_self->throw_exception("DBI Exception: $_[0]"); } else { + # the handler may be invoked by something totally out of + # the scope of DBIC croak ("DBI Exception: $_[0]"); } }; @@ -1137,7 +1176,6 @@ sub _dbh_begin_work { sub txn_commit { my $self = shift; if ($self->{transaction_depth} == 1) { - my $dbh = $self->_dbh; $self->debugobj->txn_commit() if ($self->debug); $self->_dbh_commit; @@ -1153,7 +1191,9 @@ sub txn_commit { sub _dbh_commit { my $self = shift; - $self->_dbh->commit; + my $dbh = $self->_dbh + or $self->throw_exception('cannot COMMIT on a disconnected handle'); + $dbh->commit; } sub txn_rollback { @@ -1190,7 +1230,9 @@ sub txn_rollback { sub _dbh_rollback { my $self = shift; - $self->_dbh->rollback; + my $dbh = $self->_dbh + or $self->throw_exception('cannot ROLLBACK on a disconnected handle'); + $dbh->rollback; } # This used to be the top-half of _execute. It was split out to make it @@ -1293,12 +1335,6 @@ sub _execute { sub insert { my ($self, $source, $to_insert) = @_; -# redispatch to insert method of storage we reblessed into, if necessary - if (not $self->_driver_determined) { - $self->_determine_driver; - goto $self->can('insert'); - } - my $ident = $source->from; my $bind_attributes = $self->source_bind_attributes($source); @@ -1328,24 +1364,104 @@ sub insert { ## scalar refs, or at least, all the same type as the first set, the statement is ## only prepped once. sub insert_bulk { - my ($self, $source, $cols, $data, $sth_attr) = @_; - -# redispatch to insert_bulk method of storage we reblessed into, if necessary - if (not $self->_driver_determined) { - $self->_determine_driver; - goto $self->can('insert_bulk'); - } + my ($self, $source, $cols, $data) = @_; my %colvalues; - my $table = $source->from; @colvalues{@$cols} = (0..$#$cols); -# XXX some bulk APIs require column list in database order - my ($sql, @bind) = $self->sql_maker->insert($table, \%colvalues); - $self->_query_start( $sql, @bind ); - my $sth = $self->sth($sql, 'insert', $sth_attr); + for my $i (0..$#$cols) { + my $first_val = $data->[0][$i]; + next unless ref $first_val eq 'SCALAR'; + + $colvalues{ $cols->[$i] } = $first_val; + } + + # check for bad data and stringify stringifiable objects + my $bad_slice = sub { + my ($msg, $col_idx, $slice_idx) = @_; + $self->throw_exception(sprintf "%s for column '%s' in populate slice:\n%s", + $msg, + $cols->[$col_idx], + do { + local $Data::Dumper::Maxdepth = 1; # don't dump objects, if any + Data::Dumper::Concise::Dumper({ + map { $cols->[$_] => $data->[$slice_idx][$_] } (0 .. $#$cols) + }), + } + ); + }; + + for my $datum_idx (0..$#$data) { + my $datum = $data->[$datum_idx]; + + for my $col_idx (0..$#$cols) { + my $val = $datum->[$col_idx]; + my $sqla_bind = $colvalues{ $cols->[$col_idx] }; + my $is_literal_sql = (ref $sqla_bind) eq 'SCALAR'; + + if ($is_literal_sql) { + if (not ref $val) { + $bad_slice->('bind found where literal SQL expected', $col_idx, $datum_idx); + } + elsif ((my $reftype = ref $val) ne 'SCALAR') { + $bad_slice->("$reftype reference found where literal SQL expected", + $col_idx, $datum_idx); + } + elsif ($$val ne $$sqla_bind){ + $bad_slice->("inconsistent literal SQL value, expecting: '$$sqla_bind'", + $col_idx, $datum_idx); + } + } + elsif (my $reftype = ref $val) { + require overload; + if (overload::Method($val, '""')) { + $datum->[$col_idx] = "".$val; + } + else { + $bad_slice->("$reftype reference found where bind expected", + $col_idx, $datum_idx); + } + } + } + } + + my ($sql, $bind) = $self->_prep_for_execute ( + 'insert', undef, $source, [\%colvalues] + ); + my @bind = @$bind; -# @bind = map { ref $_ ? ''.$_ : $_ } @bind; # stringify args + my $empty_bind = 1 if (not @bind) && + (grep { ref $_ eq 'SCALAR' } values %colvalues) == @$cols; + + if ((not @bind) && (not $empty_bind)) { + $self->throw_exception( + 'Cannot insert_bulk without support for placeholders' + ); + } + + $self->_query_start( $sql, ['__BULK__'] ); + my $sth = $self->sth($sql); + + my $rv = do { + if ($empty_bind) { + # bind_param_array doesn't work if there are no binds + $self->_dbh_execute_inserts_with_no_binds( $sth, scalar @$data ); + } + else { +# @bind = map { ref $_ ? ''.$_ : $_ } @bind; # stringify args + $self->_execute_array( $source, $sth, \@bind, $cols, $data ); + } + }; + + $self->_query_end( $sql, ['__BULK__'] ); + + return (wantarray ? ($rv, $sth, @bind) : $rv); +} + +sub _execute_array { + my ($self, $source, $sth, $bind, $cols, $data, @extra) = @_; + + my $guard = $self->txn_scope_guard unless $self->{transaction_depth} != 0; ## This must be an arrayref, else nothing works! my $tuple_status = []; @@ -1356,7 +1472,7 @@ sub insert_bulk { ## Bind the values and execute my $placeholder_index = 1; - foreach my $bound (@bind) { + foreach my $bound (@$bind) { my $attributes = {}; my ($column_name, $data_index) = @$bound; @@ -1371,45 +1487,70 @@ sub insert_bulk { $sth->bind_param_array( $placeholder_index, [@data], $attributes ); $placeholder_index++; } - my $rv = eval { $sth->execute_array({ArrayTupleStatus => $tuple_status}) }; - if (my $err = $@ || $sth->errstr) { + + my $rv = eval { + $self->_dbh_execute_array($sth, $tuple_status, @extra); + }; + my $err = $@ || $sth->errstr; + +# Statement must finish even if there was an exception. + eval { $sth->finish }; + $err = $@ unless $err; + + if ($err) { my $i = 0; ++$i while $i <= $#$tuple_status && !ref $tuple_status->[$i]; - $self->throw_exception($sth->errstr || "Unexpected populate error: $err") + $self->throw_exception("Unexpected populate error: $err") if ($i > $#$tuple_status); - require Data::Dumper; - local $Data::Dumper::Terse = 1; - local $Data::Dumper::Indent = 1; - local $Data::Dumper::Useqq = 1; - local $Data::Dumper::Quotekeys = 0; - local $Data::Dumper::Sortkeys = 1; - $self->throw_exception(sprintf "%s for populate slice:\n%s", - $tuple_status->[$i][1], - Data::Dumper::Dumper( - { map { $cols->[$_] => $data->[$i][$_] } (0 .. $#$cols) } - ), + ($tuple_status->[$i][1] || $err), + Data::Dumper::Concise::Dumper({ + map { $cols->[$_] => $data->[$i][$_] } (0 .. $#$cols) + }), ); } - $self->throw_exception($sth->errstr) if !$rv; - $sth->finish; + $guard->commit if $guard; - $self->_query_end( $sql, @bind ); - return (wantarray ? ($rv, $sth, @bind) : $rv); + return $rv; +} + +sub _dbh_execute_array { + my ($self, $sth, $tuple_status, @extra) = @_; + + return $sth->execute_array({ArrayTupleStatus => $tuple_status}); +} + +sub _dbh_execute_inserts_with_no_binds { + my ($self, $sth, $count) = @_; + + my $guard = $self->txn_scope_guard unless $self->{transaction_depth} != 0; + + eval { + my $dbh = $self->_get_dbh; + local $dbh->{RaiseError} = 1; + local $dbh->{PrintError} = 0; + + $sth->execute foreach 1..$count; + }; + my $exception = $@; + +# Make sure statement is finished even if there was an exception. + eval { $sth->finish }; + $exception = $@ unless $exception; + + $self->throw_exception($exception) if $exception; + + $guard->commit if $guard; + + return $count; } sub update { my ($self, $source, @args) = @_; -# redispatch to update method of storage we reblessed into, if necessary - if (not $self->_driver_determined) { - $self->_determine_driver; - goto $self->can('update'); - } - my $bind_attributes = $self->source_bind_attributes($source); return $self->_execute('update' => [], $source, $bind_attributes, @args); @@ -1417,12 +1558,11 @@ sub update { sub delete { - my $self = shift @_; - my $source = shift @_; - $self->_determine_driver; + my ($self, $source, @args) = @_; + my $bind_attrs = $self->source_bind_attributes($source); - return $self->_execute('delete' => [], $source, $bind_attrs, @_); + return $self->_execute('delete' => [], $source, $bind_attrs, @args); } # We were sent here because the $rs contains a complex search @@ -1989,19 +2129,6 @@ 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) = @_; @@ -2060,15 +2187,12 @@ Returns a L sth (statement handle) for the supplied SQL. =cut sub _dbh_sth { - my ($self, $dbh, $sql, $op, $sth_attr) = @_; -# $op is ignored right now - - $sth_attr ||= {}; + my ($self, $dbh, $sql) = @_; # 3 is the if_active parameter which avoids active sth re-use my $sth = $self->disable_sth_caching - ? $dbh->prepare($sql, $sth_attr) - : $dbh->prepare_cached($sql, $sth_attr, 3); + ? $dbh->prepare($sql) + : $dbh->prepare_cached($sql, {}, 3); # XXX You would think RaiseError would make this impossible, # but apparently that's not true :( @@ -2078,8 +2202,8 @@ sub _dbh_sth { } sub sth { - my ($self, $sql, @args) = @_; - $self->dbh_do('_dbh_sth', $sql, @args); # retry over disconnects + my ($self, $sql) = @_; + $self->dbh_do('_dbh_sth', $sql); # retry over disconnects } sub _dbh_columns_info_for { @@ -2238,14 +2362,7 @@ Returns the database driver name. =cut sub sqlt_type { - my ($self) = @_; - - if (not $self->_driver_determined) { - $self->_determine_driver; - goto $self->can ('sqlt_type'); - } - - $self->_get_dbh->{Driver}->{Name}; + shift->_get_dbh->{Driver}->{Name}; } =head2 bind_attribute_by_data_type @@ -2519,7 +2636,11 @@ sub deployment_statements { parser => 'SQL::Translator::Parser::DBIx::Class', data => $schema, ); - return $tr->translate; + + my $ret = $tr->translate + or $self->throw_exception( 'Unable to produce deployment statements: ' . $tr->error); + + return $ret; } sub deploy { @@ -2585,11 +2706,6 @@ See L =cut sub build_datetime_parser { - if (not $_[0]->_driver_determined) { - $_[0]->_determine_driver; - goto $_[0]->can('build_datetime_parser'); - } - my $self = shift; my $type = $self->datetime_parser_type(@_); $self->ensure_class_loaded ($type); @@ -2622,6 +2738,33 @@ sub lag_behind_master { return; } +# SQLT version handling +{ + my $_sqlt_version_ok; # private + my $_sqlt_version_error; # private + + sub _sqlt_version_ok { + if (!defined $_sqlt_version_ok) { + eval "use SQL::Translator $minimum_sqlt_version"; + if ($@) { + $_sqlt_version_ok = 0; + $_sqlt_version_error = $@; + } + else { + $_sqlt_version_ok = 1; + } + } + return $_sqlt_version_ok; + } + + sub _sqlt_version_error { + shift->_sqlt_version_ok unless defined $_sqlt_version_ok; + return $_sqlt_version_error; + } + + sub _sqlt_minimum_version { $minimum_sqlt_version }; +} + sub DESTROY { my $self = shift;