X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FDBIx%2FClass%2FStorage%2FDBI.pm;h=ded90f52ef4369b855a7d0e8d94ab1590ed7e918;hb=8fcf21b3a6e010f16ff278b9170a14a0858da388;hp=7cf09e6db638065175db22f6fb02c06ec7e87656;hpb=6157db4fe181ba8dbd4518aed34b8f9141083418;p=dbsrgits%2FDBIx-Class.git diff --git a/lib/DBIx/Class/Storage/DBI.pm b/lib/DBIx/Class/Storage/DBI.pm index 7cf09e6..ded90f5 100644 --- a/lib/DBIx/Class/Storage/DBI.pm +++ b/lib/DBIx/Class/Storage/DBI.pm @@ -1,5 +1,7 @@ package DBIx::Class::Storage::DBI; +use base 'DBIx::Class::Storage'; + use strict; use warnings; use DBI; @@ -17,8 +19,10 @@ use base qw/SQL::Abstract::Limit/; sub select { my ($self, $table, $fields, $where, $order, @rest) = @_; @rest = (-1) unless defined $rest[0]; - $self->SUPER::select($table, $self->_recurse_fields($fields), - $where, $order, @rest); + local $self->{having_bind} = []; + my ($sql, @ret) = $self->SUPER::select($table, + $self->_recurse_fields($fields), $where, $order, @rest); + return wantarray ? ($sql, @ret, @{$self->{having_bind}}) : $sql; } sub _emulate_limit { @@ -49,20 +53,35 @@ sub _recurse_fields { sub _order_by { my $self = shift; my $ret = ''; + my @extra; if (ref $_[0] eq 'HASH') { if (defined $_[0]->{group_by}) { $ret = $self->_sqlcase(' group by ') .$self->_recurse_fields($_[0]->{group_by}); } + if (defined $_[0]->{having}) { + my $frag; + ($frag, @extra) = $self->_recurse_where($_[0]->{having}); + push(@{$self->{having_bind}}, @extra); + $ret .= $self->_sqlcase(' having ').$frag; + } if (defined $_[0]->{order_by}) { $ret .= $self->SUPER::_order_by($_[0]->{order_by}); } + } elsif(ref $_[0] eq 'SCALAR') { + $ret = $self->_sqlcase(' order by ').${ $_[0] }; } else { $ret = $self->SUPER::_order_by(@_); } return $ret; } +sub _order_directions { + my ($self, $order) = @_; + $order = $order->{order_by} if ref $order eq 'HASH'; + return $self->SUPER::_order_directions($order); +} + sub _table { my ($self, $from) = @_; if (ref $from eq 'ARRAY') { @@ -130,9 +149,27 @@ sub _join_condition { sub _quote { my ($self, $label) = @_; return '' unless defined $label; + return "*" if $label eq '*'; + return $label unless $self->{quote_char}; + if(ref $self->{quote_char} eq "ARRAY"){ + return $self->{quote_char}->[0] . $label . $self->{quote_char}->[1] + if !defined $self->{name_sep}; + my $sep = $self->{name_sep}; + return join($self->{name_sep}, + map { $self->{quote_char}->[0] . $_ . $self->{quote_char}->[1] } + split(/\Q$sep\E/,$label)); + } return $self->SUPER::_quote($label); } +sub _RowNum { + my $self = shift; + my $c; + $_[0] =~ s/SELECT (.*?) FROM/ + 'SELECT '.join(', ', map { $_.' AS col'.++$c } split(', ', $1)).' FROM'/e; + $self->SUPER::_RowNum(@_); +} + # Accessor for setting limit dialect. This is useful # for JDBC-bridge among others where the remote SQL-dialect cannot # be determined by the name of the driver alone. @@ -143,14 +180,38 @@ sub limit_dialect { return $self->{limit_dialect}; } +sub quote_char { + my $self = shift; + $self->{quote_char} = shift if @_; + return $self->{quote_char}; +} + +sub name_sep { + my $self = shift; + $self->{name_sep} = shift if @_; + return $self->{name_sep}; +} + + + + +package DBIx::Class::Storage::DBI::DebugCallback; + +sub print { + my ($self, $string) = @_; + $string =~ m/^(\w+)/; + ${$self}->($1, $string); +} + } # End of BEGIN block use base qw/DBIx::Class/; -__PACKAGE__->load_components(qw/Exception AccessorGroup/); +__PACKAGE__->load_components(qw/AccessorGroup/); __PACKAGE__->mk_group_accessors('simple' => - qw/connect_info _dbh _sql_maker debug debugfh cursor on_connect_do transaction_depth/); + qw/connect_info _dbh _sql_maker _conn_pid _conn_tid debug debugfh + cursor on_connect_do transaction_depth/); sub new { my $new = bless({}, ref $_[0] || $_[0]); @@ -158,7 +219,7 @@ sub new { $new->transaction_depth(0); if (defined($ENV{DBIX_CLASS_STORAGE_DBI_DEBUG}) && ($ENV{DBIX_CLASS_STORAGE_DBI_DEBUG} =~ /=(.+)$/)) { - $new->debugfh(IO::File->new($1, 'w')||croak "Cannot open trace file $1"); + $new->debugfh(IO::File->new($1, 'w')) || $new->throw_exception("Cannot open trace file $1"); } else { $new->debugfh(IO::File->new('>&STDERR')); } @@ -166,6 +227,11 @@ sub new { return $new; } +sub throw_exception { + my ($self, $msg) = @_; + croak($msg); +} + =head1 NAME DBIx::Class::Storage::DBI - DBI storage handler @@ -196,19 +262,48 @@ should be an IO::Handle compatible object (only the C method is used). Initially set to be STDERR - although see information on the L environment variable. +=head2 debugcb + +Sets a callback to be executed each time a statement is run; takes a sub +reference. Overrides debugfh. Callback is executed as $sub->($op, $info) +where $op is SELECT/INSERT/UPDATE/DELETE and $info is what would normally +be printed. + =cut +sub debugcb { + my ($self, $cb) = @_; + my $cb_obj = bless(\$cb, 'DBIx::Class::Storage::DBI::DebugCallback'); + $self->debugfh($cb_obj); +} + sub disconnect { my ($self) = @_; - $self->_dbh->disconnect if $self->_dbh; + if( $self->connected ) { + $self->_dbh->rollback unless $self->_dbh->{AutoCommit}; + $self->_dbh->disconnect; + $self->_dbh(undef); + } } sub connected { my ($self) = @_; - my $dbh; - (($dbh = $self->_dbh) && $dbh->FETCH('Active') && $dbh->ping) + if(my $dbh = $self->_dbh) { + if(defined $self->_conn_tid && $self->_conn_tid != threads->tid) { + $self->_sql_maker(undef); + return $self->_dbh(undef); + } + elsif($self->_conn_pid != $$) { + $self->_dbh->{InactiveDestroy} = 1; + $self->_sql_maker(undef); + return $self->_dbh(undef) + } + return ($dbh->FETCH('Active') && $dbh->ping); + } + + return 0; } sub ensure_connected { @@ -238,27 +333,61 @@ sub _populate_dbh { my ($self) = @_; my @info = @{$self->connect_info || []}; $self->_dbh($self->_connect(@info)); - + my $driver = $self->_dbh->{Driver}->{Name}; + eval "require DBIx::Class::Storage::DBI::${driver}"; + unless ($@) { + bless $self, "DBIx::Class::Storage::DBI::${driver}"; + } # if on-connect sql statements are given execute them foreach my $sql_statement (@{$self->on_connect_do || []}) { $self->_dbh->do($sql_statement); } + + $self->_conn_pid($$); + $self->_conn_tid(threads->tid) if $INC{'threads.pm'}; } sub _connect { my ($self, @info) = @_; - return DBI->connect(@info); + + $self->throw_exception("You failed to provide any connection info") + if !@info; + + my ($old_connect_via, $dbh); + + if ($INC{'Apache/DBI.pm'} && $ENV{MOD_PERL}) { + $old_connect_via = $DBI::connect_via; + $DBI::connect_via = 'connect'; + } + + if(ref $info[0] eq 'CODE') { + $dbh = &{$info[0]}; + } + else { + $dbh = DBI->connect(@info); + } + + $DBI::connect_via = $old_connect_via if $old_connect_via; + + $self->throw_exception("DBI Connection failed: $DBI::errstr") + unless $dbh; + + $dbh; } =head2 txn_begin Calls begin_work on the current dbh. +See L for the txn_do() method, which allows for +an entire code block to be executed transactionally. + =cut sub txn_begin { my $self = shift; - $self->dbh->begin_work if $self->{transaction_depth}++ == 0 and $self->dbh->{AutoCommit}; + $self->dbh->begin_work + if $self->{transaction_depth}++ == 0 and $self->dbh->{AutoCommit}; } =head2 txn_commit @@ -279,17 +408,32 @@ sub txn_commit { =head2 txn_rollback -Issues a rollback against the current dbh. +Issues a rollback against the current dbh. A nested rollback will +throw a L exception, +which allows the rollback to propagate to the outermost transaction. =cut sub txn_rollback { my $self = shift; - if ($self->{transaction_depth} == 0) { - $self->dbh->rollback unless $self->dbh->{AutoCommit}; - } - else { - --$self->{transaction_depth} == 0 ? $self->dbh->rollback : die $@; + + eval { + if ($self->{transaction_depth} == 0) { + $self->dbh->rollback unless $self->dbh->{AutoCommit}; + } + else { + --$self->{transaction_depth} == 0 ? + $self->dbh->rollback : + die DBIx::Class::Storage::NESTED_ROLLBACK_EXCEPTION->new; + } + }; + + if ($@) { + my $error = $@; + my $exception_class = "DBIx::Class::Storage::NESTED_ROLLBACK_EXCEPTION"; + $error =~ /$exception_class/ and $self->throw_exception($error); + $self->{transaction_depth} = 0; # ensure that a failed rollback + $self->throw_exception($error); # resets the transaction depth } } @@ -297,21 +441,25 @@ sub _execute { my ($self, $op, $extra_bind, $ident, @args) = @_; my ($sql, @bind) = $self->sql_maker->$op($ident, @args); unshift(@bind, @$extra_bind) if $extra_bind; - $self->debugfh->print("$sql: @bind\n") if $self->debug; + if ($self->debug) { + my @debug_bind = map { defined $_ ? qq{`$_'} : q{`NULL'} } @bind; + $self->debugfh->print("$sql: " . join(', ', @debug_bind) . "\n"); + } my $sth = $self->sth($sql,$op); + $self->throw_exception("no sth generated via sql: $sql") unless $sth; @bind = map { ref $_ ? ''.$_ : $_ } @bind; # stringify args my $rv; if ($sth) { - $rv = $sth->execute(@bind); + $rv = $sth->execute(@bind) or $self->throw_exception("Error executing '$sql': " . $sth->errstr); } else { - croak "'$sql' did not generate a statement."; + $self->throw_exception("'$sql' did not generate a statement."); } return (wantarray ? ($rv, $sth, @bind) : $rv); } sub insert { my ($self, $ident, $to_insert) = @_; - croak( "Couldn't insert ".join(', ', map "$_ => $to_insert->{$_}", keys %$to_insert)." into ${ident}" ) + $self->throw_exception( "Couldn't insert ".join(', ', map "$_ => $to_insert->{$_}", keys %$to_insert)." into ${ident}" ) unless ($self->_execute('insert' => [], $ident, $to_insert)); return $to_insert; } @@ -330,8 +478,9 @@ sub _select { if (ref $condition eq 'SCALAR') { $order = $1 if $$condition =~ s/ORDER BY (.*)$//i; } - if (exists $attrs->{group_by}) { + if (exists $attrs->{group_by} || $attrs->{having}) { $order = { group_by => $attrs->{group_by}, + having => $attrs->{having}, ($order ? (order_by => $order) : ()) }; } my @args = ('select', $attrs->{bind}, $ident, $select, $condition, $order); @@ -374,28 +523,91 @@ Returns database type info for a given table columns. sub columns_info_for { my ($self, $table) = @_; + + if ($self->dbh->can('column_info')) { + my %result; + my $old_raise_err = $self->dbh->{RaiseError}; + my $old_print_err = $self->dbh->{PrintError}; + $self->dbh->{RaiseError} = 1; + $self->dbh->{PrintError} = 0; + eval { + my $sth = $self->dbh->column_info( undef, undef, $table, '%' ); + $sth->execute(); + while ( my $info = $sth->fetchrow_hashref() ){ + my %column_info; + $column_info{data_type} = $info->{TYPE_NAME}; + $column_info{size} = $info->{COLUMN_SIZE}; + $column_info{is_nullable} = $info->{NULLABLE} ? 1 : 0; + $column_info{default_value} = $info->{COLUMN_DEF}; + + $result{$info->{COLUMN_NAME}} = \%column_info; + } + }; + $self->dbh->{RaiseError} = $old_raise_err; + $self->dbh->{PrintError} = $old_print_err; + return \%result if !$@; + } + my %result; - if ( $self->dbh->can( 'column_info' ) ){ - my $sth = $self->dbh->column_info( undef, undef, $table, '%' ); - $sth->execute(); - while ( my $info = $sth->fetchrow_hashref() ){ - my %column_info; - $column_info{data_type} = $info->{TYPE_NAME}; - $column_info{size} = $info->{COLUMN_SIZE}; - $column_info{is_nullable} = $info->{NULLABLE}; - $result{$info->{COLUMN_NAME}} = \%column_info; + my $sth = $self->dbh->prepare("SELECT * FROM $table WHERE 1=0"); + $sth->execute; + my @columns = @{$sth->{NAME_lc}}; + for my $i ( 0 .. $#columns ){ + my %column_info; + my $type_num = $sth->{TYPE}->[$i]; + my $type_name; + if(defined $type_num && $self->dbh->can('type_info')) { + my $type_info = $self->dbh->type_info($type_num); + $type_name = $type_info->{TYPE_NAME} if $type_info; } - }else{ - my $sth = $self->dbh->prepare("SELECT * FROM $table WHERE 1=0"); - $sth->execute; - my @columns = @{$sth->{NAME}}; - for my $i ( 0 .. $#columns ){ - $result{$columns[$i]}{data_type} = $sth->{TYPE}->[$i]; + $column_info{data_type} = $type_name ? $type_name : $type_num; + $column_info{size} = $sth->{PRECISION}->[$i]; + $column_info{is_nullable} = $sth->{NULLABLE}->[$i] ? 1 : 0; + + if ($column_info{data_type} =~ m/^(.*?)\((.*?)\)$/) { + $column_info{data_type} = $1; + $column_info{size} = $2; } + + $result{$columns[$i]} = \%column_info; } + return \%result; } +sub last_insert_id { + my ($self, $row) = @_; + + return $self->dbh->func('last_insert_rowid'); + +} + +sub sqlt_type { shift->dbh->{Driver}->{Name} } + +sub deployment_statements { + my ($self, $schema, $type, $sqltargs) = @_; + $type ||= $self->sqlt_type; + eval "use SQL::Translator"; + $self->throw_exception("Can't deploy without SQL::Translator: $@") if $@; + eval "use SQL::Translator::Parser::DBIx::Class;"; + $self->throw_exception($@) if $@; + eval "use SQL::Translator::Producer::${type};"; + $self->throw_exception($@) if $@; + my $tr = SQL::Translator->new(%$sqltargs); + SQL::Translator::Parser::DBIx::Class::parse( $tr, $schema ); + return "SQL::Translator::Producer::${type}"->can('produce')->($tr); +} + +sub deploy { + my ($self, $schema, $type, $sqltargs) = @_; + foreach(split(";\n", $self->deployment_statements($schema, $type, $sqltargs))) { + $self->debugfh->print("$_\n") if $self->debug; + $self->dbh->do($_) or warn "SQL was:\n $_"; + } +} + +sub DESTROY { shift->disconnect } + 1; =head1 ENVIRONMENT VARIABLES