X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FDBIx%2FClass%2FStorage%2FDBI%2FSybase.pm;h=68c2e20eef6a4c316caedb25b4cd36546b3e2133;hb=51ac7136944f82aa2675cc133a8d080c5fb367b1;hp=e28ee63cf0155997473ec4bc6c4098671f2c9da7;hpb=0ac07712a87c97ec1676410be95ddfef768bfe23;p=dbsrgits%2FDBIx-Class.git

diff --git a/lib/DBIx/Class/Storage/DBI/Sybase.pm b/lib/DBIx/Class/Storage/DBI/Sybase.pm
index e28ee63..68c2e20 100644
--- a/lib/DBIx/Class/Storage/DBI/Sybase.pm
+++ b/lib/DBIx/Class/Storage/DBI/Sybase.pm
@@ -12,7 +12,7 @@ use Carp::Clan qw/^DBIx::Class/;
 use List::Util ();
 
 __PACKAGE__->mk_group_accessors('simple' =>
-    qw/_identity _blob_log_on_update insert_txn/
+    qw/_identity _blob_log_on_update unsafe_insert _insert_dbh/
 );
 
 =head1 NAME
@@ -34,7 +34,8 @@ also enable that driver explicitly, see the documentation for more details.
 With this driver there is unfortunately no way to get the C<last_insert_id>
 without doing a C<SELECT MAX(col)>. This is done safely in a transaction
 (locking the table.) The transaction can be turned off if concurrency is not an
-issue, see L<DBIx::Class::Storage::DBI::Sybase/connect_call_unsafe_insert>.
+issue, or you don't need the C<IDENTITY> value, see
+L<DBIx::Class::Storage::DBI::Sybase/connect_call_unsafe_insert>.
 
 But your queries will be cached.
 
@@ -64,10 +65,6 @@ sub _rebless {
     } else { # real Sybase
       my $no_bind_vars = 'DBIx::Class::Storage::DBI::Sybase::NoBindVars';
 
-# This is reset to 0 in ::NoBindVars, only necessary because we use max(col) to
-# get the identity.
-      $self->insert_txn(1);
-
       if ($self->using_freetds) {
         carp <<'EOF' unless $ENV{DBIC_SYBASE_FREETDS_NOWARN};
 
@@ -99,7 +96,7 @@ EOF
         $self->set_textsize; # based on LongReadLen in connect_info
 
       }
-      elsif (not $self->dbh->{syb_dynamic_supported}) {
+      elsif (not $self->_get_dbh->{syb_dynamic_supported}) {
         # not necessarily FreeTDS, but no placeholders nevertheless
         $self->ensure_class_loaded($no_bind_vars);
         bless $self, $no_bind_vars;
@@ -180,13 +177,13 @@ L<DBIx::Class::Storage::DBI/connect_info>,
 
 To manipulate this setting at runtime, use:
 
-  $schema->storage->insert_txn(0); # 1 to re-enable
+  $schema->storage->unsafe_insert(0|1);
 
 =cut
 
 sub connect_call_unsafe_insert {
   my $self = shift;
-  $self->insert_txn(0);
+  $self->unsafe_insert(1);
 }
 
 sub _is_lob_type {
@@ -261,7 +258,7 @@ sub _native_data_type {
   my ($self, $type) = @_;
 
   $type = lc $type;
-  $type =~ s/ identity//;
+  $type =~ s/\s* identity//x;
 
   return uc($TYPE_MAPPING{$type} || $type);
 }
@@ -288,13 +285,16 @@ sub _execute {
 
 sub last_insert_id { shift->_identity }
 
-# override to handle TEXT/IMAGE and to do a transaction if necessary
+# handles TEXT/IMAGE and transaction for last_insert_id
 sub insert {
   my $self = shift;
-  my ($ident, $source, $to_insert) = @_;
+  my ($source, $to_insert) = @_;
 
   my $blob_cols = $self->_remove_blob_cols($source, $to_insert);
 
+# insert+blob insert done atomically
+  my $guard = $self->txn_scope_guard if $blob_cols;
+
   my $need_last_insert_id = 0;
 
   my ($identity_col) =
@@ -309,31 +309,41 @@ sub insert {
   # We have to do the insert in a transaction to avoid race conditions with the
   # SELECT MAX(COL) identity method used when placeholders are enabled.
   my $updated_cols = do {
-    if ($need_last_insert_id && $self->insert_txn &&
-        (not $self->{transaction_depth})) {
+    if (
+      $need_last_insert_id && !$self->unsafe_insert && !$self->{transaction_depth}
+    ) {
+      $self->_insert_dbh($self->_connect(@{ $self->_dbi_connect_info }))
+        unless $self->_insert_dbh;
+      local $self->{_dbh} = $self->_insert_dbh;
       my $guard = $self->txn_scope_guard;
       my $upd_cols = $self->next::method (@_);
       $guard->commit;
-      return $upd_cols;
+      $self->_insert_dbh($self->_dbh);
+      $upd_cols;
     }
     else {
       $self->next::method(@_);
     }
   };
 
-  $self->_insert_blobs($source, $blob_cols, $to_insert) if %$blob_cols;
+  $self->_insert_blobs($source, $blob_cols, $to_insert) if $blob_cols;
+
+  $guard->commit if $guard;
 
   return $updated_cols;
 }
 
 sub update {
   my $self = shift;
-  my ($source, $fields, $ident_cond) = @_;
+  my ($source, $fields, $where) = @_;
 
   my $wantarray = wantarray;
 
   my $blob_cols = $self->_remove_blob_cols($source, $fields);
 
+# update+blob update(s) done atomically
+  my $guard = $self->txn_scope_guard if $blob_cols;
+
   my @res;
   if ($wantarray) {
     @res    = $self->next::method(@_);
@@ -345,7 +355,9 @@ sub update {
     $self->next::method(@_);
   }
 
-  $self->_update_blobs($source, $blob_cols, $ident_cond) if %$blob_cols;
+  $self->_update_blobs($source, $blob_cols, $where) if $blob_cols;
+
+  $guard->commit if $guard;
 
   return $wantarray ? @res : $res[0];
 }
@@ -362,11 +374,11 @@ sub _remove_blob_cols {
     }
   }
 
-  return \%blob_cols;
+  return keys %blob_cols ? \%blob_cols : undef;
 }
 
 sub _update_blobs {
-  my ($self, $source, $blob_cols, $ident_cond) = @_;
+  my ($self, $source, $blob_cols, $where) = @_;
 
   my (@primary_cols) = $source->primary_columns;
 
@@ -376,17 +388,17 @@ sub _update_blobs {
 # check if we're updating a single row by PK
   my $pk_cols_in_where = 0;
   for my $col (@primary_cols) {
-    $pk_cols_in_where++ if defined $ident_cond->{$col};
+    $pk_cols_in_where++ if defined $where->{$col};
   }
   my @rows;
 
   if ($pk_cols_in_where == @primary_cols) {
     my %row_to_update;
-    @row_to_update{@primary_cols} = @{$ident_cond}{@primary_cols};
+    @row_to_update{@primary_cols} = @{$where}{@primary_cols};
     @rows = \%row_to_update;
   } else {
     my $rs = $source->resultset->search(
-      $ident_cond,
+      $where,
       {
         result_class => 'DBIx::Class::ResultClass::HashRefInflator',
         select => \@primary_cols
@@ -402,7 +414,7 @@ sub _update_blobs {
 
 sub _insert_blobs {
   my ($self, $source, $blob_cols, $row) = @_;
-  my $dbh = $self->dbh;
+  my $dbh = $self->_get_dbh;
 
   my $table = $source->from;
 
@@ -518,7 +530,7 @@ sub _dbh_begin_work {
   my $self = shift;
   $self->next::method(@_);
   if ($self->using_freetds) {
-    $self->dbh->do('BEGIN TRAN');
+    $self->_get_dbh->do('BEGIN TRAN');
   }
 }
 
@@ -543,7 +555,7 @@ sub _dbh_rollback {
 sub _svp_begin {
   my ($self, $name) = @_;
 
-  $self->dbh->do("SAVE TRANSACTION $name");
+  $self->_get_dbh->do("SAVE TRANSACTION $name");
 }
 
 # A new SAVE TRANSACTION with the same name releases the previous one.
@@ -552,7 +564,7 @@ sub _svp_release { 1 }
 sub _svp_rollback {
   my ($self, $name) = @_;
 
-  $self->dbh->do("ROLLBACK TRANSACTION $name");
+  $self->_get_dbh->do("ROLLBACK TRANSACTION $name");
 }
 
 1;
@@ -601,6 +613,31 @@ Open Client libraries.
 
 Inserts or updates of TEXT/IMAGE columns will B<NOT> work with FreeTDS.
 
+=head1 TRANSACTIONS
+
+Due to limitations of the TDS protocol, L<DBD::Sybase>, or both; you cannot
+begin a transaction while there are active cursors. An active cursor is, for
+example, a L<ResultSet|DBIx::Class::ResultSet> that has been executed using
+C<next> or C<first> but has not been exhausted or
+L<reset|DBIx::Class::ResultSet/reset>.
+
+Transactions done for inserts in C<AutoCommit> mode when placeholders are in use
+are not affected, as they use an extra database handle to do the insert.
+
+Some workarounds:
+
+=over 4
+
+=item * use L<DBIx::Class::Storage::DBI::Replicated>
+
+=item * L<connect|DBIx::Class::Schema/connect> another L<Schema|DBIx::Class::Schema>
+
+=item * load the data from your cursor with L<DBIx::Class::ResultSet/all>
+
+=item * enlarge the scope of the transaction
+
+=back
+
 =head1 MAXIMUM CONNECTIONS
 
 The TDS protocol makes separate connections to the server for active statements
@@ -642,7 +679,7 @@ C<SET TEXTSIZE> command on connection.
 See L</connect_call_blob_setup> for a L<DBIx::Class::Storage::DBI/connect_info>
 setting you need to work with C<IMAGE> columns.
 
-=head1 AUTHORS
+=head1 AUTHOR
 
 See L<DBIx::Class/CONTRIBUTORS>.