1 package DBIx::Class::Storage::DBI;
2 # -*- mode: cperl; cperl-indent-level: 2 -*-
4 use base 'DBIx::Class::Storage';
9 use SQL::Abstract::Limit;
10 use DBIx::Class::Storage::DBI::Cursor;
11 use DBIx::Class::Storage::Statistics;
13 use Scalar::Util 'blessed';
15 __PACKAGE__->mk_group_accessors(
17 qw/_connect_info _dbh _sql_maker _sql_maker_opts _conn_pid _conn_tid
18 disable_sth_caching cursor on_connect_do transaction_depth/
23 package DBIC::SQL::Abstract; # Would merge upstream, but nate doesn't reply :(
25 use base qw/SQL::Abstract::Limit/;
27 # This prevents the caching of $dbh in S::A::L, I believe
29 my $self = shift->SUPER::new(@_);
31 # If limit_dialect is a ref (like a $dbh), go ahead and replace
32 # it with what it resolves to:
33 $self->{limit_dialect} = $self->_find_syntax($self->{limit_dialect})
34 if ref $self->{limit_dialect};
40 my ($self, $sql, $order, $rows, $offset ) = @_;
43 my $last = $rows + $offset;
44 my ( $order_by ) = $self->_order_by( $order );
49 SELECT Q1.*, ROW_NUMBER() OVER( ) AS ROW_NUM FROM (
54 WHERE ROW_NUM BETWEEN $offset AND $last
60 # While we're at it, this should make LIMIT queries more efficient,
61 # without digging into things too deeply
62 use Scalar::Util 'blessed';
64 my ($self, $syntax) = @_;
65 my $dbhname = blessed($syntax) ? $syntax->{Driver}{Name} : $syntax;
66 if(ref($self) && $dbhname && $dbhname eq 'DB2') {
67 return 'RowNumberOver';
70 $self->{_cached_syntax} ||= $self->SUPER::_find_syntax($syntax);
74 my ($self, $table, $fields, $where, $order, @rest) = @_;
75 $table = $self->_quote($table) unless ref($table);
76 local $self->{rownum_hack_count} = 1
77 if (defined $rest[0] && $self->{limit_dialect} eq 'RowNum');
78 @rest = (-1) unless defined $rest[0];
79 die "LIMIT 0 Does Not Compute" if $rest[0] == 0;
80 # and anyway, SQL::Abstract::Limit will cause a barf if we don't first
81 local $self->{having_bind} = [];
82 my ($sql, @ret) = $self->SUPER::select(
83 $table, $self->_recurse_fields($fields), $where, $order, @rest
85 return wantarray ? ($sql, @ret, @{$self->{having_bind}}) : $sql;
91 $table = $self->_quote($table) unless ref($table);
92 $self->SUPER::insert($table, @_);
98 $table = $self->_quote($table) unless ref($table);
99 $self->SUPER::update($table, @_);
105 $table = $self->_quote($table) unless ref($table);
106 $self->SUPER::delete($table, @_);
112 return $_[1].$self->_order_by($_[2]);
114 return $self->SUPER::_emulate_limit(@_);
118 sub _recurse_fields {
119 my ($self, $fields) = @_;
120 my $ref = ref $fields;
121 return $self->_quote($fields) unless $ref;
122 return $$fields if $ref eq 'SCALAR';
124 if ($ref eq 'ARRAY') {
125 return join(', ', map {
126 $self->_recurse_fields($_)
127 .(exists $self->{rownum_hack_count}
128 ? ' AS col'.$self->{rownum_hack_count}++
131 } elsif ($ref eq 'HASH') {
132 foreach my $func (keys %$fields) {
133 return $self->_sqlcase($func)
134 .'( '.$self->_recurse_fields($fields->{$func}).' )';
143 if (ref $_[0] eq 'HASH') {
144 if (defined $_[0]->{group_by}) {
145 $ret = $self->_sqlcase(' group by ')
146 .$self->_recurse_fields($_[0]->{group_by});
148 if (defined $_[0]->{having}) {
150 ($frag, @extra) = $self->_recurse_where($_[0]->{having});
151 push(@{$self->{having_bind}}, @extra);
152 $ret .= $self->_sqlcase(' having ').$frag;
154 if (defined $_[0]->{order_by}) {
155 $ret .= $self->_order_by($_[0]->{order_by});
157 } elsif (ref $_[0] eq 'SCALAR') {
158 $ret = $self->_sqlcase(' order by ').${ $_[0] };
159 } elsif (ref $_[0] eq 'ARRAY' && @{$_[0]}) {
160 my @order = @{+shift};
161 $ret = $self->_sqlcase(' order by ')
163 my $r = $self->_order_by($_, @_);
164 $r =~ s/^ ?ORDER BY //i;
168 $ret = $self->SUPER::_order_by(@_);
173 sub _order_directions {
174 my ($self, $order) = @_;
175 $order = $order->{order_by} if ref $order eq 'HASH';
176 return $self->SUPER::_order_directions($order);
180 my ($self, $from) = @_;
181 if (ref $from eq 'ARRAY') {
182 return $self->_recurse_from(@$from);
183 } elsif (ref $from eq 'HASH') {
184 return $self->_make_as($from);
186 return $from; # would love to quote here but _table ends up getting called
187 # twice during an ->select without a limit clause due to
188 # the way S::A::Limit->select works. should maybe consider
189 # bypassing this and doing S::A::select($self, ...) in
190 # our select method above. meantime, quoting shims have
191 # been added to select/insert/update/delete here
196 my ($self, $from, @join) = @_;
198 push(@sqlf, $self->_make_as($from));
199 foreach my $j (@join) {
202 # check whether a join type exists
203 my $join_clause = '';
204 my $to_jt = ref($to) eq 'ARRAY' ? $to->[0] : $to;
205 if (ref($to_jt) eq 'HASH' and exists($to_jt->{-join_type})) {
206 $join_clause = ' '.uc($to_jt->{-join_type}).' JOIN ';
208 $join_clause = ' JOIN ';
210 push(@sqlf, $join_clause);
212 if (ref $to eq 'ARRAY') {
213 push(@sqlf, '(', $self->_recurse_from(@$to), ')');
215 push(@sqlf, $self->_make_as($to));
217 push(@sqlf, ' ON ', $self->_join_condition($on));
219 return join('', @sqlf);
223 my ($self, $from) = @_;
224 return join(' ', map { (ref $_ eq 'SCALAR' ? $$_ : $self->_quote($_)) }
225 reverse each %{$self->_skip_options($from)});
229 my ($self, $hash) = @_;
231 $clean_hash->{$_} = $hash->{$_}
232 for grep {!/^-/} keys %$hash;
236 sub _join_condition {
237 my ($self, $cond) = @_;
238 if (ref $cond eq 'HASH') {
243 # XXX no throw_exception() in this package and croak() fails with strange results
244 Carp::croak(ref($v) . qq{ reference arguments are not supported in JOINS - try using \"..." instead'})
245 if ref($v) ne 'SCALAR';
249 my $x = '= '.$self->_quote($v); $j{$_} = \$x;
252 return scalar($self->_recurse_where(\%j));
253 } elsif (ref $cond eq 'ARRAY') {
254 return join(' OR ', map { $self->_join_condition($_) } @$cond);
256 die "Can't handle this yet!";
261 my ($self, $label) = @_;
262 return '' unless defined $label;
263 return "*" if $label eq '*';
264 return $label unless $self->{quote_char};
265 if(ref $self->{quote_char} eq "ARRAY"){
266 return $self->{quote_char}->[0] . $label . $self->{quote_char}->[1]
267 if !defined $self->{name_sep};
268 my $sep = $self->{name_sep};
269 return join($self->{name_sep},
270 map { $self->{quote_char}->[0] . $_ . $self->{quote_char}->[1] }
271 split(/\Q$sep\E/,$label));
273 return $self->SUPER::_quote($label);
278 $self->{limit_dialect} = shift if @_;
279 return $self->{limit_dialect};
284 $self->{quote_char} = shift if @_;
285 return $self->{quote_char};
290 $self->{name_sep} = shift if @_;
291 return $self->{name_sep};
294 } # End of BEGIN block
298 DBIx::Class::Storage::DBI - DBI storage handler
304 This class represents the connection to an RDBMS via L<DBI>. See
305 L<DBIx::Class::Storage> for general information. This pod only
306 documents DBI-specific methods and behaviors.
313 my $new = shift->next::method(@_);
315 $new->cursor("DBIx::Class::Storage::DBI::Cursor");
316 $new->transaction_depth(0);
317 $new->_sql_maker_opts({});
318 $new->{_in_dbh_do} = 0;
319 $new->{_dbh_gen} = 0;
326 The arguments of C<connect_info> are always a single array reference.
328 This is normally accessed via L<DBIx::Class::Schema/connection>, which
329 encapsulates its argument list in an arrayref before calling
330 C<connect_info> here.
332 The arrayref can either contain the same set of arguments one would
333 normally pass to L<DBI/connect>, or a lone code reference which returns
334 a connected database handle. Please note that the L<DBI> docs
335 recommend that you always explicitly set C<AutoCommit> to either
336 C<0> or C<1>. L<DBIx::Class> further recommends that it be set
337 to C<1>, and that you perform transactions via our L</txn_do>
338 method. L<DBIx::Class> will emit a warning if you fail to explicitly
339 set C<AutoCommit> one way or the other. See below for more details.
341 In either case, if the final argument in your connect_info happens
342 to be a hashref, C<connect_info> will look there for several
343 connection-specific options:
349 This can be set to an arrayref of literal sql statements, which will
350 be executed immediately after making the connection to the database
351 every time we [re-]connect.
353 =item disable_sth_caching
355 If set to a true value, this option will disable the caching of
356 statement handles via L<DBI/prepare_cached>.
360 Sets the limit dialect. This is useful for JDBC-bridge among others
361 where the remote SQL-dialect cannot be determined by the name of the
366 Specifies what characters to use to quote table and column names. If
367 you use this you will want to specify L<name_sep> as well.
369 quote_char expects either a single character, in which case is it is placed
370 on either side of the table/column, or an arrayref of length 2 in which case the
371 table/column name is placed between the elements.
373 For example under MySQL you'd use C<quote_char =E<gt> '`'>, and user SQL Server you'd
374 use C<quote_char =E<gt> [qw/[ ]/]>.
378 This only needs to be used in conjunction with L<quote_char>, and is used to
379 specify the charecter that seperates elements (schemas, tables, columns) from
380 each other. In most cases this is simply a C<.>.
384 These options can be mixed in with your other L<DBI> connection attributes,
385 or placed in a seperate hashref after all other normal L<DBI> connection
388 Every time C<connect_info> is invoked, any previous settings for
389 these options will be cleared before setting the new ones, regardless of
390 whether any options are specified in the new C<connect_info>.
392 Important note: DBIC expects the returned database handle provided by
393 a subref argument to have RaiseError set on it. If it doesn't, things
394 might not work very well, YMMV. If you don't use a subref, DBIC will
395 force this setting for you anyways. Setting HandleError to anything
396 other than simple exception object wrapper might cause problems too.
398 Another Important Note:
400 DBIC can do some wonderful magic with handling exceptions,
401 disconnections, and transactions when you use C<AutoCommit => 1>
402 combined with C<txn_do> for transaction support.
404 If you set C<AutoCommit => 0> in your connect info, then you are always
405 in an assumed transaction between commits, and you're telling us you'd
406 like to manage that manually. A lot of DBIC's magic protections
407 go away. We can't protect you from exceptions due to database
408 disconnects because we don't know anything about how to restart your
409 transactions. You're on your own for handling all sorts of exceptional
410 cases if you choose the C<AutoCommit => 0> path, just as you would
415 # Simple SQLite connection
416 ->connect_info([ 'dbi:SQLite:./foo.db' ]);
419 ->connect_info([ sub { DBI->connect(...) } ]);
421 # A bit more complicated
428 { quote_char => q{"}, name_sep => q{.} },
432 # Equivalent to the previous example
438 { AutoCommit => 1, quote_char => q{"}, name_sep => q{.} },
442 # Subref + DBIC-specific connection options
445 sub { DBI->connect(...) },
449 on_connect_do => ['SET search_path TO myschema,otherschema,public'],
450 disable_sth_caching => 1,
458 my ($self, $info_arg) = @_;
460 return $self->_connect_info if !$info_arg;
462 # Kill sql_maker/_sql_maker_opts, so we get a fresh one with only
463 # the new set of options
464 $self->_sql_maker(undef);
465 $self->_sql_maker_opts({});
467 my $info = [ @$info_arg ]; # copy because we can alter it
468 my $last_info = $info->[-1];
469 if(ref $last_info eq 'HASH') {
470 for my $storage_opt (qw/on_connect_do disable_sth_caching/) {
471 if(my $value = delete $last_info->{$storage_opt}) {
472 $self->$storage_opt($value);
475 for my $sql_maker_opt (qw/limit_dialect quote_char name_sep/) {
476 if(my $opt_val = delete $last_info->{$sql_maker_opt}) {
477 $self->_sql_maker_opts->{$sql_maker_opt} = $opt_val;
481 # Get rid of any trailing empty hashref
482 pop(@$info) if !keys %$last_info;
485 # Now check the (possibly new) final argument for AutoCommit,
486 # but not in the coderef case, obviously.
487 if(ref $info->[0] ne 'CODE') {
488 $last_info = $info->[3];
489 warn "You *really* should explicitly set AutoCommit "
490 . "(preferably to 1) in your db connect info"
492 || ref $last_info ne 'HASH'
493 || !defined $last_info->{AutoCommit};
496 $self->_connect_info($info);
501 This method is deprecated in favor of setting via L</connect_info>.
505 Arguments: $subref, @extra_coderef_args?
507 Execute the given subref using the new exception-based connection management.
509 The first two arguments will be the storage object that C<dbh_do> was called
510 on and a database handle to use. Any additional arguments will be passed
511 verbatim to the called subref as arguments 2 and onwards.
513 Using this (instead of $self->_dbh or $self->dbh) ensures correct
514 exception handling and reconnection (or failover in future subclasses).
516 Your subref should have no side-effects outside of the database, as
517 there is the potential for your subref to be partially double-executed
518 if the database connection was stale/dysfunctional.
522 my @stuff = $schema->storage->dbh_do(
524 my ($storage, $dbh, @cols) = @_;
525 my $cols = join(q{, }, @cols);
526 $dbh->selectrow_array("SELECT $cols FROM foo");
537 ref $coderef eq 'CODE' or $self->throw_exception
538 ('$coderef must be a CODE reference');
540 return $coderef->($self, $self->_dbh, @_) if $self->{_in_dbh_do}
541 || $self->{transaction_depth};
543 local $self->{_in_dbh_do} = 1;
546 my $want_array = wantarray;
549 $self->_verify_pid if $self->_dbh;
550 $self->_populate_dbh if !$self->_dbh;
552 @result = $coderef->($self, $self->_dbh, @_);
554 elsif(defined $want_array) {
555 $result[0] = $coderef->($self, $self->_dbh, @_);
558 $coderef->($self, $self->_dbh, @_);
563 if(!$exception) { return $want_array ? @result : $result[0] }
565 $self->throw_exception($exception) if $self->connected;
567 # We were not connected - reconnect and retry, but let any
568 # exception fall right through this time
569 $self->_populate_dbh;
570 $coderef->($self, $self->_dbh, @_);
573 # This is basically a blend of dbh_do above and DBIx::Class::Storage::txn_do.
574 # It also informs dbh_do to bypass itself while under the direction of txn_do,
575 # via $self->{_in_dbh_do} (this saves some redundant eval and errorcheck, etc)
580 ref $coderef eq 'CODE' or $self->throw_exception
581 ('$coderef must be a CODE reference');
583 local $self->{_in_dbh_do} = 1;
586 my $want_array = wantarray;
591 $self->_verify_pid if $self->_dbh;
592 $self->_populate_dbh if !$self->_dbh;
596 @result = $coderef->(@_);
598 elsif(defined $want_array) {
599 $result[0] = $coderef->(@_);
608 if(!$exception) { return $want_array ? @result : $result[0] }
610 if($tried++ > 0 || $self->connected) {
611 eval { $self->txn_rollback };
612 my $rollback_exception = $@;
613 if($rollback_exception) {
614 my $exception_class = "DBIx::Class::Storage::NESTED_ROLLBACK_EXCEPTION";
615 $self->throw_exception($exception) # propagate nested rollback
616 if $rollback_exception =~ /$exception_class/;
618 $self->throw_exception(
619 "Transaction aborted: ${exception}. "
620 . "Rollback failed: ${rollback_exception}"
623 $self->throw_exception($exception)
626 # We were not connected, and was first try - reconnect and retry
628 $self->_populate_dbh;
634 Our C<disconnect> method also performs a rollback first if the
635 database is not in C<AutoCommit> mode.
642 if( $self->connected ) {
643 $self->_dbh->rollback unless $self->_dbh->{AutoCommit};
644 $self->_dbh->disconnect;
653 if(my $dbh = $self->_dbh) {
654 if(defined $self->_conn_tid && $self->_conn_tid != threads->tid) {
662 return ($dbh->FETCH('Active') && $dbh->ping);
668 # handle pid changes correctly
669 # NOTE: assumes $self->_dbh is a valid $dbh
673 return if $self->_conn_pid == $$;
675 $self->_dbh->{InactiveDestroy} = 1;
682 sub ensure_connected {
685 unless ($self->connected) {
686 $self->_populate_dbh;
692 Returns the dbh - a data base handle of class L<DBI>.
699 $self->ensure_connected;
703 sub _sql_maker_args {
706 return ( bindtype=>'columns', limit_dialect => $self->dbh, %{$self->_sql_maker_opts} );
711 unless ($self->_sql_maker) {
712 $self->_sql_maker(new DBIC::SQL::Abstract( $self->_sql_maker_args ));
714 return $self->_sql_maker;
719 my @info = @{$self->_connect_info || []};
720 $self->_dbh($self->_connect(@info));
722 # Always set the transaction depth on connect, since
723 # there is no transaction in progress by definition
724 $self->{transaction_depth} = $self->_dbh->{AutoCommit} ? 0 : 1;
726 if(ref $self eq 'DBIx::Class::Storage::DBI') {
727 my $driver = $self->_dbh->{Driver}->{Name};
728 if ($self->load_optional_class("DBIx::Class::Storage::DBI::${driver}")) {
729 bless $self, "DBIx::Class::Storage::DBI::${driver}";
730 $self->_rebless() if $self->can('_rebless');
734 # if on-connect sql statements are given execute them
735 foreach my $sql_statement (@{$self->on_connect_do || []}) {
736 $self->debugobj->query_start($sql_statement) if $self->debug();
737 $self->_dbh->do($sql_statement);
738 $self->debugobj->query_end($sql_statement) if $self->debug();
741 $self->_conn_pid($$);
742 $self->_conn_tid(threads->tid) if $INC{'threads.pm'};
746 my ($self, @info) = @_;
748 $self->throw_exception("You failed to provide any connection info")
751 my ($old_connect_via, $dbh);
753 if ($INC{'Apache/DBI.pm'} && $ENV{MOD_PERL}) {
754 $old_connect_via = $DBI::connect_via;
755 $DBI::connect_via = 'connect';
759 if(ref $info[0] eq 'CODE') {
763 $dbh = DBI->connect(@info);
764 $dbh->{RaiseError} = 1;
765 $dbh->{PrintError} = 0;
766 $dbh->{PrintWarn} = 0;
770 $DBI::connect_via = $old_connect_via if $old_connect_via;
773 $self->throw_exception("DBI Connection failed: " . ($@ || $DBI::errstr));
782 if($self->{transaction_depth}++ == 0) {
783 $self->debugobj->txn_begin()
785 # this isn't ->_dbh-> because
786 # we should reconnect on begin_work
787 # for AutoCommit users
788 $self->dbh->begin_work;
794 if ($self->{transaction_depth} == 1) {
795 my $dbh = $self->_dbh;
796 $self->debugobj->txn_commit()
799 $self->{transaction_depth} = 0
800 if $dbh->{AutoCommit};
802 elsif($self->{transaction_depth} > 1) {
803 $self->{transaction_depth}--
809 my $dbh = $self->_dbh;
812 $autocommit = $dbh->{AutoCommit};
813 if ($self->{transaction_depth} == 1) {
814 $self->debugobj->txn_rollback()
817 $self->{transaction_depth} = 0
820 elsif($self->{transaction_depth} > 1) {
821 $self->{transaction_depth}--;
824 die DBIx::Class::Storage::NESTED_ROLLBACK_EXCEPTION->new;
829 my $exception_class = "DBIx::Class::Storage::NESTED_ROLLBACK_EXCEPTION";
830 $error =~ /$exception_class/ and $self->throw_exception($error);
831 # ensure that a failed rollback resets the transaction depth
832 $self->{transaction_depth} = $autocommit ? 0 : 1;
833 $self->throw_exception($error);
837 # This used to be the top-half of _execute. It was split out to make it
838 # easier to override in NoBindVars without duping the rest. It takes up
839 # all of _execute's args, and emits $sql, @bind.
840 sub _prep_for_execute {
841 my ($self, $op, $extra_bind, $ident, @args) = @_;
843 my ($sql, @bind) = $self->sql_maker->$op($ident, @args);
845 map { ref $_ eq 'ARRAY' ? $_ : [ '!!dummy', $_ ] } @$extra_bind)
847 @bind = map { ref $_ ? ''.$_ : $_ } @bind; # stringify args
849 return ($sql, @bind);
853 my ($self, $op, $extra_bind, $ident, $bind_attributes, @args) = @_;
855 if( blessed($ident) && $ident->isa("DBIx::Class::ResultSource") ) {
856 $ident = $ident->from();
859 my ($sql, @bind) = $self->sql_maker->$op($ident, @args);
861 map { ref $_ eq 'ARRAY' ? $_ : [ '!!dummy', $_ ] } @$extra_bind)
865 map { defined ($_ && $_->[1]) ? qq{'$_->[1]'} : q{'NULL'} } @bind;
866 $self->debugobj->query_start($sql, @debug_bind);
871 $sth = eval { $self->sth($sql,$op) };
874 $self->throw_exception(
875 'no sth generated via sql (' . ($@ || $self->_dbh->errstr) . "): $sql"
882 my $placeholder_index = 1;
884 foreach my $bound (@bind) {
887 my($column_name, @data) = @$bound;
889 if( $bind_attributes ) {
890 $attributes = $bind_attributes->{$column_name}
891 if defined $bind_attributes->{$column_name};
894 foreach my $data (@data)
896 $data = ref $data ? ''.$data : $data; # stringify args
898 $sth->bind_param($placeholder_index, $data, $attributes);
899 $placeholder_index++;
906 $self->throw_exception("Error executing '$sql': ".($@ || $sth->errstr))
908 $self->_populate_dbh;
913 $self->throw_exception("'$sql' did not generate a statement.");
915 } # While(1) to retry if disconencted
919 map { defined ($_ && $_->[1]) ? qq{'$_->[1]'} : q{'NULL'} } @bind;
920 $self->debugobj->query_end($sql, @debug_bind);
922 return (wantarray ? ($rv, $sth, @bind) : $rv);
926 my ($self, $source, $to_insert) = @_;
928 my $ident = $source->from;
929 my $bind_attributes = $self->source_bind_attributes($source);
931 $self->throw_exception(
932 "Couldn't insert ".join(', ',
933 map "$_ => $to_insert->{$_}", keys %$to_insert
935 ) unless ($self->_execute('insert' => [], $source, $bind_attributes, $to_insert));
939 ## Still not quite perfect, and EXPERIMENTAL
940 ## Currently it is assumed that all values passed will be "normal", i.e. not
941 ## scalar refs, or at least, all the same type as the first set, the statement is
942 ## only prepped once.
944 my ($self, $source, $cols, $data) = @_;
946 my $table = $source->from;
947 @colvalues{@$cols} = (0..$#$cols);
948 my ($sql, @bind) = $self->sql_maker->insert($table, \%colvalues);
951 my @debug_bind = map { defined $_->[1] ? qq{$_->[1]} : q{'NULL'} } @bind;
952 $self->debugobj->query_start($sql, @debug_bind);
954 my $sth = $self->sth($sql);
956 # @bind = map { ref $_ ? ''.$_ : $_ } @bind; # stringify args
960 ## This must be an arrayref, else nothing works!
962 my $tuple_status = [];
965 ##print STDERR Dumper( $data, $sql, [@bind] );
971 ## Get the bind_attributes, if any exist
972 my $bind_attributes = $self->source_bind_attributes($source);
974 ## Bind the values and execute
977 my $placeholder_index = 1;
979 foreach my $bound (@bind) {
982 my ($column_name, $data_index) = @$bound;
984 if( $bind_attributes ) {
985 $attributes = $bind_attributes->{$column_name}
986 if defined $bind_attributes->{$column_name};
989 my @data = map { $_->[$data_index] } @$data;
991 $sth->bind_param_array( $placeholder_index, [@data], $attributes );
992 $placeholder_index++;
994 $sth->execute_array( {ArrayTupleStatus => $tuple_status} );
998 if ($@ || !defined $rv) {
1000 foreach my $tuple (@$tuple_status) {
1001 $errors .= "\n" . $tuple->[1] if(ref $tuple);
1003 $self->throw_exception("Error executing '$sql': ".($@ || $errors));
1006 $self->throw_exception("'$sql' did not generate a statement.");
1009 my @debug_bind = map { defined $_ ? qq{`$_'} : q{`NULL'} } @bind;
1010 $self->debugobj->query_end($sql, @debug_bind);
1012 return (wantarray ? ($rv, $sth, @bind) : $rv);
1016 my $self = shift @_;
1017 my $source = shift @_;
1018 my $bind_attributes = $self->source_bind_attributes($source);
1020 return $self->_execute('update' => [], $source, $bind_attributes, @_);
1025 my $self = shift @_;
1026 my $source = shift @_;
1028 my $bind_attrs = {}; ## If ever it's needed...
1030 return $self->_execute('delete' => [], $source, $bind_attrs, @_);
1034 my ($self, $ident, $select, $condition, $attrs) = @_;
1035 my $order = $attrs->{order_by};
1036 if (ref $condition eq 'SCALAR') {
1037 $order = $1 if $$condition =~ s/ORDER BY (.*)$//i;
1039 if (exists $attrs->{group_by} || $attrs->{having}) {
1041 group_by => $attrs->{group_by},
1042 having => $attrs->{having},
1043 ($order ? (order_by => $order) : ())
1046 my $bind_attrs = {}; ## Future support
1047 my @args = ('select', $attrs->{bind}, $ident, $bind_attrs, $select, $condition, $order);
1048 if ($attrs->{software_limit} ||
1049 $self->sql_maker->_default_limit_syntax eq "GenericSubQ") {
1050 $attrs->{software_limit} = 1;
1052 $self->throw_exception("rows attribute must be positive if present")
1053 if (defined($attrs->{rows}) && !($attrs->{rows} > 0));
1054 push @args, $attrs->{rows}, $attrs->{offset};
1056 return $self->_execute(@args);
1059 sub source_bind_attributes {
1060 my ($self, $source) = @_;
1062 my $bind_attributes;
1063 foreach my $column ($source->columns) {
1065 my $data_type = $source->column_info($column)->{data_type} || '';
1066 $bind_attributes->{$column} = $self->bind_attribute_by_data_type($data_type)
1070 return $bind_attributes;
1077 =item Arguments: $ident, $select, $condition, $attrs
1081 Handle a SQL select statement.
1087 my ($ident, $select, $condition, $attrs) = @_;
1088 return $self->cursor->new($self, \@_, $attrs);
1093 my ($rv, $sth, @bind) = $self->_select(@_);
1094 my @row = $sth->fetchrow_array;
1095 # Need to call finish() to work round broken DBDs
1104 =item Arguments: $sql
1108 Returns a L<DBI> sth (statement handle) for the supplied SQL.
1113 my ($self, $dbh, $sql) = @_;
1115 # 3 is the if_active parameter which avoids active sth re-use
1116 my $sth = $self->disable_sth_caching
1117 ? $dbh->prepare($sql)
1118 : $dbh->prepare_cached($sql, {}, 3);
1120 $self->throw_exception(
1121 'no sth generated via sql (' . ($@ || $dbh->errstr) . "): $sql"
1128 my ($self, $sql) = @_;
1129 $self->dbh_do($self->can('_dbh_sth'), $sql);
1132 sub _dbh_columns_info_for {
1133 my ($self, $dbh, $table) = @_;
1135 if ($dbh->can('column_info')) {
1138 my ($schema,$tab) = $table =~ /^(.+?)\.(.+)$/ ? ($1,$2) : (undef,$table);
1139 my $sth = $dbh->column_info( undef,$schema, $tab, '%' );
1141 while ( my $info = $sth->fetchrow_hashref() ){
1143 $column_info{data_type} = $info->{TYPE_NAME};
1144 $column_info{size} = $info->{COLUMN_SIZE};
1145 $column_info{is_nullable} = $info->{NULLABLE} ? 1 : 0;
1146 $column_info{default_value} = $info->{COLUMN_DEF};
1147 my $col_name = $info->{COLUMN_NAME};
1148 $col_name =~ s/^\"(.*)\"$/$1/;
1150 $result{$col_name} = \%column_info;
1153 return \%result if !$@ && scalar keys %result;
1157 my $sth = $dbh->prepare($self->sql_maker->select($table, undef, \'1 = 0'));
1159 my @columns = @{$sth->{NAME_lc}};
1160 for my $i ( 0 .. $#columns ){
1162 $column_info{data_type} = $sth->{TYPE}->[$i];
1163 $column_info{size} = $sth->{PRECISION}->[$i];
1164 $column_info{is_nullable} = $sth->{NULLABLE}->[$i] ? 1 : 0;
1166 if ($column_info{data_type} =~ m/^(.*?)\((.*?)\)$/) {
1167 $column_info{data_type} = $1;
1168 $column_info{size} = $2;
1171 $result{$columns[$i]} = \%column_info;
1175 foreach my $col (keys %result) {
1176 my $colinfo = $result{$col};
1177 my $type_num = $colinfo->{data_type};
1179 if(defined $type_num && $dbh->can('type_info')) {
1180 my $type_info = $dbh->type_info($type_num);
1181 $type_name = $type_info->{TYPE_NAME} if $type_info;
1182 $colinfo->{data_type} = $type_name if $type_name;
1189 sub columns_info_for {
1190 my ($self, $table) = @_;
1191 $self->dbh_do($self->can('_dbh_columns_info_for'), $table);
1194 =head2 last_insert_id
1196 Return the row id of the last insert.
1200 sub _dbh_last_insert_id {
1201 my ($self, $dbh, $source, $col) = @_;
1202 # XXX This is a SQLite-ism as a default... is there a DBI-generic way?
1203 $dbh->func('last_insert_rowid');
1206 sub last_insert_id {
1208 $self->dbh_do($self->can('_dbh_last_insert_id'), @_);
1213 Returns the database driver name.
1217 sub sqlt_type { shift->dbh->{Driver}->{Name} }
1219 =head2 bind_attribute_by_data_type
1221 Given a datatype from column info, returns a database specific bind attribute for
1222 $dbh->bind_param($val,$attribute) or nothing if we will let the database planner
1225 Generally only needed for special case column types, like bytea in postgres.
1229 sub bind_attribute_by_data_type {
1233 =head2 create_ddl_dir (EXPERIMENTAL)
1237 =item Arguments: $schema \@databases, $version, $directory, $preversion, $sqlt_args
1241 Creates a SQL file based on the Schema, for each of the specified
1242 database types, in the given directory.
1244 Note that this feature is currently EXPERIMENTAL and may not work correctly
1245 across all databases, or fully handle complex relationships.
1251 my ($self, $schema, $databases, $version, $dir, $preversion, $sqltargs) = @_;
1253 if(!$dir || !-d $dir)
1255 warn "No directory given, using ./\n";
1258 $databases ||= ['MySQL', 'SQLite', 'PostgreSQL'];
1259 $databases = [ $databases ] if(ref($databases) ne 'ARRAY');
1260 $version ||= $schema->VERSION || '1.x';
1261 $sqltargs = { ( add_drop_table => 1 ), %{$sqltargs || {}} };
1263 eval "use SQL::Translator";
1264 $self->throw_exception("Can't create a ddl file without SQL::Translator: $@") if $@;
1266 my $sqlt = SQL::Translator->new({
1268 add_drop_table => 1,
1270 foreach my $db (@$databases)
1273 $sqlt->parser('SQL::Translator::Parser::DBIx::Class');
1274 # $sqlt->parser_args({'DBIx::Class' => $schema);
1275 $sqlt = $self->configure_sqlt($sqlt, $db);
1276 $sqlt->data($schema);
1277 $sqlt->producer($db);
1280 my $filename = $schema->ddl_filename($db, $dir, $version);
1283 warn("$filename already exists, skipping $db");
1287 my $output = $sqlt->translate;
1290 warn("Failed to translate to $db, skipping. (" . $sqlt->error . ")");
1293 if(!open($file, ">$filename"))
1295 $self->throw_exception("Can't open $filename for writing ($!)");
1298 print $file $output;
1303 eval "use SQL::Translator::Diff";
1306 warn("Can't diff versions without SQL::Translator::Diff: $@");
1310 my $prefilename = $schema->ddl_filename($db, $dir, $preversion);
1311 # print "Previous version $prefilename\n";
1312 if(!-e $prefilename)
1314 warn("No previous schema file found ($prefilename)");
1317 #### We need to reparse the SQLite file we just wrote, so that
1318 ## Diff doesnt get all confoosed, and Diff is *very* confused.
1319 ## FIXME: rip Diff to pieces!
1320 # my $target_schema = $sqlt->schema;
1321 # unless ( $target_schema->name ) {
1322 # $target_schema->name( $filename );
1325 push @input, {file => $prefilename, parser => $db};
1326 push @input, {file => $filename, parser => $db};
1327 my ( $source_schema, $source_db, $target_schema, $target_db ) = map {
1328 my $file = $_->{'file'};
1329 my $parser = $_->{'parser'};
1331 my $t = SQL::Translator->new;
1334 $t->parser( $parser ) or die $t->error;
1335 my $out = $t->translate( $file ) or die $t->error;
1336 my $schema = $t->schema;
1337 unless ( $schema->name ) {
1338 $schema->name( $file );
1343 my $diff = SQL::Translator::Diff::schema_diff($source_schema, $db,
1344 $target_schema, $db,
1347 my $difffile = $schema->ddl_filename($db, $dir, $version, $preversion);
1348 print STDERR "Diff: $difffile: $db, $dir, $version, $preversion \n";
1351 warn("$difffile already exists, skipping");
1354 if(!open $file, ">$difffile")
1356 $self->throw_exception("Can't write to $difffile ($!)");
1365 sub configure_sqlt() {
1368 my $db = shift || $self->sqlt_type;
1369 if ($db eq 'PostgreSQL') {
1370 $tr->quote_table_names(0);
1371 $tr->quote_field_names(0);
1376 =head2 deployment_statements
1380 =item Arguments: $schema, $type, $version, $directory, $sqlt_args
1384 Returns the statements used by L</deploy> and L<DBIx::Class::Schema/deploy>.
1385 The database driver name is given by C<$type>, though the value from
1386 L</sqlt_type> is used if it is not specified.
1388 C<$directory> is used to return statements from files in a previously created
1389 L</create_ddl_dir> directory and is optional. The filenames are constructed
1390 from L<DBIx::Class::Schema/ddl_filename>, the schema name and the C<$version>.
1392 If no C<$directory> is specified then the statements are constructed on the
1393 fly using L<SQL::Translator> and C<$version> is ignored.
1395 See L<SQL::Translator/METHODS> for a list of values for C<$sqlt_args>.
1399 sub deployment_statements {
1400 my ($self, $schema, $type, $version, $dir, $sqltargs) = @_;
1401 # Need to be connected to get the correct sqlt_type
1402 $self->ensure_connected() unless $type;
1403 $type ||= $self->sqlt_type;
1404 $version ||= $schema->VERSION || '1.x';
1406 my $filename = $schema->ddl_filename($type, $dir, $version);
1410 open($file, "<$filename")
1411 or $self->throw_exception("Can't open $filename ($!)");
1414 return join('', @rows);
1417 eval "use SQL::Translator";
1420 eval "use SQL::Translator::Parser::DBIx::Class;";
1421 $self->throw_exception($@) if $@;
1422 eval "use SQL::Translator::Producer::${type};";
1423 $self->throw_exception($@) if $@;
1425 # sources needs to be a parser arg, but for simplicty allow at top level
1427 $sqltargs->{parser_args}{sources} = delete $sqltargs->{sources}
1428 if exists $sqltargs->{sources};
1430 my $tr = SQL::Translator->new(%$sqltargs);
1431 SQL::Translator::Parser::DBIx::Class::parse( $tr, $schema );
1432 return "SQL::Translator::Producer::${type}"->can('produce')->($tr);
1435 $self->throw_exception("No SQL::Translator, and no Schema file found, aborting deploy");
1441 my ($self, $schema, $type, $sqltargs, $dir) = @_;
1442 foreach my $statement ( $self->deployment_statements($schema, $type, undef, $dir, { no_comments => 1, %{ $sqltargs || {} } } ) ) {
1443 for ( split(";\n", $statement)) {
1444 next if($_ =~ /^--/);
1446 # next if($_ =~ /^DROP/m);
1447 next if($_ =~ /^BEGIN TRANSACTION/m);
1448 next if($_ =~ /^COMMIT/m);
1449 next if $_ =~ /^\s+$/; # skip whitespace only
1450 $self->debugobj->query_start($_) if $self->debug;
1451 $self->dbh->do($_) or warn "SQL was:\n $_"; # XXX exceptions?
1452 $self->debugobj->query_end($_) if $self->debug;
1457 =head2 datetime_parser
1459 Returns the datetime parser class
1463 sub datetime_parser {
1465 return $self->{datetime_parser} ||= $self->build_datetime_parser(@_);
1468 =head2 datetime_parser_type
1470 Defines (returns) the datetime parser class - currently hardwired to
1471 L<DateTime::Format::MySQL>
1475 sub datetime_parser_type { "DateTime::Format::MySQL"; }
1477 =head2 build_datetime_parser
1479 See L</datetime_parser>
1483 sub build_datetime_parser {
1485 my $type = $self->datetime_parser_type(@_);
1487 $self->throw_exception("Couldn't load ${type}: $@") if $@;
1493 return if !$self->_dbh;
1502 The module defines a set of methods within the DBIC::SQL::Abstract
1503 namespace. These build on L<SQL::Abstract::Limit> to provide the
1504 SQL query functions.
1506 The following methods are extended:-
1520 See L</connect_info> for details.
1521 For setting, this method is deprecated in favor of L</connect_info>.
1525 See L</connect_info> for details.
1526 For setting, this method is deprecated in favor of L</connect_info>.
1530 See L</connect_info> for details.
1531 For setting, this method is deprecated in favor of L</connect_info>.
1537 Matt S. Trout <mst@shadowcatsystems.co.uk>
1539 Andy Grundman <andy@hybridized.org>
1543 You may distribute this code under the same terms as Perl itself.