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 ($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] &&
# 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;
}
}
$self->_init; # run driver-specific initializations
$self->_run_connection_actions
- if $started_unconnected && defined $self->_dbh;
+ if !$started_connected && defined $self->_dbh;
}
}
## 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) = @_;
+ my ($self, $source, $cols, $data) = @_;
# redispatch to insert_bulk method of storage we reblessed into, if necessary
if (not $self->_driver_determined) {
# pass scalarref to SQLA for literal sql if it's the same in all slices
for my $i (0..$#$cols) {
my $first_val = $data->[0][$i];
- next unless (Scalar::Util::reftype($first_val)||'') eq 'SCALAR';
+ next unless ref $first_val eq 'SCALAR';
$colvalues{ $cols->[$i] } = $first_val
if (grep {
- (Scalar::Util::reftype($_)||'') eq 'SCALAR' &&
- $$_ eq $$first_val
+ ref $_ eq 'SCALAR' && $$_ eq $$first_val
} map $data->[$_][$i], (1..$#$data)) == (@$data - 1);
}
my @bind = @$bind;
my $empty_bind = 1 if (not @bind) &&
- (grep { (Scalar::Util::reftype($_)||'') eq 'SCALAR' } values %colvalues)
- == @$cols;
+ (grep { ref $_ eq 'SCALAR' } values %colvalues) == @$cols;
if ((not @bind) && (not $empty_bind)) {
- croak 'Cannot insert_bulk without support for placeholders';
+ $self->throw_exception(
+ 'Cannot insert_bulk without support for placeholders'
+ );
}
$self->_query_start( $sql, @bind );
- my $sth = $self->sth($sql, 'insert', $sth_attr);
+ my $sth = $self->sth($sql);
my $rv = do {
if ($empty_bind) {
}
sub _execute_array {
- my ($self, $source, $sth, $bind, $cols, $data, $guard) = @_;
+ 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 = [];
$placeholder_index++;
}
- my $rv = eval { $sth->execute_array({ArrayTupleStatus => $tuple_status}) };
-
- $guard->commit if $guard; # probably only needed for Sybase
+ my $rv = eval {
+ $self->_dbh_execute_array($sth, $tuple_status, @extra);
+ };
+ my $err = $@ || $sth->errstr;
- $sth->finish;
+# Statement must finish even if there was an exception.
+ eval { $sth->finish };
+ $err = $@ unless $err;
- if (my $err = $@ || $sth->errstr) {
+ if ($err) {
my $i = 0;
++$i while $i <= $#$tuple_status && !ref $tuple_status->[$i];
$self->throw_exception(sprintf "%s for populate slice:\n%s",
($tuple_status->[$i][1] || $err),
- $self->_pretty_print ({
+ Data::Dumper::Concise::Dumper({
map { $cols->[$_] => $data->[$i][$_] } (0 .. $#$cols)
}),
);
}
+ $guard->commit if $guard;
+
return $rv;
}
+sub _dbh_execute_array {
+ my ($self, $sth, $tuple_status, @extra) = @_;
+
+ return $sth->execute_array({ArrayTupleStatus => $tuple_status});
+}
+
sub _execute_array_empty {
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;
- foreach (1..$count) {
- $sth->execute;
-# In case of a multi-statement with a select, some DBDs (namely Sybase) require
-# the cursor to be exhausted.
- $sth->fetchall_arrayref;
- }
+
+ $sth->execute foreach 1..$count;
};
my $exception = $@;
- $sth->finish;
+
+# 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;
}
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) = @_;
=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 :(
}
sub sth {
- my ($self, $sql, $op, $sth_attr) = @_;
- $self->dbh_do('_dbh_sth', $sql, $op, $sth_attr); # retry over disconnects
+ my ($self, $sql) = @_;
+ $self->dbh_do('_dbh_sth', $sql); # retry over disconnects
}
sub _dbh_columns_info_for {