lib/DBIx/Class/Storage/DBI/Sybase.pm

   1 package DBIx::Class::Storage::DBI::Sybase;
   2
   3 use strict;
   4 use warnings;
   5
   6 use base qw/
   7     DBIx::Class::Storage::DBI::Sybase::Common
   8     DBIx::Class::Storage::DBI::AutoCast
   9 /;
  10 use mro 'c3';
  11 use Carp::Clan qw/^DBIx::Class/;
  12 use List::Util ();
  13
  14 __PACKAGE__->mk_group_accessors('simple' =>
  15     qw/_identity _blob_log_on_update _insert_dbh _identity_method/
  16 );
  17
  18 =head1 NAME
  19
  20 DBIx::Class::Storage::DBI::Sybase - Sybase support for DBIx::Class
  21
  22 =head1 SYNOPSIS
  23
  24 This subclass supports L<DBD::Sybase> for real Sybase databases.  If you are
  25 using an MSSQL database via L<DBD::Sybase>, your storage will be reblessed to
  26 L<DBIx::Class::Storage::DBI::Sybase::Microsoft_SQL_Server>.
  27
  28 =head1 DESCRIPTION
  29
  30 If your version of Sybase does not support placeholders, then your storage
  31 will be reblessed to L<DBIx::Class::Storage::DBI::Sybase::NoBindVars>. You can
  32 also enable that driver explicitly, see the documentation for more details.
  33
  34 With this driver there is unfortunately no way to get the C<last_insert_id>
  35 without doing a C<SELECT MAX(col)>. This is done safely in a transaction
  36 (locking the table.) See L</INSERTS WITH PLACEHOLDERS>.
  37
  38 A recommended L<DBIx::Class::Storage::DBI/connect_info> setting:
  39
  40   on_connect_call => [['datetime_setup'], ['blob_setup', log_on_update => 0]]
  41
  42 =head1 METHODS
  43
  44 =cut
  45
  46 sub _rebless {
  47   my $self = shift;
  48
  49   if (ref($self) eq 'DBIx::Class::Storage::DBI::Sybase') {
  50     my $dbtype = eval {
  51       @{$self->_get_dbh->selectrow_arrayref(qq{sp_server_info \@attribute_id=1})}[2]
  52     } || '';
  53
  54     my $exception = $@;
  55     $dbtype =~ s/\W/_/gi;
  56     my $subclass = "DBIx::Class::Storage::DBI::Sybase::${dbtype}";
  57
  58     if (!$exception && $dbtype && $self->load_optional_class($subclass)) {
  59       bless $self, $subclass;
  60       $self->_rebless;
  61     } else { # real Sybase
  62       my $no_bind_vars = 'DBIx::Class::Storage::DBI::Sybase::NoBindVars';
  63
  64       if ($self->using_freetds) {
  65         carp <<'EOF' unless $ENV{DBIC_SYBASE_FREETDS_NOWARN};
  66
  67 You are using FreeTDS with Sybase.
  68
  69 We will do our best to support this configuration, but please consider this
  70 support experimental.
  71
  72 TEXT/IMAGE columns will definitely not work.
  73
  74 You are encouraged to recompile DBD::Sybase with the Sybase Open Client libraries
  75 instead.
  76
  77 See perldoc DBIx::Class::Storage::DBI::Sybase for more details.
  78
  79 To turn off this warning set the DBIC_SYBASE_FREETDS_NOWARN environment
  80 variable.
  81 EOF
  82         if (not $self->_typeless_placeholders_supported) {
  83           if ($self->_placeholders_supported) {
  84             $self->auto_cast(1);
  85           } else {
  86             $self->ensure_class_loaded($no_bind_vars);
  87             bless $self, $no_bind_vars;
  88             $self->_rebless;
  89           }
  90         }
  91       }
  92       elsif (not $self->_get_dbh->{syb_dynamic_supported}) {
  93         # not necessarily FreeTDS, but no placeholders nevertheless
  94         $self->ensure_class_loaded($no_bind_vars);
  95         bless $self, $no_bind_vars;
  96         $self->_rebless;
  97       } elsif (not $self->_typeless_placeholders_supported) {
  98 # this is highly unlikely, but we check just in case
  99         $self->auto_cast(1);
 100       }
 101     }
 102   }
 103 }
 104
 105 sub _init {
 106   my $self = shift;
 107   $self->_set_max_connect(256);
 108
 109   # based on LongReadLen in connect_info
 110   $self->set_textsize if $self->using_freetds;
 111 }
 112
 113 # Make sure we have CHAINED mode turned on if AutoCommit is off in non-FreeTDS
 114 # DBD::Sybase (since we don't know how DBD::Sybase was compiled.) If however
 115 # we're using FreeTDS, CHAINED mode turns on an implicit transaction which we
 116 # only want when AutoCommit is off.
 117 sub _populate_dbh {
 118   my $self = shift;
 119
 120   $self->next::method(@_);
 121
 122   if (not $self->using_freetds) {
 123     $self->_dbh->{syb_chained_txn} = 1;
 124   } else {
 125     if ($self->_dbh_autocommit) {
 126       $self->_dbh->do('SET CHAINED OFF');
 127     } else {
 128       $self->_dbh->do('SET CHAINED ON');
 129     }
 130   }
 131 }
 132
 133 =head2 connect_call_blob_setup
 134
 135 Used as:
 136
 137   on_connect_call => [ [ 'blob_setup', log_on_update => 0 ] ]
 138
 139 Does C<< $dbh->{syb_binary_images} = 1; >> to return C<IMAGE> data as raw binary
 140 instead of as a hex string.
 141
 142 Recommended.
 143
 144 Also sets the C<log_on_update> value for blob write operations. The default is
 145 C<1>, but C<0> is better if your database is configured for it.
 146
 147 See
 148 L<DBD::Sybase/Handling_IMAGE/TEXT_data_with_syb_ct_get_data()/syb_ct_send_data()>.
 149
 150 =cut
 151
 152 sub connect_call_blob_setup {
 153   my $self = shift;
 154   my %args = @_;
 155   my $dbh = $self->_dbh;
 156   $dbh->{syb_binary_images} = 1;
 157
 158   $self->_blob_log_on_update($args{log_on_update})
 159     if exists $args{log_on_update};
 160 }
 161
 162 sub _is_lob_type {
 163   my $self = shift;
 164   my $type = shift;
 165   $type && $type =~ /(?:text|image|lob|bytea|binary|memo)/i;
 166 }
 167
 168 sub _prep_for_execute {
 169   my $self = shift;
 170   my ($op, $extra_bind, $ident, $args) = @_;
 171
 172   my ($sql, $bind) = $self->next::method (@_);
 173
 174   if ($op eq 'insert') {
 175     my $table = $ident->from;
 176
 177     my $bind_info = $self->_resolve_column_info(
 178       $ident, [map $_->[0], @{$bind}]
 179     );
 180     my $identity_col = List::Util::first
 181       { $bind_info->{$_}{is_auto_increment} }
 182       (keys %$bind_info)
 183     ;
 184
 185     if ($identity_col) {
 186       $sql = join ("\n",
 187         "SET IDENTITY_INSERT $table ON",
 188         $sql,
 189         "SET IDENTITY_INSERT $table OFF",
 190       );
 191     }
 192     else {
 193       $identity_col = List::Util::first
 194         { $ident->column_info($_)->{is_auto_increment} }
 195         $ident->columns
 196       ;
 197     }
 198
 199     if ($identity_col) {
 200       $sql =
 201         "$sql\n" .
 202         $self->_fetch_identity_sql($ident, $identity_col);
 203     }
 204   }
 205
 206   return ($sql, $bind);
 207 }
 208
 209 # Stolen from SQLT, with some modifications. This is a makeshift
 210 # solution before a sane type-mapping library is available, thus
 211 # the 'our' for easy overrides.
 212 our %TYPE_MAPPING  = (
 213     number    => 'numeric',
 214     money     => 'money',
 215     varchar   => 'varchar',
 216     varchar2  => 'varchar',
 217     timestamp => 'datetime',
 218     text      => 'varchar',
 219     real      => 'double precision',
 220     comment   => 'text',
 221     bit       => 'bit',
 222     tinyint   => 'smallint',
 223     float     => 'double precision',
 224     serial    => 'numeric',
 225     bigserial => 'numeric',
 226     boolean   => 'varchar',
 227     long      => 'varchar',
 228 );
 229
 230 sub _native_data_type {
 231   my ($self, $type) = @_;
 232
 233   $type = lc $type;
 234   $type =~ s/\s* identity//x;
 235
 236   return uc($TYPE_MAPPING{$type} || $type);
 237 }
 238
 239 sub _fetch_identity_sql {
 240   my ($self, $source, $col) = @_;
 241
 242   return "SELECT MAX($col) FROM ".$source->from;
 243 }
 244
 245 sub _execute {
 246   my $self = shift;
 247   my ($op) = @_;
 248
 249   my ($rv, $sth, @bind) = $self->dbh_do($self->can('_dbh_execute'), @_);
 250
 251   if ($op eq 'insert') {
 252     $self->_identity($sth->fetchrow_array);
 253     $sth->finish;
 254   }
 255
 256   return wantarray ? ($rv, $sth, @bind) : $rv;
 257 }
 258
 259 sub last_insert_id { shift->_identity }
 260
 261 # handles TEXT/IMAGE and transaction for last_insert_id
 262 sub insert {
 263   my $self = shift;
 264   my ($source, $to_insert) = @_;
 265
 266   my $blob_cols = $self->_remove_blob_cols($source, $to_insert);
 267
 268 # insert+blob insert done atomically, on _insert_dbh
 269   (my ($guard), local ($self->{_dbh})) = do {
 270     $self->_insert_dbh($self->_connect(@{ $self->_dbi_connect_info }))
 271       unless $self->_insert_dbh;
 272
 273     my $new_guard = $self->txn_scope_guard;
 274
 275 # _dbh_begin_work may reconnect, if so we need to update _insert_dbh
 276     $self->_insert_dbh($self->_dbh);
 277
 278     ($new_guard, $self->_insert_dbh)
 279   } if $blob_cols;
 280
 281   my $need_last_insert_id = 0;
 282
 283   my ($identity_col) =
 284     map $_->[0],
 285     grep $_->[1]{is_auto_increment},
 286     map [ $_, $source->column_info($_) ],
 287     $source->columns;
 288
 289   $need_last_insert_id = 1
 290     if $identity_col && (not exists $to_insert->{$identity_col});
 291
 292   # We have to do the insert in a transaction to avoid race conditions with the
 293   # SELECT MAX(COL) identity method used when placeholders are enabled.
 294   my $updated_cols = do {
 295     no warnings 'uninitialized';
 296     if (
 297       $need_last_insert_id &&
 298       $self->_identity_method ne '@@IDENTITY' &&
 299       !$self->{transaction_depth}
 300     ) {
 301       $self->_insert_dbh($self->_connect(@{ $self->_dbi_connect_info }))
 302         unless $self->_insert_dbh;
 303       local $self->{_dbh} = $self->_insert_dbh;
 304
 305       my $guard = $self->txn_scope_guard;
 306
 307 # _dbh_begin_work may reconnect, if so we need to update _insert_dbh
 308       $self->_insert_dbh($self->_dbh);
 309
 310       my $upd_cols = $self->next::method (@_);
 311       $guard->commit;
 312
 313       $upd_cols;
 314     }
 315     else {
 316       $self->next::method(@_);
 317     }
 318   };
 319
 320   $self->_insert_blobs($source, $blob_cols, $to_insert) if $blob_cols;
 321
 322   $guard->commit if $guard;
 323
 324   return $updated_cols;
 325 }
 326
 327 sub update {
 328   my $self = shift;
 329   my ($source, $fields, $where) = @_;
 330
 331   my $wantarray = wantarray;
 332
 333   my $blob_cols = $self->_remove_blob_cols($source, $fields);
 334
 335 # update+blob update(s) done atomically
 336   my $guard = $self->txn_scope_guard if $blob_cols;
 337
 338   my @res;
 339   if ($wantarray) {
 340     @res    = $self->next::method(@_);
 341   }
 342   elsif (defined $wantarray) {
 343     $res[0] = $self->next::method(@_);
 344   }
 345   else {
 346     $self->next::method(@_);
 347   }
 348
 349   $self->_update_blobs($source, $blob_cols, $where) if $blob_cols;
 350
 351   $guard->commit if $guard;
 352
 353   return $wantarray ? @res : $res[0];
 354 }
 355
 356 sub _remove_blob_cols {
 357   my ($self, $source, $fields) = @_;
 358
 359   my %blob_cols;
 360
 361   for my $col (keys %$fields) {
 362     if ($self->_is_lob_type($source->column_info($col)->{data_type})) {
 363       $blob_cols{$col} = delete $fields->{$col};
 364       $fields->{$col} = \"''";
 365     }
 366   }
 367
 368   return keys %blob_cols ? \%blob_cols : undef;
 369 }
 370
 371 sub _update_blobs {
 372   my ($self, $source, $blob_cols, $where) = @_;
 373
 374   my (@primary_cols) = $source->primary_columns;
 375
 376   croak "Cannot update TEXT/IMAGE column(s) without a primary key"
 377     unless @primary_cols;
 378
 379 # check if we're updating a single row by PK
 380   my $pk_cols_in_where = 0;
 381   for my $col (@primary_cols) {
 382     $pk_cols_in_where++ if defined $where->{$col};
 383   }
 384   my @rows;
 385
 386   if ($pk_cols_in_where == @primary_cols) {
 387     my %row_to_update;
 388     @row_to_update{@primary_cols} = @{$where}{@primary_cols};
 389     @rows = \%row_to_update;
 390   } else {
 391     my $rs = $source->resultset->search(
 392       $where,
 393       {
 394         result_class => 'DBIx::Class::ResultClass::HashRefInflator',
 395         select => \@primary_cols
 396       }
 397     );
 398     @rows = $rs->all; # statement must finish
 399   }
 400
 401   for my $row (@rows) {
 402     $self->_insert_blobs($source, $blob_cols, $row);
 403   }
 404 }
 405
 406 sub _insert_blobs {
 407   my ($self, $source, $blob_cols, $row) = @_;
 408   my $dbh = $self->_get_dbh;
 409
 410   my $table = $source->from;
 411
 412   my %row = %$row;
 413   my (@primary_cols) = $source->primary_columns;
 414
 415   croak "Cannot update TEXT/IMAGE column(s) without a primary key"
 416     unless @primary_cols;
 417
 418   if ((grep { defined $row{$_} } @primary_cols) != @primary_cols) {
 419     if (@primary_cols == 1) {
 420       my $col = $primary_cols[0];
 421       $row{$col} = $self->last_insert_id($source, $col);
 422     } else {
 423       croak "Cannot update TEXT/IMAGE column(s) without primary key values";
 424     }
 425   }
 426
 427   for my $col (keys %$blob_cols) {
 428     my $blob = $blob_cols->{$col};
 429
 430     my %where = map { ($_, $row{$_}) } @primary_cols;
 431     my $cursor = $source->resultset->search(\%where, {
 432       select => [$col]
 433     })->cursor;
 434     $cursor->next;
 435     my $sth = $cursor->sth;
 436
 437     eval {
 438       do {
 439         $sth->func('CS_GET', 1, 'ct_data_info') or die $sth->errstr;
 440       } while $sth->fetch;
 441
 442       $sth->func('ct_prepare_send') or die $sth->errstr;
 443
 444       my $log_on_update = $self->_blob_log_on_update;
 445       $log_on_update    = 1 if not defined $log_on_update;
 446
 447       $sth->func('CS_SET', 1, {
 448         total_txtlen => length($blob),
 449         log_on_update => $log_on_update
 450       }, 'ct_data_info') or die $sth->errstr;
 451
 452       $sth->func($blob, length($blob), 'ct_send_data') or die $sth->errstr;
 453
 454       $sth->func('ct_finish_send') or die $sth->errstr;
 455     };
 456     my $exception = $@;
 457     $sth->finish if $sth;
 458     if ($exception) {
 459       if ($self->using_freetds) {
 460         croak (
 461           'TEXT/IMAGE operation failed, probably because you are using FreeTDS: '
 462           . $exception
 463         );
 464       } else {
 465         croak $exception;
 466       }
 467     }
 468   }
 469 }
 470
 471 =head2 connect_call_datetime_setup
 472
 473 Used as:
 474
 475   on_connect_call => 'datetime_setup'
 476
 477 In L<DBIx::Class::Storage::DBI/connect_info> to set:
 478
 479   $dbh->syb_date_fmt('ISO_strict'); # output fmt: 2004-08-21T14:36:48.080Z
 480   $dbh->do('set dateformat mdy');   # input fmt:  08/13/1979 18:08:55.080
 481
 482 On connection for use with L<DBIx::Class::InflateColumn::DateTime>, using
 483 L<DateTime::Format::Sybase>, which you will need to install.
 484
 485 This works for both C<DATETIME> and C<SMALLDATETIME> columns, although
 486 C<SMALLDATETIME> columns only have minute precision.
 487
 488 =cut
 489
 490 {
 491   my $old_dbd_warned = 0;
 492
 493   sub connect_call_datetime_setup {
 494     my $self = shift;
 495     my $dbh = $self->_dbh;
 496
 497     if ($dbh->can('syb_date_fmt')) {
 498       # amazingly, this works with FreeTDS
 499       $dbh->syb_date_fmt('ISO_strict');
 500     } elsif (not $old_dbd_warned) {
 501       carp "Your DBD::Sybase is too old to support ".
 502       "DBIx::Class::InflateColumn::DateTime, please upgrade!";
 503       $old_dbd_warned = 1;
 504     }
 505
 506     $dbh->do('SET DATEFORMAT mdy');
 507
 508     1;
 509   }
 510 }
 511
 512 sub datetime_parser_type { "DateTime::Format::Sybase" }
 513
 514 # ->begin_work and such have no effect with FreeTDS but we run them anyway to
 515 # let the DBD keep any state it needs to.
 516 #
 517 # If they ever do start working, the extra statements will do no harm (because
 518 # Sybase supports nested transactions.)
 519
 520 sub _dbh_begin_work {
 521   my $self = shift;
 522   $self->next::method(@_);
 523   if ($self->using_freetds) {
 524     $self->_get_dbh->do('BEGIN TRAN');
 525   }
 526 }
 527
 528 sub _dbh_commit {
 529   my $self = shift;
 530   if ($self->using_freetds) {
 531     $self->_dbh->do('COMMIT');
 532   }
 533   return $self->next::method(@_);
 534 }
 535
 536 sub _dbh_rollback {
 537   my $self = shift;
 538   if ($self->using_freetds) {
 539     $self->_dbh->do('ROLLBACK');
 540   }
 541   return $self->next::method(@_);
 542 }
 543
 544 # savepoint support using ASE syntax
 545
 546 sub _svp_begin {
 547   my ($self, $name) = @_;
 548
 549   $self->_get_dbh->do("SAVE TRANSACTION $name");
 550 }
 551
 552 # A new SAVE TRANSACTION with the same name releases the previous one.
 553 sub _svp_release { 1 }
 554
 555 sub _svp_rollback {
 556   my ($self, $name) = @_;
 557
 558   $self->_get_dbh->do("ROLLBACK TRANSACTION $name");
 559 }
 560
 561 1;
 562
 563 =head1 Schema::Loader Support
 564
 565 There is an experimental branch of L<DBIx::Class::Schema::Loader> that will
 566 allow you to dump a schema from most (if not all) versions of Sybase.
 567
 568 It is available via subversion from:
 569
 570   http://dev.catalyst.perl.org/repos/bast/branches/DBIx-Class-Schema-Loader/current/
 571
 572 =head1 FreeTDS
 573
 574 This driver supports L<DBD::Sybase> compiled against FreeTDS
 575 (L<http://www.freetds.org/>) to the best of our ability, however it is
 576 recommended that you recompile L<DBD::Sybase> against the Sybase Open Client
 577 libraries. They are a part of the Sybase ASE distribution:
 578
 579 The Open Client FAQ is here:
 580 L<http://www.isug.com/Sybase_FAQ/ASE/section7.html>.
 581
 582 Sybase ASE for Linux (which comes with the Open Client libraries) may be
 583 downloaded here: L<http://response.sybase.com/forms/ASE_Linux_Download>.
 584
 585 To see if you're using FreeTDS check C<< $schema->storage->using_freetds >>, or run:
 586
 587   perl -MDBI -le 'my $dbh = DBI->connect($dsn, $user, $pass); print $dbh->{syb_oc_version}'
 588
 589 Some versions of the libraries involved will not support placeholders, in which
 590 case the storage will be reblessed to
 591 L<DBIx::Class::Storage::DBI::Sybase::NoBindVars>.
 592
 593 In some configurations, placeholders will work but will throw implicit type
 594 conversion errors for anything that's not expecting a string. In such a case,
 595 the C<auto_cast> option from L<DBIx::Class::Storage::DBI::AutoCast> is
 596 automatically set, which you may enable on connection with
 597 L<DBIx::Class::Storage::DBI::AutoCast/connect_call_set_auto_cast>. The type info
 598 for the C<CAST>s is taken from the L<DBIx::Class::ResultSource/data_type>
 599 definitions in your Result classes, and are mapped to a Sybase type (if it isn't
 600 already) using a mapping based on L<SQL::Translator>.
 601
 602 In other configurations, placeholers will work just as they do with the Sybase
 603 Open Client libraries.
 604
 605 Inserts or updates of TEXT/IMAGE columns will B<NOT> work with FreeTDS.
 606
 607 =head1 INSERTS WITH PLACEHOLDERS
 608
 609 With placeholders enabled, inserts are done in a transaction so that there are
 610 no concurrency issues with getting the inserted identity value using
 611 C<SELECT MAX(col)>, which is the only way to get the C<IDENTITY> value in this
 612 mode.
 613
 614 When using C<DBIx::Class::Storage::DBI::Sybase::NoBindVars> transactions are
 615 disabled, as there are no concurrency issues with C<SELECT @@IDENTITY> as it's a
 616 session variable.
 617
 618 =head1 TRANSACTIONS
 619
 620 Due to limitations of the TDS protocol, L<DBD::Sybase>, or both; you cannot
 621 begin a transaction while there are active cursors. An active cursor is, for
 622 example, a L<ResultSet|DBIx::Class::ResultSet> that has been executed using
 623 C<next> or C<first> but has not been exhausted or
 624 L<reset|DBIx::Class::ResultSet/reset>.
 625
 626 For example, this will not work:
 627
 628   $schema->txn_do(sub {
 629     my $rs = $schema->resultset('Book');
 630     while (my $row = $rs->next) {
 631       $schema->resultset('MetaData')->create({
 632         book_id => $row->id,
 633         ...
 634       });
 635     }
 636   });
 637
 638 Transactions done for inserts in C<AutoCommit> mode when placeholders are in use
 639 are not affected, as they use an extra database handle to do the insert.
 640
 641 Some workarounds:
 642
 643 =over 4
 644
 645 =item * use L<DBIx::Class::Storage::DBI::Replicated>
 646
 647 =item * L<connect|DBIx::Class::Schema/connect> another L<Schema|DBIx::Class::Schema>
 648
 649 =item * load the data from your cursor with L<DBIx::Class::ResultSet/all>
 650
 651 =back
 652
 653 =head1 MAXIMUM CONNECTIONS
 654
 655 The TDS protocol makes separate connections to the server for active statements
 656 in the background. By default the number of such connections is limited to 25,
 657 on both the client side and the server side.
 658
 659 This is a bit too low for a complex L<DBIx::Class> application, so on connection
 660 the client side setting is set to C<256> (see L<DBD::Sybase/maxConnect>.) You
 661 can override it to whatever setting you like in the DSN.
 662
 663 See
 664 L<http://infocenter.sybase.com/help/index.jsp?topic=/com.sybase.help.ase_15.0.sag1/html/sag1/sag1272.htm>
 665 for information on changing the setting on the server side.
 666
 667 =head1 DATES
 668
 669 See L</connect_call_datetime_setup> to setup date formats
 670 for L<DBIx::Class::InflateColumn::DateTime>.
 671
 672 =head1 TEXT/IMAGE COLUMNS
 673
 674 L<DBD::Sybase> compiled with FreeTDS will B<NOT> allow you to insert or update
 675 C<TEXT/IMAGE> columns.
 676
 677 Setting C<< $dbh->{LongReadLen} >> will also not work with FreeTDS use either:
 678
 679   $schema->storage->dbh->do("SET TEXTSIZE $bytes");
 680
 681 or
 682
 683   $schema->storage->set_textsize($bytes);
 684
 685 instead.
 686
 687 However, the C<LongReadLen> you pass in
 688 L<DBIx::Class::Storage::DBI/connect_info> is used to execute the equivalent
 689 C<SET TEXTSIZE> command on connection.
 690
 691 See L</connect_call_blob_setup> for a L<DBIx::Class::Storage::DBI/connect_info>
 692 setting you need to work with C<IMAGE> columns.
 693
 694 =head1 AUTHOR
 695
 696 See L<DBIx::Class/CONTRIBUTORS>.
 697
 698 =head1 LICENSE
 699
 700 You may distribute this code under the same terms as Perl itself.
 701
 702 =cut
 703 # vim:sts=2 sw=2: