WriteLOBs storage component and 2 implementations

Factor out the LOB Writing code through an API from ::Sybase::ASE into a
generic component, ::Storage::DBI::WriteLOBs which requires the
composing class to implement just two methods, _write_lobs and _empty_lob
and implements insert, update and insert_bulk as well as a bunch of low
level methods (which are private.) These methods are documented in the
component as top comments.

::DBI::Oracle::Generic and ::Sybase::ASE implement this component.

The implementation is stackable, so that a composing class override of
LOB handling using the low level methods will not conflict with the
inherited methods, however for performance reasons a flag has been
added:

    local $self->{_skip_writelobs_impl} = 1;

to shortcircuit the implementation even faster. This flag is not
documented and will be replaced using the capability system in the
future, it is used in the ASE implementation of insert_bulk because of
the special identities handling it requires.

This refactor addresses a number of issues:

 - rows can now be identified by unique constraints, not just PKs for
   LOB ops

 - ASE UPDATEs with LIKE queries on TEXT columns in the WHERE condition
   now work

 - LOB ops now work in Oracle with quoting turned on

 - LOB ops work in Oracle with DBD::Oracle 1.23

 - insert_bulk now works with LOBs for Oracle, as long as the slices can
   be uniquely identified

Author: rkitover

Changes

@@ -1,5 +1,14 @@
 Revision history for DBIx::Class
 
+        - Loosen primary key requirement restriction on TEXT/IMAGE operations
+          for Sybase ASE to unique constraints
+        - Support TEXT/IMAGE UPDATE operations with TEXT queries in WHERE for
+          Sybase ASE
+        - Support BLOB/CLOB operations for Oracle with quoting enabled (by
+          switching to ora_auto_lob => 0)
+        - Support BLOB/CLOB operations for Oracle on DBD::Oracle version 1.23
+        - Support insert_bulk with BLOBs/CLOBs for Oracle
+
 0.08200 2012-08-24 (UTC)
     * Fixes
         - Change one of the new tests for the previous release to not require

lib/DBIx/Class/Storage/DBI.pm

@@ -23,9 +23,11 @@ use namespace::clean;
 __PACKAGE__->cursor_class('DBIx::Class::Storage::DBI::Cursor');
 
 __PACKAGE__->mk_group_accessors('inherited' => qw/
-  sql_limit_dialect sql_quote_char sql_name_sep
+  sql_limit_dialect sql_quote_char sql_name_sep _prepare_attributes
 /);
 
+__PACKAGE__->_prepare_attributes({}); # see _dbh_sth
+
 __PACKAGE__->mk_group_accessors('component_class' => qw/sql_maker_class datetime_parser_type/);
 
 __PACKAGE__->sql_maker_class('DBIx::Class::SQLMaker');
@@ -2304,8 +2306,8 @@ sub _dbh_sth {
 
   # 3 is the if_active parameter which avoids active sth re-use
   my $sth = $self->disable_sth_caching
-    ? $dbh->prepare($sql)
-    : $dbh->prepare_cached($sql, {}, 3);
+    ? $dbh->prepare($sql, $self->_prepare_attributes)
+    : $dbh->prepare_cached($sql, $self->_prepare_attributes, 3);
 
   # XXX You would think RaiseError would make this impossible,
   #  but apparently that's not true :(

lib/DBIx/Class/Storage/DBI/Oracle/Generic.pm

@@ -2,7 +2,7 @@ package DBIx::Class::Storage::DBI::Oracle::Generic;
 
 use strict;
 use warnings;
-use base qw/DBIx::Class::Storage::DBI/;
+use base qw/DBIx::Class::Storage::DBI::WriteLOBs/;
 use mro 'c3';
 use DBIx::Class::Carp;
 use Scope::Guard ();
@@ -456,6 +456,37 @@ sub bind_attribute_by_data_type {
   }
 }
 
+sub _empty_lob {
+  my ($self, $source, $col) = @_;
+
+  return $self->_is_text_lob_type($source->column_info($col)->{data_type}) ?
+    \'EMPTY_CLOB()' : \'EMPTY_BLOB()';
+}
+
+sub _write_lobs {
+  my ($self, $source, $lobs, $where) = @_;
+
+  my @lobs = keys %$lobs;
+
+  local $self->_prepare_attributes->{ora_auto_lob} = 0;
+
+  my $cursor = $self->select($source, \@lobs, $where, { for => 'update' });
+
+  my $dbh = $self->_get_dbh;
+
+  while (my @locators = $cursor->next) {
+    my %lobs;
+    @lobs{@lobs} = @locators;
+
+    foreach my $lob (@lobs) {
+      my $data = \$lobs->{$lob};
+
+      $dbh->ora_lob_trim($lobs{$lob}, 0);
+      $dbh->ora_lob_write($lobs{$lob}, 1, $$data);
+    }
+  }
+}
+
 # Handle blob columns in WHERE.
 #
 # For equality comparisons: