DBIx::Class::Storage::DBI::Sybase::ASE - Sybase ASE SQL Server support for

  on_connect_call => [['datetime_setup'], ['blob_setup', log_on_update => 0]]

  on_connect_call => [ [ 'blob_setup', log_on_update => 0 ] ]

  on_connect_call => 'datetime_setup'

  $dbh->syb_date_fmt('ISO_strict'); # output fmt: 2004-08-21T14:36:48.080Z
  $dbh->do('set dateformat mdy');   # input fmt:  08/13/1979 18:08:55.080

  perl -MDBI -le 'my $dbh = DBI->connect($dsn, $user, $pass); print $dbh->{syb_oc_version}'

  $schema->txn_do(sub {
    my $rs = $schema->resultset('Book');
    while (my $row = $rs->next) {
      $schema->resultset('MetaData')->create({
        book_id => $row->id,
        ...
      });
    }
  });

  my $first_row = $large_rs->first;
  $schema->txn_do(sub { ... });

  $schema->storage->dbh->do("SET TEXTSIZE $bytes");

  $schema->storage->set_textsize($bytes);

  while (my $rows = $data_source->get_100_rows()) {
    $rs->populate($rows);
  }

  created_dtm AS getdate()

  created_dtm => {
    data_type => undef,
    default_value => \'getdate()',
    is_nullable => 0,
    inflate_datetime => 1,
  }

  ts => {
    data_type => 'timestamp',
    is_nullable => 0,
    inflate_datetime => 0,
  }

package DBIx::Class::Storage::DBI::Sybase::ASE;

use strict;
use warnings;

use base qw/
    DBIx::Class::Storage::DBI::Sybase
    DBIx::Class::Storage::DBI::AutoCast
/;
use mro 'c3';
use DBIx::Class::Carp;
use Scalar::Util 'blessed';
use List::Util 'first';
use Sub::Name();
use Data::Dumper::Concise 'Dumper';
use Try::Tiny;
use namespace::clean;

__PACKAGE__->sql_limit_dialect ('RowCountOrGenericSubQ');
__PACKAGE__->sql_quote_char ([qw/[ ]/]);
__PACKAGE__->datetime_parser_type('DateTime::Format::Sybase');

__PACKAGE__->mk_group_accessors('simple' =>
    qw/_identity _blob_log_on_update _writer_storage _is_extra_storage
       _bulk_storage _is_bulk_storage _began_bulk_work
       _bulk_disabled_due_to_coderef_connect_info_warned
       _identity_method/
);

my @also_proxy_to_extra_storages = qw/
  connect_call_set_auto_cast auto_cast connect_call_blob_setup
  connect_call_datetime_setup

  disconnect _connect_info _sql_maker _sql_maker_opts disable_sth_caching
  auto_savepoint unsafe cursor_class debug debugobj schema
/;

sub _rebless {
  my $self = shift;

  my $no_bind_vars = __PACKAGE__ . '::NoBindVars';

  if ($self->using_freetds) {
    carp <<'EOF' unless $ENV{DBIC_SYBASE_FREETDS_NOWARN};

You are using FreeTDS with Sybase.

We will do our best to support this configuration, but please consider this
support experimental.

TEXT/IMAGE columns will definitely not work.

You are encouraged to recompile DBD::Sybase with the Sybase Open Client libraries
instead.

See perldoc DBIx::Class::Storage::DBI::Sybase::ASE for more details.

To turn off this warning set the DBIC_SYBASE_FREETDS_NOWARN environment
variable.
EOF

    if (not $self->_use_typeless_placeholders) {
      if ($self->_use_placeholders) {
        $self->auto_cast(1);
      }
      else {
        $self->ensure_class_loaded($no_bind_vars);
        bless $self, $no_bind_vars;
        $self->_rebless;
      }
    }
  }

  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;
    $self->_rebless;
  }
  # this is highly unlikely, but we check just in case
  elsif (not $self->_use_typeless_placeholders) {
    $self->auto_cast(1);
  }
}

sub _init {
  my $self = shift;
  $self->_set_max_connect(256);

# create storage for insert/(update blob) transactions,
# unless this is that storage
  return if $self->_is_extra_storage;

  my $writer_storage = (ref $self)->new;

  $writer_storage->_is_extra_storage(1);
  $writer_storage->connect_info($self->connect_info);
  $writer_storage->auto_cast($self->auto_cast);

  $self->_writer_storage($writer_storage);

# create a bulk storage unless connect_info is a coderef
  return if ref($self->_dbi_connect_info->[0]) eq 'CODE';

  my $bulk_storage = (ref $self)->new;

  $bulk_storage->_is_extra_storage(1);
  $bulk_storage->_is_bulk_storage(1); # for special ->disconnect acrobatics
  $bulk_storage->connect_info($self->connect_info);

# this is why
  $bulk_storage->_dbi_connect_info->[0] .= ';bulkLogin=1';

  $self->_bulk_storage($bulk_storage);
}

for my $method (@also_proxy_to_extra_storages) {
  no strict 'refs';
  no warnings 'redefine';

  my $replaced = __PACKAGE__->can($method);

  *{$method} = Sub::Name::subname $method => sub {
    my $self = shift;
    $self->_writer_storage->$replaced(@_) if $self->_writer_storage;
    $self->_bulk_storage->$replaced(@_)   if $self->_bulk_storage;
    return $self->$replaced(@_);
  };
}

sub disconnect {
  my $self = shift;

# Even though we call $sth->finish for uses off the bulk API, there's still an
# "active statement" warning on disconnect, which we throw away here.
# This is due to the bug described in insert_bulk.
# Currently a noop because 'prepare' is used instead of 'prepare_cached'.
  local $SIG{__WARN__} = sub {
    warn $_[0] unless $_[0] =~ /active statement/i;
  } if $self->_is_bulk_storage;

# so that next transaction gets a dbh
  $self->_began_bulk_work(0) if $self->_is_bulk_storage;

  $self->next::method;
}

# This is only invoked for FreeTDS drivers by ::Storage::DBI::Sybase::FreeTDS
sub _set_autocommit_stmt {
  my ($self, $on) = @_;

  return 'SET CHAINED ' . ($on ? 'OFF' : 'ON');
}

# Set up session settings for Sybase databases for the connection.
#
# Make sure we have CHAINED mode turned on if AutoCommit is off in non-FreeTDS
# DBD::Sybase (since we don't know how DBD::Sybase was compiled.) If however
# we're using FreeTDS, CHAINED mode turns on an implicit transaction which we
# only want when AutoCommit is off.
sub _run_connection_actions {
  my $self = shift;

  if ($self->_is_bulk_storage) {
    # this should be cleared on every reconnect
    $self->_began_bulk_work(0);
    return;
  }

  $self->_dbh->{syb_chained_txn} = 1
    unless $self->using_freetds;

  $self->next::method(@_);
}

sub connect_call_blob_setup {
  my $self = shift;
  my %args = @_;
  my $dbh = $self->_dbh;
  $dbh->{syb_binary_images} = 1;

  $self->_blob_log_on_update($args{log_on_update})
    if exists $args{log_on_update};
}

sub _is_lob_column {
  my ($self, $source, $column) = @_;

  return $self->_is_lob_type($source->column_info($column)->{data_type});
}

sub _prep_for_execute {
  my $self = shift;
  my ($op, $ident, $args) = @_;

  my ($sql, $bind) = $self->next::method (@_);

  my $table = blessed $ident ? $ident->from : $ident;

  my $bind_info = $self->_resolve_column_info(
    $ident, [map { $_->[0]{dbic_colname} || () } @{$bind}]
  );
  my $bound_identity_col =
    first { $bind_info->{$_}{is_auto_increment} }
    keys %$bind_info
  ;

  my $columns_info = blessed $ident && $ident->columns_info;

  my $identity_col =
    $columns_info &&
    first { $columns_info->{$_}{is_auto_increment} }
      keys %$columns_info
  ;

  if (($op eq 'insert' && $bound_identity_col) ||
      ($op eq 'update' && exists $args->[0]{$identity_col})) {
    $sql = join ("\n",
      $self->_set_table_identity_sql($op => $table, 'on'),
      $sql,
      $self->_set_table_identity_sql($op => $table, 'off'),
    );
  }

  if ($op eq 'insert' && (not $bound_identity_col) && $identity_col &&
      (not $self->{insert_bulk})) {
    $sql =
      "$sql\n" .
      $self->_fetch_identity_sql($ident, $identity_col);
  }

  return ($sql, $bind);
}

sub _set_table_identity_sql {
  my ($self, $op, $table, $on_off) = @_;

  return sprintf 'SET IDENTITY_%s %s %s',
    uc($op), $self->sql_maker->_quote($table), uc($on_off);
}

# Stolen from SQLT, with some modifications. This is a makeshift
# solution before a sane type-mapping library is available, thus
# the 'our' for easy overrides.
our %TYPE_MAPPING  = (
    number    => 'numeric',
    money     => 'money',
    varchar   => 'varchar',
    varchar2  => 'varchar',
    timestamp => 'datetime',
    text      => 'varchar',
    real      => 'double precision',
    comment   => 'text',
    bit       => 'bit',
    tinyint   => 'smallint',
    float     => 'double precision',
    serial    => 'numeric',
    bigserial => 'numeric',
    boolean   => 'varchar',
    long      => 'varchar',
);

sub _native_data_type {
  my ($self, $type) = @_;

  $type = lc $type;
  $type =~ s/\s* identity//x;

  return uc($TYPE_MAPPING{$type} || $type);
}

sub _fetch_identity_sql {
  my ($self, $source, $col) = @_;

  return sprintf ("SELECT MAX(%s) FROM %s",
    map { $self->sql_maker->_quote ($_) } ($col, $source->from)
  );
}

sub _execute {
  my $self = shift;
  my ($op) = @_;

  my ($rv, $sth, @bind) = $self->next::method(@_);

  if ($op eq 'insert') {
    $self->_identity($sth->fetchrow_array);
    $sth->finish;
  }

  return wantarray ? ($rv, $sth, @bind) : $rv;
}

sub last_insert_id { shift->_identity }

# handles TEXT/IMAGE and transaction for last_insert_id
sub insert {
  my $self = shift;
  my ($source, $to_insert) = @_;

  my $columns_info = $source->columns_info;

  my $identity_col =
    (first { $columns_info->{$_}{is_auto_increment} }
      keys %$columns_info )
    || '';

  # check for empty insert
  # INSERT INTO foo DEFAULT VALUES -- does not work with Sybase
  # try to insert explicit 'DEFAULT's instead (except for identity, timestamp
  # and computed columns)
  if (not %$to_insert) {
    for my $col ($source->columns) {
      next if $col eq $identity_col;

      my $info = $source->column_info($col);

      next if ref $info->{default_value} eq 'SCALAR'
        || (exists $info->{data_type} && (not defined $info->{data_type}));

      next if $info->{data_type} && $info->{data_type} =~ /^timestamp\z/i;

      $to_insert->{$col} = \'DEFAULT';
    }
  }

  my $blob_cols = $self->_remove_blob_cols($source, $to_insert);

  # do we need the horrific SELECT MAX(COL) hack?
  my $dumb_last_insert_id =
       $identity_col
    && (not exists $to_insert->{$identity_col})
    && ($self->_identity_method||'') ne '@@IDENTITY';

  my $next = $self->next::can;

  # we are already in a transaction, or there are no blobs
  # and we don't need the PK - just (try to) do it
  if ($self->{transaction_depth}
        || (!$blob_cols && !$dumb_last_insert_id)
  ) {
    return $self->_insert (
      $next, $source, $to_insert, $blob_cols, $identity_col
    );
  }

  # otherwise use the _writer_storage to do the insert+transaction on another
  # connection
  my $guard = $self->_writer_storage->txn_scope_guard;

  my $updated_cols = $self->_writer_storage->_insert (
    $next, $source, $to_insert, $blob_cols, $identity_col
  );

  $self->_identity($self->_writer_storage->_identity);

  $guard->commit;

  return $updated_cols;
}

sub _insert {
  my ($self, $next, $source, $to_insert, $blob_cols, $identity_col) = @_;

  my $updated_cols = $self->$next ($source, $to_insert);

  my $final_row = {
    ($identity_col ?
      ($identity_col => $self->last_insert_id($source, $identity_col)) : ()),
    %$to_insert,
    %$updated_cols,
  };

  $self->_insert_blobs ($source, $blob_cols, $final_row) if $blob_cols;

  return $updated_cols;
}

sub update {
  my $self = shift;
  my ($source, $fields, $where, @rest) = @_;

  my $blob_cols = $self->_remove_blob_cols($source, $fields);

  my $table = $source->name;

  my $columns_info = $source->columns_info;

  my $identity_col =
    first { $columns_info->{$_}{is_auto_increment} }
      keys %$columns_info;

  my $is_identity_update = $identity_col && defined $fields->{$identity_col};

  return $self->next::method(@_) unless $blob_cols;

# If there are any blobs in $where, Sybase will return a descriptive error
# message.
# XXX blobs can still be used with a LIKE query, and this should be handled.

# update+blob update(s) done atomically on separate connection
  $self = $self->_writer_storage;

  my $guard = $self->txn_scope_guard;

# First update the blob columns to be updated to '' (taken from $fields, where
# it is originally put by _remove_blob_cols .)
  my %blobs_to_empty = map { ($_ => delete $fields->{$_}) } keys %$blob_cols;

# We can't only update NULL blobs, because blobs cannot be in the WHERE clause.

  $self->next::method($source, \%blobs_to_empty, $where, @rest);

# Now update the blobs before the other columns in case the update of other
# columns makes the search condition invalid.
  $self->_update_blobs($source, $blob_cols, $where);

  my @res;
  if (%$fields) {
    if (wantarray) {
      @res    = $self->next::method(@_);
    }
    elsif (defined wantarray) {
      $res[0] = $self->next::method(@_);
    }
    else {
      $self->next::method(@_);
    }
  }

  $guard->commit;

  return wantarray ? @res : $res[0];
}

sub insert_bulk {
  my $self = shift;
  my ($source, $cols, $data) = @_;

  my $columns_info = $source->columns_info;

  my $identity_col =
    first { $columns_info->{$_}{is_auto_increment} }
      keys %$columns_info;

  my $is_identity_insert = (first { $_ eq $identity_col } @{$cols}) ? 1 : 0;

  my @source_columns = $source->columns;

  my $use_bulk_api =
    $self->_bulk_storage &&
    $self->_get_dbh->{syb_has_blk};

  if ((not $use_bulk_api)
        &&
      (ref($self->_dbi_connect_info->[0]) eq 'CODE')
        &&
      (not $self->_bulk_disabled_due_to_coderef_connect_info_warned)) {
    carp <<'EOF';
Bulk API support disabled due to use of a CODEREF connect_info. Reverting to
regular array inserts.
EOF
    $self->_bulk_disabled_due_to_coderef_connect_info_warned(1);
  }

  if (not $use_bulk_api) {
    my $blob_cols = $self->_remove_blob_cols_array($source, $cols, $data);

# _execute_array uses a txn anyway, but it ends too early in case we need to
# select max(col) to get the identity for inserting blobs.
    ($self, my $guard) = $self->{transaction_depth} == 0 ?
      ($self->_writer_storage, $self->_writer_storage->txn_scope_guard)
      :
      ($self, undef);

    local $self->{insert_bulk} = 1;

    $self->next::method(@_);

    if ($blob_cols) {
      if ($is_identity_insert) {
        $self->_insert_blobs_array ($source, $blob_cols, $cols, $data);
      }
      else {
        my @cols_with_identities = (@$cols, $identity_col);

        ## calculate identities
        # XXX This assumes identities always increase by 1, which may or may not
        # be true.
        my ($last_identity) =
          $self->_dbh->selectrow_array (
            $self->_fetch_identity_sql($source, $identity_col)
          );
        my @identities = (($last_identity - @$data + 1) .. $last_identity);

        my @data_with_identities = map [@$_, shift @identities], @$data;

        $self->_insert_blobs_array (
          $source, $blob_cols, \@cols_with_identities, \@data_with_identities
        );
      }
    }

    $guard->commit if $guard;

    return;
  }

# otherwise, use the bulk API

# rearrange @$data so that columns are in database order
  my %orig_idx;
  @orig_idx{@$cols} = 0..$#$cols;

  my %new_idx;
  @new_idx{@source_columns} = 0..$#source_columns;

  my @new_data;
  for my $datum (@$data) {
    my $new_datum = [];
    for my $col (@source_columns) {
# identity data will be 'undef' if not $is_identity_insert
# columns with defaults will also be 'undef'
      $new_datum->[ $new_idx{$col} ] =
        exists $orig_idx{$col} ? $datum->[ $orig_idx{$col} ] : undef;
    }
    push @new_data, $new_datum;
  }

# bcp identity index is 1-based
  my $identity_idx = exists $new_idx{$identity_col} ?
    $new_idx{$identity_col} + 1 : 0;

## Set a client-side conversion error handler, straight from DBD::Sybase docs.
# This ignores any data conversion errors detected by the client side libs, as
# they are usually harmless.
  my $orig_cslib_cb = DBD::Sybase::set_cslib_cb(
    Sub::Name::subname insert_bulk => sub {
      my ($layer, $origin, $severity, $errno, $errmsg, $osmsg, $blkmsg) = @_;

      return 1 if $errno == 36;

      carp
        "Layer: $layer, Origin: $origin, Severity: $severity, Error: $errno" .
        ($errmsg ? "\n$errmsg" : '') .
        ($osmsg  ? "\n$osmsg"  : '')  .
        ($blkmsg ? "\n$blkmsg" : '');

      return 0;
  });

  my $exception = '';
  try {
    my $bulk = $self->_bulk_storage;

    my $guard = $bulk->txn_scope_guard;

## XXX get this to work instead of our own $sth
## will require SQLA or *Hacks changes for ordered columns
#    $bulk->next::method($source, \@source_columns, \@new_data, {
#      syb_bcp_attribs => {
#        identity_flag   => $is_identity_insert,
#        identity_column => $identity_idx,
#      }
#    });
    my $sql = 'INSERT INTO ' .
      $bulk->sql_maker->_quote($source->name) . ' (' .
# colname list is ignored for BCP, but does no harm
      (join ', ', map $bulk->sql_maker->_quote($_), @source_columns) . ') '.
      ' VALUES ('.  (join ', ', ('?') x @source_columns) . ')';

## XXX there's a bug in the DBD::Sybase bulk support that makes $sth->finish for
## a prepare_cached statement ineffective. Replace with ->sth when fixed, or
## better yet the version above. Should be fixed in DBD::Sybase .
    my $sth = $bulk->_get_dbh->prepare($sql,
#      'insert', # op
      {
        syb_bcp_attribs => {
          identity_flag   => $is_identity_insert,
          identity_column => $identity_idx,
        }
      }
    );

    my @bind = map { [ $source_columns[$_] => $_ ] } (0 .. $#source_columns);

    $self->_execute_array(
      $source, $sth, \@bind, \@source_columns, \@new_data, sub {
        $guard->commit
      }
    );

    $bulk->_query_end($sql);
  } catch {
    $exception = shift;
  };

  DBD::Sybase::set_cslib_cb($orig_cslib_cb);

  if ($exception =~ /-Y option/) {
    my $w = 'Sybase bulk API operation failed due to character set incompatibility, '
          . 'reverting to regular array inserts. Try unsetting the LANG environment variable'
    ;
    $w .= "\n$exception" if $self->debug;
    carp $w;

    $self->_bulk_storage(undef);
    unshift @_, $self;
    goto \&insert_bulk;
  }
  elsif ($exception) {
# rollback makes the bulkLogin connection unusable
    $self->_bulk_storage->disconnect;
    $self->throw_exception($exception);
  }
}

sub _dbh_execute_array {
  my ($self, $sth, $tuple_status, $cb) = @_;

  my $rv = $self->next::method($sth, $tuple_status);
  $cb->() if $cb;

  return $rv;
}

# Make sure blobs are not bound as placeholders, and return any non-empty ones
# as a hash.
sub _remove_blob_cols {
  my ($self, $source, $fields) = @_;

  my %blob_cols;

  for my $col (keys %$fields) {
    if ($self->_is_lob_column($source, $col)) {
      my $blob_val = delete $fields->{$col};
      if (not defined $blob_val) {
        $fields->{$col} = \'NULL';
      }
      else {
        $fields->{$col} = \"''";
        $blob_cols{$col} = $blob_val unless $blob_val eq '';
      }
    }
  }

  return %blob_cols ? \%blob_cols : undef;
}

# same for insert_bulk
sub _remove_blob_cols_array {
  my ($self, $source, $cols, $data) = @_;

  my @blob_cols;

  for my $i (0..$#$cols) {
    my $col = $cols->[$i];

    if ($self->_is_lob_column($source, $col)) {
      for my $j (0..$#$data) {
        my $blob_val = delete $data->[$j][$i];
        if (not defined $blob_val) {
          $data->[$j][$i] = \'NULL';
        }
        else {
          $data->[$j][$i] = \"''";
          $blob_cols[$j][$i] = $blob_val
            unless $blob_val eq '';
        }
      }
    }
  }

  return @blob_cols ? \@blob_cols : undef;
}

sub _update_blobs {
  my ($self, $source, $blob_cols, $where) = @_;

  my @primary_cols = try
    { $source->_pri_cols }
    catch {
      $self->throw_exception("Cannot update TEXT/IMAGE column(s): $_")
    };

  my @pks_to_update;
  if (
    ref $where eq 'HASH'
      and
    @primary_cols == grep { defined $where->{$_} } @primary_cols
  ) {
    my %row_to_update;
    @row_to_update{@primary_cols} = @{$where}{@primary_cols};
    @pks_to_update = \%row_to_update;
  }
  else {
    my $cursor = $self->select ($source, \@primary_cols, $where, {});
    @pks_to_update = map {
      my %row; @row{@primary_cols} = @$_; \%row
    } $cursor->all;
  }

  for my $ident (@pks_to_update) {
    $self->_insert_blobs($source, $blob_cols, $ident);
  }
}

sub _insert_blobs {
  my ($self, $source, $blob_cols, $row) = @_;
  my $dbh = $self->_get_dbh;

  my $table = $source->name;

  my %row = %$row;
  my @primary_cols = try
    { $source->_pri_cols }
    catch {
      $self->throw_exception("Cannot update TEXT/IMAGE column(s): $_")
    };

  $self->throw_exception('Cannot update TEXT/IMAGE column(s) without primary key values')
    if ((grep { defined $row{$_} } @primary_cols) != @primary_cols);

  for my $col (keys %$blob_cols) {
    my $blob = $blob_cols->{$col};

    my %where = map { ($_, $row{$_}) } @primary_cols;

    my $cursor = $self->select ($source, [$col], \%where, {});
    $cursor->next;
    my $sth = $cursor->sth;

    if (not $sth) {
      $self->throw_exception(
          "Could not find row in table '$table' for blob update:\n"
        . (Dumper \%where)
      );
    }

    try {
      do {
        $sth->func('CS_GET', 1, 'ct_data_info') or die $sth->errstr;
      } while $sth->fetch;

      $sth->func('ct_prepare_send') or die $sth->errstr;

      my $log_on_update = $self->_blob_log_on_update;
      $log_on_update    = 1 if not defined $log_on_update;

      $sth->func('CS_SET', 1, {
        total_txtlen => length($blob),
        log_on_update => $log_on_update
      }, 'ct_data_info') or die $sth->errstr;

      $sth->func($blob, length($blob), 'ct_send_data') or die $sth->errstr;

      $sth->func('ct_finish_send') or die $sth->errstr;
    }
    catch {
      if ($self->using_freetds) {
        $self->throw_exception (
          "TEXT/IMAGE operation failed, probably because you are using FreeTDS: $_"
        );
      }
      else {
        $self->throw_exception($_);
      }
    }
    finally {
      $sth->finish if $sth;
    };
  }
}

sub _insert_blobs_array {
  my ($self, $source, $blob_cols, $cols, $data) = @_;

  for my $i (0..$#$data) {
    my $datum = $data->[$i];

    my %row;
    @row{ @$cols } = @$datum;

    my %blob_vals;
    for my $j (0..$#$cols) {
      if (exists $blob_cols->[$i][$j]) {
        $blob_vals{ $cols->[$j] } = $blob_cols->[$i][$j];
      }
    }

    $self->_insert_blobs ($source, \%blob_vals, \%row);
  }
}

sub connect_call_datetime_setup {
  my $self = shift;
  my $dbh = $self->_get_dbh;

  if ($dbh->can('syb_date_fmt')) {
    # amazingly, this works with FreeTDS
    $dbh->syb_date_fmt('ISO_strict');
  }
  else {
    carp_once
      'Your DBD::Sybase is too old to support '
     .'DBIx::Class::InflateColumn::DateTime, please upgrade!';

    $dbh->do('SET DATEFORMAT mdy');
    1;
  }
}


sub _exec_txn_begin {
  my $self = shift;

# bulkLogin=1 connections are always in a transaction, and can only call BEGIN
# TRAN once. However, we need to make sure there's a $dbh.
  return if $self->_is_bulk_storage && $self->_dbh && $self->_began_bulk_work;

  $self->next::method(@_);

  $self->_began_bulk_work(1) if $self->_is_bulk_storage;
}

# savepoint support using ASE syntax

sub _exec_svp_begin {
  my ($self, $name) = @_;

  $self->_dbh->do("SAVE TRANSACTION $name");
}

# A new SAVE TRANSACTION with the same name releases the previous one.
sub _exec_svp_release { 1 }

sub _exec_svp_rollback {
  my ($self, $name) = @_;

  $self->_dbh->do("ROLLBACK TRANSACTION $name");
}

1;

# vim:sts=2 sw=2: