X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FDBIx%2FClass%2FStorage%2FDBI.pm;h=78d7321de19d780c3a2270cb3a53b565ced7cf24;hb=f83d99c80b593ccf0c445784cda98cb4de0c8564;hp=657c91923c009799d59f6e5b0faa9ce6c59296ee;hpb=892d77688a0fee5ce467c9d27e3c78f3ff2545ce;p=dbsrgits%2FDBIx-Class.git diff --git a/lib/DBIx/Class/Storage/DBI.pm b/lib/DBIx/Class/Storage/DBI.pm index 657c919..78d7321 100644 --- a/lib/DBIx/Class/Storage/DBI.pm +++ b/lib/DBIx/Class/Storage/DBI.pm @@ -18,13 +18,36 @@ use base qw/SQL::Abstract::Limit/; sub select { my ($self, $table, $fields, $where, $order, @rest) = @_; + $table = $self->_quote($table) unless ref($table); @rest = (-1) unless defined $rest[0]; local $self->{having_bind} = []; - my ($sql, @ret) = $self->SUPER::select($table, - $self->_recurse_fields($fields), $where, $order, @rest); + my ($sql, @ret) = $self->SUPER::select( + $table, $self->_recurse_fields($fields), $where, $order, @rest + ); return wantarray ? ($sql, @ret, @{$self->{having_bind}}) : $sql; } +sub insert { + my $self = shift; + my $table = shift; + $table = $self->_quote($table) unless ref($table); + $self->SUPER::insert($table, @_); +} + +sub update { + my $self = shift; + my $table = shift; + $table = $self->_quote($table) unless ref($table); + $self->SUPER::update($table, @_); +} + +sub delete { + my $self = shift; + my $table = shift; + $table = $self->_quote($table) unless ref($table); + $self->SUPER::delete($table, @_); +} + sub _emulate_limit { my $self = shift; if ($_[3] == -1) { @@ -68,6 +91,8 @@ sub _order_by { 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(@_); } @@ -87,7 +112,12 @@ sub _table { } elsif (ref $from eq 'HASH') { return $self->_make_as($from); } else { - return $from; + return $from; # would love to quote here but _table ends up getting called + # twice during an ->select without a limit clause due to + # the way S::A::Limit->select works. should maybe consider + # bypassing this and doing S::A::select($self, ...) in + # our select method above. meantime, quoting shims have + # been added to select/insert/update/delete here } } @@ -120,7 +150,7 @@ sub _recurse_from { sub _make_as { my ($self, $from) = @_; return join(' ', map { (ref $_ eq 'SCALAR' ? $$_ : $self->_quote($_)) } - reverse each %{$self->_skip_options($from)}); + reverse each %{$self->_skip_options($from)}); } sub _skip_options { @@ -135,7 +165,9 @@ sub _join_condition { my ($self, $cond) = @_; if (ref $cond eq 'HASH') { my %j; - for (keys %$cond) { my $x = '= '.$self->_quote($cond->{$_}); $j{$_} = \$x; }; + for (keys %$cond) { + my $x = '= '.$self->_quote($cond->{$_}); $j{$_} = \$x; + }; return $self->_recurse_where(\%j); } elsif (ref $cond eq 'ARRAY') { return join(' OR ', map { $self->_join_condition($_) } @$cond); @@ -208,8 +240,8 @@ use base qw/DBIx::Class/; __PACKAGE__->load_components(qw/AccessorGroup/); __PACKAGE__->mk_group_accessors('simple' => - qw/connect_info _dbh _sql_maker _connection_pid 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]); @@ -217,7 +249,8 @@ 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')) || $new->throw_exception("Cannot open trace file $1"); + $new->debugfh(IO::File->new($1, 'w')) + or $new->throw_exception("Cannot open trace file $1"); } else { $new->debugfh(IO::File->new('>&STDERR')); } @@ -230,7 +263,7 @@ sub throw_exception { croak($msg); } -=head1 NAME +=head1 NAME DBIx::Class::Storage::DBI - DBI storage handler @@ -244,6 +277,25 @@ This class represents the connection to the database =cut +=head2 connect_info + +Connection information arrayref. Can either be the same arguments +one would pass to DBI->connect, or a code-reference which returns +a connected database handle. In either case, there is an optional +final element in the arrayref, which can hold a hashref of +connection-specific Storage::DBI options. These include +C, and the sql_maker options C, +C, and C. Examples: + + ->connect_info([ 'dbi:SQLite:./foo.db' ]); + ->connect_info(sub { DBI->connect(...) }); + ->connect_info([ 'dbi:Pg:dbname=foo', + 'postgres', + '', + { AutoCommit => 0 }, + { quote_char => q{`}, name_sep => q{@} }, + ]); + =head2 on_connect_do Executes the sql statements given as a listref on every db connect. @@ -288,8 +340,20 @@ sub disconnect { 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 { @@ -300,11 +364,15 @@ sub ensure_connected { } } +=head2 dbh + +Returns the dbh - a data base handle of class L. + +=cut + sub dbh { my ($self) = @_; - $self->_dbh(undef) - if $self->_connection_pid && $self->_connection_pid != $$; $self->ensure_connected; return $self->_dbh; } @@ -317,9 +385,40 @@ sub sql_maker { return $self->_sql_maker; } +sub connect_info { + my ($self, $info_arg) = @_; + + if($info_arg) { + my $info = [ @$info_arg ]; # copy because we can alter it + my $last_info = $info->[-1]; + if(ref $last_info eq 'HASH') { + my $used; + if(my $on_connect_do = $last_info->{on_connect_do}) { + $used = 1; + $self->on_connect_do($on_connect_do); + } + for my $sql_maker_opt (qw/limit_dialect quote_char name_sep/) { + if(my $opt_val = $last_info->{$sql_maker_opt}) { + $used = 1; + $self->sql_maker->$sql_maker_opt($opt_val); + } + } + + # remove our options hashref if it was there, to avoid confusing + # DBI in the case the user didn't use all 4 DBI options, as in: + # [ 'dbi:SQLite:foo.db', { quote_char => q{`} } ] + pop(@$info) if $used; + } + + $self->_connect_info($info); + } + + $self->_connect_info; +} + sub _populate_dbh { my ($self) = @_; - my @info = @{$self->connect_info || []}; + my @info = @{$self->_connect_info || []}; $self->_dbh($self->_connect(@info)); my $driver = $self->_dbh->{Driver}->{Name}; eval "require DBIx::Class::Storage::DBI::${driver}"; @@ -331,23 +430,38 @@ sub _populate_dbh { $self->_dbh->do($sql_statement); } - $self->_connection_pid($$); + $self->_conn_pid($$); + $self->_conn_tid(threads->tid) if $INC{'threads.pm'}; } sub _connect { my ($self, @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}) { - my $old_connect_via = $DBI::connect_via; + $old_connect_via = $DBI::connect_via; $DBI::connect_via = 'connect'; - my $dbh = DBI->connect(@info); - $DBI::connect_via = $old_connect_via; - return $dbh; } - my $dbh = DBI->connect(@info); - $self->throw_exception("DBI Connection failed: $DBI::errstr") - unless $dbh; + eval { + if(ref $info[0] eq 'CODE') { + $dbh = &{$info[0]}; + } + else { + $dbh = DBI->connect(@info); + } + }; + + $DBI::connect_via = $old_connect_via if $old_connect_via; + + if (!$dbh || $@) { + $self->throw_exception("DBI Connection failed: " . ($@ || $DBI::errstr)); + } + $dbh; } @@ -355,11 +469,21 @@ sub _connect { 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}; + if ($self->{transaction_depth}++ == 0) { + my $dbh = $self->dbh; + if ($dbh->{AutoCommit}) { + $self->debugfh->print("BEGIN WORK\n") + if ($self->debug); + $dbh->begin_work; + } + } } =head2 txn_commit @@ -371,16 +495,27 @@ Issues a commit against the current dbh. sub txn_commit { my $self = shift; if ($self->{transaction_depth} == 0) { - $self->dbh->commit unless $self->dbh->{AutoCommit}; + my $dbh = $self->dbh; + unless ($dbh->{AutoCommit}) { + $self->debugfh->print("COMMIT\n") + if ($self->debug); + $dbh->commit; + } } else { - $self->dbh->commit if --$self->{transaction_depth} == 0; + if (--$self->{transaction_depth} == 0) { + $self->debugfh->print("COMMIT\n") + if ($self->debug); + $self->dbh->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 @@ -389,12 +524,22 @@ sub txn_rollback { eval { if ($self->{transaction_depth} == 0) { - $self->dbh->rollback unless $self->dbh->{AutoCommit}; + my $dbh = $self->dbh; + unless ($dbh->{AutoCommit}) { + $self->debugfh->print("ROLLBACK\n") + if ($self->debug); + $dbh->rollback; + } } else { - --$self->{transaction_depth} == 0 ? - $self->dbh->rollback : - die DBIx::Class::Storage::NESTED_ROLLBACK_EXCEPTION->new; + if (--$self->{transaction_depth} == 0) { + $self->debugfh->print("ROLLBACK\n") + if ($self->debug); + $self->dbh->rollback; + } + else { + die DBIx::Class::Storage::NESTED_ROLLBACK_EXCEPTION->new; + } } }; @@ -412,16 +557,24 @@ sub _execute { my ($sql, @bind) = $self->sql_maker->$op($ident, @args); unshift(@bind, @$extra_bind) if $extra_bind; if ($self->debug) { - my @debug_bind = map { defined $_ ? $_ : 'NULL' } @bind; - $self->debugfh->print("$sql: @debug_bind\n"); + my @debug_bind = map { defined $_ ? qq{`$_'} : q{`NULL'} } @bind; + $self->debugfh->print("$sql: " . join(', ', @debug_bind) . "\n"); + } + my $sth = eval { $self->sth($sql,$op) }; + + if (!$sth || $@) { + $self->throw_exception('no sth generated via sql (' . ($@ || $self->_dbh->errstr) . "): $sql"); } - 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); - } else { + if ($sth) { + $rv = eval { $sth->execute(@bind) }; + + if ($@ || !$rv) { + $self->throw_exception("Error executing '$sql': ".($@ || $sth->errstr)); + } + } else { $self->throw_exception("'$sql' did not generate a statement."); } return (wantarray ? ($rv, $sth, @bind) : $rv); @@ -429,8 +582,11 @@ sub _execute { sub insert { my ($self, $ident, $to_insert) = @_; - $self->throw_exception( "Couldn't insert ".join(', ', map "$_ => $to_insert->{$_}", keys %$to_insert)." into ${ident}" ) - unless ($self->_execute('insert' => [], $ident, $to_insert)); + $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; } @@ -449,9 +605,11 @@ sub _select { $order = $1 if $$condition =~ s/ORDER BY (.*)$//i; } if (exists $attrs->{group_by} || $attrs->{having}) { - $order = { group_by => $attrs->{group_by}, - having => $attrs->{having}, - ($order ? (order_by => $order) : ()) }; + $order = { + group_by => $attrs->{group_by}, + having => $attrs->{having}, + ($order ? (order_by => $order) : ()) + }; } my @args = ('select', $attrs->{bind}, $ident, $select, $condition, $order); if ($attrs->{software_limit} || @@ -492,27 +650,59 @@ Returns database type info for a given table columns. =cut sub columns_info_for { - my ($self, $table) = @_; + my ($self, $table) = @_; + + my $dbh = $self->dbh; + + if ($dbh->can('column_info')) { 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; - } - } 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]; - } + my $old_raise_err = $dbh->{RaiseError}; + my $old_print_err = $dbh->{PrintError}; + $dbh->{RaiseError} = 1; + $dbh->{PrintError} = 0; + eval { + my $sth = $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; + } + }; + $dbh->{RaiseError} = $old_raise_err; + $dbh->{PrintError} = $old_print_err; + return \%result if !$@; + } + + my %result; + my $sth = $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 && $dbh->can('type_info')) { + my $type_info = $dbh->type_info($type_num); + $type_name = $type_info->{TYPE_NAME} if $type_info; + } + $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; } - return \%result; + + $result{$columns[$i]} = \%column_info; + } + + return \%result; } sub last_insert_id { @@ -522,32 +712,30 @@ sub last_insert_id { } -sub sqlt_type { - my ($self) = @_; - my $dsn = $self->connect_info->[0]; - $dsn =~ /^dbi:(.*?)\d*:/; - return $1; -} +sub sqlt_type { shift->dbh->{Driver}->{Name} } sub deployment_statements { - my ($self, $schema, $type) = @_; + 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 $@; + $self->throw_exception($@) if $@; eval "use SQL::Translator::Producer::${type};"; $self->throw_exception($@) if $@; - my $tr = SQL::Translator->new(); + 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) = @_; - foreach(split(";\n", $self->deployment_statements($schema, $type))) { - $self->dbh->do($_) or warn "SQL was:\n $_"; - } + my ($self, $schema, $type, $sqltargs) = @_; + foreach my $statement ( $self->deployment_statements($schema, $type, $sqltargs) ) { + for ( split(";\n", $statement)) { + $self->debugfh->print("$_\n") if $self->debug; + $self->dbh->do($_) or warn "SQL was:\n $_"; + } + } } sub DESTROY { shift->disconnect }