stringify values passed to populate/insert_bulk
[dbsrgits/DBIx-Class.git] / lib / DBIx / Class / Storage / DBI.pm
index f1cb9c0..44fe102 100644 (file)
@@ -13,6 +13,7 @@ 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
@@ -878,13 +879,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] &&
@@ -896,7 +898,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;
         }
       }
 
@@ -913,7 +914,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;
   }
 }
 
@@ -1346,15 +1347,60 @@ sub insert_bulk {
   my %colvalues;
   @colvalues{@$cols} = (0..$#$cols);
 
-  # 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 ref $first_val eq 'SCALAR';
 
-    $colvalues{ $cols->[$i] } = $first_val
-      if (grep {
-        ref $_ eq 'SCALAR' && $$_ eq $$first_val
-      } map $data->[$_][$i], (1..$#$data)) == (@$data - 1);
+    $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 (
@@ -1371,13 +1417,13 @@ sub insert_bulk {
     );
   }
 
-  $self->_query_start( $sql, @bind );
+  $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->_execute_array_empty( $sth, scalar @$data );
+      $self->_dbh_execute_inserts_with_no_binds( $sth, scalar @$data );
     }
     else {
 #      @bind = map { ref $_ ? ''.$_ : $_ } @bind; # stringify args
@@ -1385,13 +1431,13 @@ sub insert_bulk {
     }
   };
 
-  $self->_query_end( $sql, @bind );
+  $self->_query_end( $sql, ['__BULK__'] );
 
   return (wantarray ? ($rv, $sth, @bind) : $rv);
 }
 
 sub _execute_array {
-  my ($self, $source, $sth, $bind, $cols, $data, $after_exec_cb) = @_;
+  my ($self, $source, $sth, $bind, $cols, $data, @extra) = @_;
 
   my $guard = $self->txn_scope_guard unless $self->{transaction_depth} != 0;
 
@@ -1420,10 +1466,8 @@ sub _execute_array {
     $placeholder_index++;
   }
 
-  my $rv;
-  eval {
-    $rv = $sth->execute_array({ArrayTupleStatus => $tuple_status});
-    $after_exec_cb->() if $after_exec_cb;
+  my $rv = eval {
+    $self->_dbh_execute_array($sth, $tuple_status, @extra);
   };
   my $err = $@ || $sth->errstr;
 
@@ -1440,7 +1484,7 @@ sub _execute_array {
 
     $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)
       }),
     );
@@ -1451,7 +1495,13 @@ sub _execute_array {
   return $rv;
 }
 
-sub _execute_array_empty {
+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;
@@ -1461,17 +1511,7 @@ sub _execute_array_empty {
     local $dbh->{RaiseError} = 1;
     local $dbh->{PrintError} = 0;
 
-# In case of a multi-statement with a select, some DBDs (namely Sybase) require
-# the statement to be exhausted.
-    my $fetch = 0;
-    if ($self->_exhaust_statements && $sth->{Statement} =~ /(?:\n|;)select/i) {
-      $fetch = 1;
-    }
-
-    foreach (1..$count) {
-      $sth->execute;
-      $sth->fetchall_arrayref if $fetch;
-    }
+    $sth->execute foreach 1..$count;
   };
   my $exception = $@;
 
@@ -1486,11 +1526,6 @@ sub _execute_array_empty {
   return $count;
 }
 
-# Whether we prefer to exhaust cursors with results, or they can be
-# reused/finished without fetching anything. To be overridden to '1' in storages
-# that need it.
-sub _exhaust_statements { 0 }
-
 sub update {
   my ($self, $source, @args) = @_; 
 
@@ -2696,10 +2731,10 @@ sub lag_behind_master {
     return;
 }
 
-# SQLT version handling 
+# SQLT version handling
 {
-  my $_sqlt_version_ok;     # private 
-  my $_sqlt_version_error;  # private 
+  my $_sqlt_version_ok;     # private
+  my $_sqlt_version_error;  # private
 
   sub _sqlt_version_ok {
     if (!defined $_sqlt_version_ok) {