X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FDBIx%2FClass%2FStorage%2FDBI.pm;h=094b508e978380ab10b9c4451dddc8ae9d7731e9;hb=28be49a61823d8e7592ddd9c81e86066fd47e6ee;hp=d6c637010922c64a15c64b153f836753e2bf3c8e;hpb=aed5b8a46a2e48adeeb790c06906c4d48f190043;p=dbsrgits%2FDBIx-Class.git diff --git a/lib/DBIx/Class/Storage/DBI.pm b/lib/DBIx/Class/Storage/DBI.pm index d6c6370..094b508 100644 --- a/lib/DBIx/Class/Storage/DBI.pm +++ b/lib/DBIx/Class/Storage/DBI.pm @@ -1,387 +1,268 @@ package DBIx::Class::Storage::DBI; # -*- mode: cperl; cperl-indent-level: 2 -*- +use strict; +use warnings; + use base 'DBIx::Class::Storage'; +use mro 'c3'; -use strict; -use warnings; +use Carp::Clan qw/^DBIx::Class/; use DBI; -use SQL::Abstract::Limit; use DBIx::Class::Storage::DBI::Cursor; use DBIx::Class::Storage::Statistics; -use Scalar::Util qw/blessed weaken/; +use Scalar::Util(); +use List::Util(); __PACKAGE__->mk_group_accessors('simple' => - qw/_connect_info _dbi_connect_info _dbh _sql_maker _sql_maker_opts - _conn_pid _conn_tid disable_sth_caching on_connect_do - on_disconnect_do transaction_depth unsafe _dbh_autocommit/ + qw/_connect_info _dbi_connect_info _dbh _sql_maker _sql_maker_opts _conn_pid + _conn_tid transaction_depth _dbh_autocommit _driver_determined savepoints/ ); +# the values for these accessors are picked out (and deleted) from +# the attribute hashref passed to connect_info +my @storage_options = qw/ + on_connect_call on_disconnect_call on_connect_do on_disconnect_do + disable_sth_caching unsafe auto_savepoint +/; +__PACKAGE__->mk_group_accessors('simple' => @storage_options); + + +# default cursor class, overridable in connect_info attributes __PACKAGE__->cursor_class('DBIx::Class::Storage::DBI::Cursor'); __PACKAGE__->mk_group_accessors('inherited' => qw/sql_maker_class/); -__PACKAGE__->sql_maker_class('DBIC::SQL::Abstract'); +__PACKAGE__->sql_maker_class('DBIx::Class::SQLAHacks'); -BEGIN { -package DBIC::SQL::Abstract; # Would merge upstream, but nate doesn't reply :( +=head1 NAME -use base qw/SQL::Abstract::Limit/; +DBIx::Class::Storage::DBI - DBI storage handler -# This prevents the caching of $dbh in S::A::L, I believe -sub new { - my $self = shift->SUPER::new(@_); +=head1 SYNOPSIS - # If limit_dialect is a ref (like a $dbh), go ahead and replace - # it with what it resolves to: - $self->{limit_dialect} = $self->_find_syntax($self->{limit_dialect}) - if ref $self->{limit_dialect}; + my $schema = MySchema->connect('dbi:SQLite:my.db'); - $self; -} + $schema->storage->debug(1); + $schema->dbh_do("DROP TABLE authors"); -sub _RowNumberOver { - my ($self, $sql, $order, $rows, $offset ) = @_; + $schema->resultset('Book')->search({ + written_on => $schema->storage->datetime_parser(DateTime->now) + }); - $offset += 1; - my $last = $rows + $offset; - my ( $order_by ) = $self->_order_by( $order ); +=head1 DESCRIPTION - $sql = <<""; -SELECT * FROM -( - SELECT Q1.*, ROW_NUMBER() OVER( ) AS ROW_NUM FROM ( - $sql - $order_by - ) Q1 -) Q2 -WHERE ROW_NUM BETWEEN $offset AND $last +This class represents the connection to an RDBMS via L. See +L for general information. This pod only +documents DBI-specific methods and behaviors. - return $sql; -} +=head1 METHODS +=cut -# While we're at it, this should make LIMIT queries more efficient, -# without digging into things too deeply -use Scalar::Util 'blessed'; -sub _find_syntax { - my ($self, $syntax) = @_; - my $dbhname = blessed($syntax) ? $syntax->{Driver}{Name} : $syntax; - if(ref($self) && $dbhname && $dbhname eq 'DB2') { - return 'RowNumberOver'; - } +sub new { + my $new = shift->next::method(@_); - $self->{_cached_syntax} ||= $self->SUPER::_find_syntax($syntax); -} + $new->transaction_depth(0); + $new->_sql_maker_opts({}); + $new->{savepoints} = []; + $new->{_in_dbh_do} = 0; + $new->{_dbh_gen} = 0; -sub select { - my ($self, $table, $fields, $where, $order, @rest) = @_; - $table = $self->_quote($table) unless ref($table); - local $self->{rownum_hack_count} = 1 - if (defined $rest[0] && $self->{limit_dialect} eq 'RowNum'); - @rest = (-1) unless defined $rest[0]; - die "LIMIT 0 Does Not Compute" if $rest[0] == 0; - # and anyway, SQL::Abstract::Limit will cause a barf if we don't first - local $self->{having_bind} = []; - my ($sql, @ret) = $self->SUPER::select( - $table, $self->_recurse_fields($fields), $where, $order, @rest - ); - $sql .= - $self->{for} ? - ( - $self->{for} eq 'update' ? ' FOR UPDATE' : - $self->{for} eq 'shared' ? ' FOR SHARE' : - '' - ) : - '' - ; - return wantarray ? ($sql, @ret, @{$self->{having_bind}}) : $sql; + $new; } -sub insert { - my $self = shift; - my $table = shift; - $table = $self->_quote($table) unless ref($table); - $self->SUPER::insert($table, @_); -} +=head2 connect_info -sub update { - my $self = shift; - my $table = shift; - $table = $self->_quote($table) unless ref($table); - $self->SUPER::update($table, @_); -} +This method is normally called by L, which +encapsulates its argument list in an arrayref before passing them here. -sub delete { - my $self = shift; - my $table = shift; - $table = $self->_quote($table) unless ref($table); - $self->SUPER::delete($table, @_); -} +The argument list may contain: -sub _emulate_limit { - my $self = shift; - if ($_[3] == -1) { - return $_[1].$self->_order_by($_[2]); - } else { - return $self->SUPER::_emulate_limit(@_); - } -} +=over -sub _recurse_fields { - my ($self, $fields, $params) = @_; - my $ref = ref $fields; - return $self->_quote($fields) unless $ref; - return $$fields if $ref eq 'SCALAR'; - - if ($ref eq 'ARRAY') { - return join(', ', map { - $self->_recurse_fields($_) - .(exists $self->{rownum_hack_count} && !($params && $params->{no_rownum_hack}) - ? ' AS col'.$self->{rownum_hack_count}++ - : '') - } @$fields); - } elsif ($ref eq 'HASH') { - foreach my $func (keys %$fields) { - return $self->_sqlcase($func) - .'( '.$self->_recurse_fields($fields->{$func}).' )'; - } - } -} +=item * -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}, { no_rownum_hack => 1 }); - } - 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->_order_by($_[0]->{order_by}); - } - } elsif (ref $_[0] eq 'SCALAR') { - $ret = $self->_sqlcase(' order by ').${ $_[0] }; - } elsif (ref $_[0] eq 'ARRAY' && @{$_[0]}) { - my @order = @{+shift}; - $ret = $self->_sqlcase(' order by ') - .join(', ', map { - my $r = $self->_order_by($_, @_); - $r =~ s/^ ?ORDER BY //i; - $r; - } @order); - } else { - $ret = $self->SUPER::_order_by(@_); - } - return $ret; -} +The same 4-element argument set one would normally pass to +L, optionally followed by +L +recognized by DBIx::Class: -sub _order_directions { - my ($self, $order) = @_; - $order = $order->{order_by} if ref $order eq 'HASH'; - return $self->SUPER::_order_directions($order); -} + $connect_info_args = [ $dsn, $user, $password, \%dbi_attributes?, \%extra_attributes? ]; -sub _table { - my ($self, $from) = @_; - if (ref $from eq 'ARRAY') { - return $self->_recurse_from(@$from); - } elsif (ref $from eq 'HASH') { - return $self->_make_as($from); - } else { - 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 - } -} +=item * -sub _recurse_from { - my ($self, $from, @join) = @_; - my @sqlf; - push(@sqlf, $self->_make_as($from)); - foreach my $j (@join) { - my ($to, $on) = @$j; +A single code reference which returns a connected +L optionally followed by +L recognized +by DBIx::Class: - # check whether a join type exists - my $join_clause = ''; - my $to_jt = ref($to) eq 'ARRAY' ? $to->[0] : $to; - if (ref($to_jt) eq 'HASH' and exists($to_jt->{-join_type})) { - $join_clause = ' '.uc($to_jt->{-join_type}).' JOIN '; - } else { - $join_clause = ' JOIN '; - } - push(@sqlf, $join_clause); + $connect_info_args = [ sub { DBI->connect (...) }, \%extra_attributes? ]; - if (ref $to eq 'ARRAY') { - push(@sqlf, '(', $self->_recurse_from(@$to), ')'); - } else { - push(@sqlf, $self->_make_as($to)); - } - push(@sqlf, ' ON ', $self->_join_condition($on)); - } - return join('', @sqlf); -} - -sub _make_as { - my ($self, $from) = @_; - return join(' ', map { (ref $_ eq 'SCALAR' ? $$_ : $self->_quote($_)) } - reverse each %{$self->_skip_options($from)}); -} - -sub _skip_options { - my ($self, $hash) = @_; - my $clean_hash = {}; - $clean_hash->{$_} = $hash->{$_} - for grep {!/^-/} keys %$hash; - return $clean_hash; -} - -sub _join_condition { - my ($self, $cond) = @_; - if (ref $cond eq 'HASH') { - my %j; - for (keys %$cond) { - my $v = $cond->{$_}; - if (ref $v) { - # XXX no throw_exception() in this package and croak() fails with strange results - Carp::croak(ref($v) . qq{ reference arguments are not supported in JOINS - try using \"..." instead'}) - if ref($v) ne 'SCALAR'; - $j{$_} = $v; - } - else { - my $x = '= '.$self->_quote($v); $j{$_} = \$x; - } - }; - return scalar($self->_recurse_where(\%j)); - } elsif (ref $cond eq 'ARRAY') { - return join(' OR ', map { $self->_join_condition($_) } @$cond); - } else { - die "Can't handle this yet!"; - } -} +=item * -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); -} +A single hashref with all the attributes and the dsn/user/password +mixed together: -sub limit_dialect { - my $self = shift; - $self->{limit_dialect} = shift if @_; - return $self->{limit_dialect}; -} + $connect_info_args = [{ + dsn => $dsn, + user => $user, + password => $pass, + %dbi_attributes, + %extra_attributes, + }]; -sub quote_char { - my $self = shift; - $self->{quote_char} = shift if @_; - return $self->{quote_char}; -} +This is particularly useful for L based applications, allowing the +following config (L style): -sub name_sep { - my $self = shift; - $self->{name_sep} = shift if @_; - return $self->{name_sep}; -} + + schema_class App::DB + + dsn dbi:mysql:database=test + user testuser + password TestPass + AutoCommit 1 + + -} # End of BEGIN block +=back -=head1 NAME +Please note that the L docs recommend that you always explicitly +set C to either I<0> or I<1>. L further +recommends that it be set to I<1>, and that you perform transactions +via our L method. L will set it +to I<1> if you do not do explicitly set it to zero. This is the default +for most DBDs. See L for details. -DBIx::Class::Storage::DBI - DBI storage handler +=head3 DBIx::Class specific connection attributes -=head1 SYNOPSIS +In addition to the standard L +L attributes, DBIx::Class recognizes +the following connection options. These options can be mixed in with your other +L connection attributes, or placed in a seperate hashref +(C<\%extra_attributes>) as shown above. -=head1 DESCRIPTION +Every time C is invoked, any previous settings for +these options will be cleared before setting the new ones, regardless of +whether any options are specified in the new C. -This class represents the connection to an RDBMS via L. See -L for general information. This pod only -documents DBI-specific methods and behaviors. -=head1 METHODS +=over -=cut +=item on_connect_do -sub new { - my $new = shift->next::method(@_); +Specifies things to do immediately after connecting or re-connecting to +the database. Its value may contain: - $new->transaction_depth(0); - $new->_sql_maker_opts({}); - $new->{_in_dbh_do} = 0; - $new->{_dbh_gen} = 0; +=over - $new; -} +=item a scalar -=head2 connect_info +This contains one SQL statement to execute. + +=item an array reference + +This contains SQL statements to execute in order. Each element contains +a string or a code reference that returns a string. + +=item a code reference -The arguments of C are always a single array reference. +This contains some code to execute. Unlike code references within an +array reference, its return value is ignored. -This is normally accessed via L, which -encapsulates its argument list in an arrayref before calling -C here. +=back -The arrayref can either contain the same set of arguments one would -normally pass to L, or a lone code reference which returns -a connected database handle. Please note that the L docs -recommend that you always explicitly set C to either -C<0> or C<1>. L further recommends that it be set -to C<1>, and that you perform transactions via our L -method. L will set it to C<1> if you do not do explicitly -set it to zero. This is the default for most DBDs. See below for more -details. +=item on_disconnect_do -In either case, if the final argument in your connect_info happens -to be a hashref, C will look there for several -connection-specific options: +Takes arguments in the same form as L and executes them +immediately before disconnecting from the database. -=over 4 +Note, this only runs if you explicitly call L on the +storage object. -=item on_connect_do +=item on_connect_call -Specifies things to do immediately after connecting or re-connecting to -the database. Its value may contain: +A more generalized form of L that calls the specified +C methods in your storage driver. + + on_connect_do => 'select 1' + +is equivalent to: + + on_connect_call => [ [ do_sql => 'select 1' ] ] + +Its values may contain: =over +=item a scalar + +Will call the C method. + +=item a code reference + +Will execute C<< $code->($storage) >> + =item an array reference -This contains SQL statements to execute in order. Each element contains -a string or a code reference that returns a string. +Each value can be a method name or code reference. + +=item an array of arrays + +For each array, the first item is taken to be the C method name +or code reference, and the rest are parameters to it. + +=back + +Some predefined storage methods you may use: + +=over + +=item do_sql + +Executes a SQL string or a code reference that returns a SQL string. This is +what L and L use. + +It can take: + +=over + +=item a scalar + +Will execute the scalar as SQL. + +=item an arrayref + +Taken to be arguments to L, the SQL string optionally followed by the +attributes hashref and bind values. =item a code reference -This contains some code to execute. Unlike code references within an -array reference, its return value is ignored. +Will execute C<< $code->($storage) >> and execute the return array refs as +above. =back -=item on_disconnect_do +=item datetime_setup + +Execute any statements necessary to initialize the database session to return +and accept datetime/timestamp values used with +L. + +Only necessary for some databases, see your specific storage driver for +implementation details. + +=back + +=item on_disconnect_call -Takes arguments in the same form as L and executes them +Takes arguments in the same form as L and executes them immediately before disconnecting from the database. -Note, this only runs if you explicitly call L on the +Calls the C methods as opposed to the +C methods called by L. + +Note, this only runs if you explicitly call L on the storage object. =item disable_sth_caching @@ -389,30 +270,35 @@ storage object. If set to a true value, this option will disable the caching of statement handles via L. -=item limit_dialect +=item limit_dialect Sets the 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. +driver alone. See also L. =item quote_char -Specifies what characters to use to quote table and column names. If -you use this you will want to specify L as well. +Specifies what characters to use to quote table and column names. If +you use this you will want to specify L as well. -quote_char expects either a single character, in which case is it is placed -on either side of the table/column, or an arrayref of length 2 in which case the -table/column name is placed between the elements. +C expects either a single character, in which case is it +is placed on either side of the table/column name, or an arrayref of length +2 in which case the table/column name is placed between the elements. -For example under MySQL you'd use C '`'>, and user SQL Server you'd -use C [qw/[ ]/]>. +For example under MySQL you should use C<< quote_char => '`' >>, and for +SQL Server you should use C<< quote_char => [qw/[ ]/] >>. =item name_sep -This only needs to be used in conjunction with L, and is used to -specify the charecter that seperates elements (schemas, tables, columns) from +This only needs to be used in conjunction with C, and is used to +specify the charecter that seperates elements (schemas, tables, columns) from each other. In most cases this is simply a C<.>. +The consequences of not supplying this value is that L +will assume DBIx::Class' uses of aliases to be complete column +names. The output will look like I<"me.name"> when it should actually +be I<"me"."name">. + =item unsafe This Storage driver normally installs its own C, sets @@ -429,32 +315,21 @@ Note that your custom settings can cause Storage to malfunction, especially if you set a C handler that suppresses exceptions and/or disable C. -=back - -These options can be mixed in with your other L connection attributes, -or placed in a seperate hashref after all other normal L connection -arguments. +=item auto_savepoint -Every time C is invoked, any previous settings for -these options will be cleared before setting the new ones, regardless of -whether any options are specified in the new C. +If this option is true, L will use savepoints when nesting +transactions, making it possible to recover from failure in the inner +transaction without having to abort all outer transactions. -Another Important Note: +=item cursor_class -DBIC can do some wonderful magic with handling exceptions, -disconnections, and transactions when you use C -combined with C for transaction support. +Use this argument to supply a cursor class other than the default +L. -If you set C in your connect info, then you are always -in an assumed transaction between commits, and you're telling us you'd -like to manage that manually. A lot of DBIC's magic protections -go away. We can't protect you from exceptions due to database -disconnects because we don't know anything about how to restart your -transactions. You're on your own for handling all sorts of exceptional -cases if you choose the C path, just as you would -be with raw DBI. +=back -Examples: +Some real-life examples of arguments to L and +L # Simple SQLite connection ->connect_info([ 'dbi:SQLite:./foo.db' ]); @@ -483,7 +358,20 @@ Examples: ] ); - # Subref + DBIC-specific connection options + # Same, but with hashref as argument + # See parse_connect_info for explanation + ->connect_info( + [{ + dsn => 'dbi:Pg:dbname=foo', + user => 'postgres', + password => 'my_pg_password', + AutoCommit => 1, + quote_char => q{"}, + name_sep => q{.}, + }] + ); + + # Subref + DBIx::Class-specific connection options ->connect_info( [ sub { DBI->connect(...) }, @@ -496,6 +384,8 @@ Examples: ] ); + + =cut sub connect_info { @@ -503,50 +393,107 @@ sub connect_info { return $self->_connect_info if !$info_arg; + my @args = @$info_arg; # take a shallow copy for further mutilation + $self->_connect_info([@args]); # copy for _connect_info + + + # combine/pre-parse arguments depending on invocation style + + my %attrs; + if (ref $args[0] eq 'CODE') { # coderef with optional \%extra_attributes + %attrs = %{ $args[1] || {} }; + @args = $args[0]; + } + elsif (ref $args[0] eq 'HASH') { # single hashref (i.e. Catalyst config) + %attrs = %{$args[0]}; + @args = (); + for (qw/password user dsn/) { + unshift @args, delete $attrs{$_}; + } + } + else { # otherwise assume dsn/user/password + \%attrs + \%extra_attrs + %attrs = ( + % { $args[3] || {} }, + % { $args[4] || {} }, + ); + @args = @args[0,1,2]; + } + # Kill sql_maker/_sql_maker_opts, so we get a fresh one with only # the new set of options $self->_sql_maker(undef); $self->_sql_maker_opts({}); - $self->_connect_info([@$info_arg]); # copy for _connect_info - - my $dbi_info = [@$info_arg]; # copy for _dbi_connect_info - my $last_info = $dbi_info->[-1]; - if(ref $last_info eq 'HASH') { - $last_info = { %$last_info }; # so delete is non-destructive - my @storage_option = qw( - on_connect_do on_disconnect_do disable_sth_caching unsafe cursor_class - ); - for my $storage_opt (@storage_option) { - if(my $value = delete $last_info->{$storage_opt}) { + if(keys %attrs) { + for my $storage_opt (@storage_options, 'cursor_class') { # @storage_options is declared at the top of the module + if(my $value = delete $attrs{$storage_opt}) { $self->$storage_opt($value); } } for my $sql_maker_opt (qw/limit_dialect quote_char name_sep/) { - if(my $opt_val = delete $last_info->{$sql_maker_opt}) { + if(my $opt_val = delete $attrs{$sql_maker_opt}) { $self->_sql_maker_opts->{$sql_maker_opt} = $opt_val; } } - # re-insert modified hashref - $dbi_info->[-1] = $last_info; + } - # Get rid of any trailing empty hashref - pop(@$dbi_info) if !keys %$last_info; + if (ref $args[0] eq 'CODE') { + # _connect() never looks past $args[0] in this case + %attrs = () + } else { + %attrs = ( + %{ $self->_default_dbi_connect_attributes || {} }, + %attrs, + ); } - $self->_dbi_connect_info($dbi_info); + $self->_dbi_connect_info([@args, keys %attrs ? \%attrs : ()]); $self->_connect_info; } +sub _default_dbi_connect_attributes { + return { AutoCommit => 1 }; +} + =head2 on_connect_do -This method is deprecated in favor of setting via L. +This method is deprecated in favour of setting via L. + +=cut + +=head2 on_disconnect_do + +This method is deprecated in favour of setting via L. + +=cut + +sub _parse_connect_do { + my ($self, $type) = @_; + + my $val = $self->$type; + return () if not defined $val; + + my @res; + + if (not ref($val)) { + push @res, [ 'do_sql', $val ]; + } elsif (ref($val) eq 'CODE') { + push @res, $val; + } elsif (ref($val) eq 'ARRAY') { + push @res, map { [ 'do_sql', $_ ] } @$val; + } else { + $self->throw_exception("Invalid type for $type: ".ref($val)); + } + + return \@res; +} =head2 dbh_do -Arguments: $subref, @extra_coderef_args? +Arguments: ($subref | $method_name), @extra_coderef_args? -Execute the given subref using the new exception-based connection management. +Execute the given $subref or $method_name using the new exception-based +connection management. The first two arguments will be the storage object that C was called on and a database handle to use. Any additional arguments will be passed @@ -574,30 +521,40 @@ Example: sub dbh_do { my $self = shift; - my $coderef = shift; + my $code = shift; - ref $coderef eq 'CODE' or $self->throw_exception - ('$coderef must be a CODE reference'); + my $dbh = $self->_dbh; - return $coderef->($self, $self->_dbh, @_) if $self->{_in_dbh_do} + return $self->$code($dbh, @_) if $self->{_in_dbh_do} || $self->{transaction_depth}; local $self->{_in_dbh_do} = 1; + $self->_do_with_reconnect($code, @_); +} + +sub _do_with_reconnect { + my $self = shift; + my $code = shift; my @result; my $want_array = wantarray; + my $dbh = $self->_dbh; eval { - $self->_verify_pid if $self->_dbh; - $self->_populate_dbh if !$self->_dbh; + $self->_verify_pid if $dbh; + if(!$self->_dbh) { + $self->_populate_dbh; + $dbh = $self->_dbh; + } + if($want_array) { - @result = $coderef->($self, $self->_dbh, @_); + @result = $self->$code($dbh, @_); } elsif(defined $want_array) { - $result[0] = $coderef->($self, $self->_dbh, @_); + $result[0] = $self->$code($dbh, @_); } else { - $coderef->($self, $self->_dbh, @_); + $self->$code($dbh, @_); } }; @@ -609,7 +566,7 @@ sub dbh_do { # We were not connected - reconnect and retry, but let any # exception fall right through this time $self->_populate_dbh; - $coderef->($self, $self->_dbh, @_); + $self->$code($self->_dbh, @_); } # This is basically a blend of dbh_do above and DBIx::Class::Storage::txn_do. @@ -622,7 +579,7 @@ sub txn_do { ref $coderef eq 'CODE' or $self->throw_exception ('$coderef must be a CODE reference'); - return $coderef->(@_) if $self->{transaction_depth}; + return $coderef->(@_) if $self->{transaction_depth} && ! $self->auto_savepoint; local $self->{_in_dbh_do} = 1; @@ -683,9 +640,13 @@ database is not in C mode. sub disconnect { my ($self) = @_; - if( $self->connected ) { - my $connection_do = $self->on_disconnect_do; - $self->_do_connection_actions($connection_do) if ref($connection_do); + if( $self->_dbh ) { + my @actions; + + push @actions, ( $self->on_disconnect_call || () ); + push @actions, $self->_parse_connect_do ('on_disconnect_do'); + + $self->_do_connection_actions(disconnect_call_ => $_) for @actions; $self->_dbh->rollback unless $self->_dbh_autocommit; $self->_dbh->disconnect; @@ -694,6 +655,44 @@ sub disconnect { } } +=head2 with_deferred_fk_checks + +=over 4 + +=item Arguments: C<$coderef> + +=item Return Value: The return value of $coderef + +=back + +Storage specific method to run the code ref with FK checks deferred or +in MySQL's case disabled entirely. + +=cut + +# Storage subclasses should override this +sub with_deferred_fk_checks { + my ($self, $sub) = @_; + + $sub->(); +} + +=head2 connected + +=over + +=item Arguments: none + +=item Return Value: 1|0 + +=back + +Verifies that the the current database handle is active and ready to execute +an SQL statement (i.e. the connection did not get stale, server is still +answering, etc.) This method is used internally by L. + +=cut + sub connected { my ($self) = @_; @@ -707,12 +706,20 @@ sub connected { $self->_verify_pid; return 0 if !$self->_dbh; } - return ($dbh->FETCH('Active') && $dbh->ping); + return ($dbh->FETCH('Active') && $self->_ping); } return 0; } +sub _ping { + my $self = shift; + + my $dbh = $self->_dbh or return 0; + + return $dbh->ping; +} + # handle pid changes correctly # NOTE: assumes $self->_dbh is a valid $dbh sub _verify_pid { @@ -737,70 +744,159 @@ sub ensure_connected { =head2 dbh -Returns the dbh - a data base handle of class L. +Returns a C<$dbh> - a data base handle of class L. The returned handle +is guaranteed to be healthy by implicitly calling L, and if +necessary performing a reconnection before returning. =cut sub dbh { my ($self) = @_; - $self->ensure_connected; + if (not $self->_dbh) { + $self->_populate_dbh; + } else { + $self->ensure_connected; + } return $self->_dbh; } -sub _sql_maker_args { - my ($self) = @_; - - return ( bindtype=>'columns', limit_dialect => $self->dbh, %{$self->_sql_maker_opts} ); -} +=head2 last_dbh -sub sql_maker { - my ($self) = @_; - unless ($self->_sql_maker) { +This returns the B available C<$dbh> if any, or attempts to +connect and returns the resulting handle. This method differs from +L by not validating if a preexisting handle is still healthy +via L. Make sure you take appropriate precautions +when using this method, as the C<$dbh> may be useless at this point. + +=cut + +sub last_dbh { + my $self = shift; + $self->_populate_dbh unless $self->_dbh; + return $self->_dbh; +} + +sub _sql_maker_args { + my ($self) = @_; + + return ( + bindtype=>'columns', + array_datatypes => 1, + limit_dialect => $self->last_dbh, + %{$self->_sql_maker_opts} + ); +} + +sub sql_maker { + my ($self) = @_; + unless ($self->_sql_maker) { my $sql_maker_class = $self->sql_maker_class; + $self->ensure_class_loaded ($sql_maker_class); $self->_sql_maker($sql_maker_class->new( $self->_sql_maker_args )); } return $self->_sql_maker; } +sub _rebless {} + sub _populate_dbh { my ($self) = @_; + my @info = @{$self->_dbi_connect_info || []}; $self->_dbh($self->_connect(@info)); + $self->_conn_pid($$); + $self->_conn_tid(threads->tid) if $INC{'threads.pm'}; + + $self->_determine_driver; + # Always set the transaction depth on connect, since # there is no transaction in progress by definition $self->{transaction_depth} = $self->_dbh_autocommit ? 0 : 1; - if(ref $self eq 'DBIx::Class::Storage::DBI') { - my $driver = $self->_dbh->{Driver}->{Name}; - if ($self->load_optional_class("DBIx::Class::Storage::DBI::${driver}")) { - bless $self, "DBIx::Class::Storage::DBI::${driver}"; - $self->_rebless() if $self->can('_rebless'); - } - } + $self->_run_connection_actions unless $self->{_in_determine_driver}; +} - my $connection_do = $self->on_connect_do; - $self->_do_connection_actions($connection_do) if ref($connection_do); +sub _run_connection_actions { + my $self = shift; + my @actions; - $self->_conn_pid($$); - $self->_conn_tid(threads->tid) if $INC{'threads.pm'}; + push @actions, ( $self->on_connect_call || () ); + push @actions, $self->_parse_connect_do ('on_connect_do'); + + $self->_do_connection_actions(connect_call_ => $_) for @actions; } -sub _do_connection_actions { - my $self = shift; - my $connection_do = shift; +sub _determine_driver { + my ($self) = @_; + + if (not $self->_driver_determined) { + my $started_unconnected = 0; + local $self->{_in_determine_driver} = 1; + + if (ref($self) eq __PACKAGE__) { + my $driver; + if ($self->_dbh) { # we are connected + $driver = $self->_dbh->{Driver}{Name}; + } else { + # try to use dsn to not require being connected, the driver may still + # force a connection in _rebless to determine version + ($driver) = $self->_dbi_connect_info->[0] =~ /dbi:([^:]+):/i; + $started_unconnected = 1; + } + + my $storage_class = "DBIx::Class::Storage::DBI::${driver}"; + if ($self->load_optional_class($storage_class)) { + mro::set_mro($storage_class, 'c3'); + bless $self, $storage_class; + $self->_rebless(); + } + } - if (ref $connection_do eq 'ARRAY') { - $self->_do_query($_) foreach @$connection_do; + $self->_driver_determined(1); + + $self->_run_connection_actions + if $started_unconnected && defined $self->_dbh; } - elsif (ref $connection_do eq 'CODE') { - $connection_do->(); +} + +sub _do_connection_actions { + my $self = shift; + my $method_prefix = shift; + my $call = shift; + + if (not ref($call)) { + my $method = $method_prefix . $call; + $self->$method(@_); + } elsif (ref($call) eq 'CODE') { + $self->$call(@_); + } elsif (ref($call) eq 'ARRAY') { + if (ref($call->[0]) ne 'ARRAY') { + $self->_do_connection_actions($method_prefix, $_) for @$call; + } else { + $self->_do_connection_actions($method_prefix, @$_) for @$call; + } + } else { + $self->throw_exception (sprintf ("Don't know how to process conection actions of type '%s'", ref($call)) ); } return $self; } +sub connect_call_do_sql { + my $self = shift; + $self->_do_query(@_); +} + +sub disconnect_call_do_sql { + my $self = shift; + $self->_do_query(@_); +} + +# override in db-specific backend when necessary +sub connect_call_datetime_setup { 1 } + sub _do_query { my ($self, $action) = @_; @@ -809,10 +905,18 @@ sub _do_query { $self->_do_query($_) foreach @$action; } else { - my @to_run = (ref $action eq 'ARRAY') ? (@$action) : ($action); - $self->_query_start(@to_run); - $self->_dbh->do(@to_run); - $self->_query_end(@to_run); + # Most debuggers expect ($sql, @bind), so we need to exclude + # the attribute hash which is the second argument to $dbh->do + # furthermore the bind values are usually to be presented + # as named arrayref pairs, so wrap those here too + my @do_args = (ref $action eq 'ARRAY') ? (@$action) : ($action); + my $sql = shift @do_args; + my $attrs = shift @do_args; + my @bind = map { [ undef, $_ ] } @do_args; + + $self->_query_start($sql, @bind); + $self->_dbh->do($sql, $attrs, @do_args); + $self->_query_end($sql, @bind); } return $self; @@ -841,9 +945,14 @@ sub _connect { if($dbh && !$self->unsafe) { my $weak_self = $self; - weaken($weak_self); + Scalar::Util::weaken($weak_self); $dbh->{HandleError} = sub { - $weak_self->throw_exception("DBI Exception: $_[0]") + if ($weak_self) { + $weak_self->throw_exception("DBI Exception: $_[0]"); + } + else { + croak ("DBI Exception: $_[0]"); + } }; $dbh->{ShowErrorStatement} = 1; $dbh->{RaiseError} = 1; @@ -861,17 +970,102 @@ sub _connect { $dbh; } +sub svp_begin { + my ($self, $name) = @_; + + $name = $self->_svp_generate_name + unless defined $name; + + $self->throw_exception ("You can't use savepoints outside a transaction") + if $self->{transaction_depth} == 0; + + $self->throw_exception ("Your Storage implementation doesn't support savepoints") + unless $self->can('_svp_begin'); + + push @{ $self->{savepoints} }, $name; + + $self->debugobj->svp_begin($name) if $self->debug; + + return $self->_svp_begin($name); +} + +sub svp_release { + my ($self, $name) = @_; + + $self->throw_exception ("You can't use savepoints outside a transaction") + if $self->{transaction_depth} == 0; + + $self->throw_exception ("Your Storage implementation doesn't support savepoints") + unless $self->can('_svp_release'); + + if (defined $name) { + $self->throw_exception ("Savepoint '$name' does not exist") + unless grep { $_ eq $name } @{ $self->{savepoints} }; + + # Dig through the stack until we find the one we are releasing. This keeps + # the stack up to date. + my $svp; + + do { $svp = pop @{ $self->{savepoints} } } while $svp ne $name; + } else { + $name = pop @{ $self->{savepoints} }; + } + + $self->debugobj->svp_release($name) if $self->debug; + + return $self->_svp_release($name); +} + +sub svp_rollback { + my ($self, $name) = @_; + + $self->throw_exception ("You can't use savepoints outside a transaction") + if $self->{transaction_depth} == 0; + + $self->throw_exception ("Your Storage implementation doesn't support savepoints") + unless $self->can('_svp_rollback'); + + if (defined $name) { + # If they passed us a name, verify that it exists in the stack + unless(grep({ $_ eq $name } @{ $self->{savepoints} })) { + $self->throw_exception("Savepoint '$name' does not exist!"); + } + + # Dig through the stack until we find the one we are releasing. This keeps + # the stack up to date. + while(my $s = pop(@{ $self->{savepoints} })) { + last if($s eq $name); + } + # Add the savepoint back to the stack, as a rollback doesn't remove the + # named savepoint, only everything after it. + push(@{ $self->{savepoints} }, $name); + } else { + # We'll assume they want to rollback to the last savepoint + $name = $self->{savepoints}->[-1]; + } + + $self->debugobj->svp_rollback($name) if $self->debug; + + return $self->_svp_rollback($name); +} + +sub _svp_generate_name { + my ($self) = @_; + + return 'savepoint_'.scalar(@{ $self->{'savepoints'} }); +} sub txn_begin { my $self = shift; - $self->ensure_connected(); if($self->{transaction_depth} == 0) { $self->debugobj->txn_begin() if $self->debug; # this isn't ->_dbh-> because # we should reconnect on begin_work # for AutoCommit users - $self->dbh->begin_work; + $self->_do_with_reconnect(sub { $_[1]->begin_work }); + } elsif ($self->auto_savepoint) { + $self->svp_begin; } $self->{transaction_depth}++; } @@ -887,7 +1081,9 @@ sub txn_commit { if $self->_dbh_autocommit; } elsif($self->{transaction_depth} > 1) { - $self->{transaction_depth}-- + $self->{transaction_depth}--; + $self->svp_release + if $self->auto_savepoint; } } @@ -904,6 +1100,10 @@ sub txn_rollback { } elsif($self->{transaction_depth} > 1) { $self->{transaction_depth}--; + if ($self->auto_savepoint) { + $self->svp_rollback; + $self->svp_release; + } } else { die DBIx::Class::Storage::NESTED_ROLLBACK_EXCEPTION->new; @@ -925,14 +1125,19 @@ sub txn_rollback { sub _prep_for_execute { my ($self, $op, $extra_bind, $ident, $args) = @_; + if( Scalar::Util::blessed($ident) && $ident->isa("DBIx::Class::ResultSource") ) { + $ident = $ident->from(); + } + my ($sql, @bind) = $self->sql_maker->$op($ident, @$args); + unshift(@bind, map { ref $_ eq 'ARRAY' ? $_ : [ '!!dummy', $_ ] } @$extra_bind) if $extra_bind; - return ($sql, \@bind); } + sub _fix_bind_params { my ($self, @bind) = @_; @@ -952,191 +1157,712 @@ sub _fix_bind_params { sub _query_start { my ( $self, $sql, @bind ) = @_; - if ( $self->debug ) { - @bind = $self->_fix_bind_params(@bind); - $self->debugobj->query_start( $sql, @bind ); - } -} + if ( $self->debug ) { + @bind = $self->_fix_bind_params(@bind); + + $self->debugobj->query_start( $sql, @bind ); + } +} + +sub _query_end { + my ( $self, $sql, @bind ) = @_; + + if ( $self->debug ) { + @bind = $self->_fix_bind_params(@bind); + $self->debugobj->query_end( $sql, @bind ); + } +} + +sub _dbh_execute { + my ($self, $dbh, $op, $extra_bind, $ident, $bind_attributes, @args) = @_; + + my ($sql, $bind) = $self->_prep_for_execute($op, $extra_bind, $ident, \@args); + + $self->_query_start( $sql, @$bind ); + + my $sth = $self->sth($sql,$op); + + my $placeholder_index = 1; + + foreach my $bound (@$bind) { + my $attributes = {}; + my($column_name, @data) = @$bound; + + if ($bind_attributes) { + $attributes = $bind_attributes->{$column_name} + if defined $bind_attributes->{$column_name}; + } + + foreach my $data (@data) { + my $ref = ref $data; + $data = $ref && $ref ne 'ARRAY' ? ''.$data : $data; # stringify args (except arrayrefs) + + $sth->bind_param($placeholder_index, $data, $attributes); + $placeholder_index++; + } + } + + # Can this fail without throwing an exception anyways??? + my $rv = $sth->execute(); + $self->throw_exception($sth->errstr) if !$rv; + + $self->_query_end( $sql, @$bind ); + + return (wantarray ? ($rv, $sth, @$bind) : $rv); +} + +sub _execute { + my $self = shift; + $self->dbh_do('_dbh_execute', @_) +} + +sub insert { + my ($self, $source, $to_insert) = @_; + +# redispatch to insert method of storage we reblessed into, if necessary + if (not $self->_driver_determined) { + $self->_determine_driver; + goto $self->can('insert'); + } + + my $ident = $source->from; + my $bind_attributes = $self->source_bind_attributes($source); + + my $updated_cols = {}; + + foreach my $col ( $source->columns ) { + if ( !defined $to_insert->{$col} ) { + my $col_info = $source->column_info($col); + + if ( $col_info->{auto_nextval} ) { + $updated_cols->{$col} = $to_insert->{$col} = $self->_sequence_fetch( + 'nextval', + $col_info->{sequence} || + $self->_dbh_get_autoinc_seq($self->last_dbh, $source) + ); + } + } + } + + $self->_execute('insert' => [], $source, $bind_attributes, $to_insert); + + return $updated_cols; +} + +## Still not quite perfect, and EXPERIMENTAL +## Currently it is assumed that all values passed will be "normal", i.e. not +## scalar refs, or at least, all the same type as the first set, the statement is +## only prepped once. +sub insert_bulk { + my ($self, $source, $cols, $data) = @_; + my %colvalues; + my $table = $source->from; + @colvalues{@$cols} = (0..$#$cols); + my ($sql, @bind) = $self->sql_maker->insert($table, \%colvalues); + + $self->_determine_driver; + + $self->_query_start( $sql, @bind ); + my $sth = $self->sth($sql); + +# @bind = map { ref $_ ? ''.$_ : $_ } @bind; # stringify args + + ## This must be an arrayref, else nothing works! + my $tuple_status = []; + + ## Get the bind_attributes, if any exist + my $bind_attributes = $self->source_bind_attributes($source); + + ## Bind the values and execute + my $placeholder_index = 1; + + foreach my $bound (@bind) { + + my $attributes = {}; + my ($column_name, $data_index) = @$bound; + + if( $bind_attributes ) { + $attributes = $bind_attributes->{$column_name} + if defined $bind_attributes->{$column_name}; + } + + my @data = map { $_->[$data_index] } @$data; + + $sth->bind_param_array( $placeholder_index, [@data], $attributes ); + $placeholder_index++; + } + my $rv = eval { $sth->execute_array({ArrayTupleStatus => $tuple_status}) }; + if (my $err = $@) { + my $i = 0; + ++$i while $i <= $#$tuple_status && !ref $tuple_status->[$i]; + + $self->throw_exception($sth->errstr || "Unexpected populate error: $err") + if ($i > $#$tuple_status); + + require Data::Dumper; + local $Data::Dumper::Terse = 1; + local $Data::Dumper::Indent = 1; + local $Data::Dumper::Useqq = 1; + local $Data::Dumper::Quotekeys = 0; + + $self->throw_exception(sprintf "%s for populate slice:\n%s", + $tuple_status->[$i][1], + Data::Dumper::Dumper( + { map { $cols->[$_] => $data->[$i][$_] } (0 .. $#$cols) } + ), + ); + } + $self->throw_exception($sth->errstr) if !$rv; + + $self->_query_end( $sql, @bind ); + return (wantarray ? ($rv, $sth, @bind) : $rv); +} + +sub update { + my $self = shift @_; + my $source = shift @_; + $self->_determine_driver; + my $bind_attributes = $self->source_bind_attributes($source); + + return $self->_execute('update' => [], $source, $bind_attributes, @_); +} + + +sub delete { + my $self = shift @_; + my $source = shift @_; + $self->_determine_driver; + my $bind_attrs = $self->source_bind_attributes($source); + + return $self->_execute('delete' => [], $source, $bind_attrs, @_); +} + +# We were sent here because the $rs contains a complex search +# which will require a subquery to select the correct rows +# (i.e. joined or limited resultsets) +# +# Genarating a single PK column subquery is trivial and supported +# by all RDBMS. However if we have a multicolumn PK, things get ugly. +# Look at _multipk_update_delete() +sub _subq_update_delete { + my $self = shift; + my ($rs, $op, $values) = @_; + + my $rsrc = $rs->result_source; + + # we already check this, but double check naively just in case. Should be removed soon + my $sel = $rs->_resolved_attrs->{select}; + $sel = [ $sel ] unless ref $sel eq 'ARRAY'; + my @pcols = $rsrc->primary_columns; + if (@$sel != @pcols) { + $self->throw_exception ( + 'Subquery update/delete can not be called on resultsets selecting a' + .' number of columns different than the number of primary keys' + ); + } + + if (@pcols == 1) { + return $self->$op ( + $rsrc, + $op eq 'update' ? $values : (), + { $pcols[0] => { -in => $rs->as_query } }, + ); + } + + else { + return $self->_multipk_update_delete (@_); + } +} + +# ANSI SQL does not provide a reliable way to perform a multicol-PK +# resultset update/delete involving subqueries. So by default resort +# to simple (and inefficient) delete_all style per-row opearations, +# while allowing specific storages to override this with a faster +# implementation. +# +sub _multipk_update_delete { + return shift->_per_row_update_delete (@_); +} + +# This is the default loop used to delete/update rows for multi PK +# resultsets, and used by mysql exclusively (because it can't do anything +# else). +# +# We do not use $row->$op style queries, because resultset update/delete +# is not expected to cascade (this is what delete_all/update_all is for). +# +# There should be no race conditions as the entire operation is rolled +# in a transaction. +# +sub _per_row_update_delete { + my $self = shift; + my ($rs, $op, $values) = @_; + + my $rsrc = $rs->result_source; + my @pcols = $rsrc->primary_columns; + + my $guard = $self->txn_scope_guard; + + # emulate the return value of $sth->execute for non-selects + my $row_cnt = '0E0'; + + my $subrs_cur = $rs->cursor; + while (my @pks = $subrs_cur->next) { + + my $cond; + for my $i (0.. $#pcols) { + $cond->{$pcols[$i]} = $pks[$i]; + } + + $self->$op ( + $rsrc, + $op eq 'update' ? $values : (), + $cond, + ); + + $row_cnt++; + } + + $guard->commit; + + return $row_cnt; +} + +sub _select { + my $self = shift; + + # localization is neccessary as + # 1) there is no infrastructure to pass this around before SQLA2 + # 2) _select_args sets it and _prep_for_execute consumes it + my $sql_maker = $self->sql_maker; + local $sql_maker->{_dbic_rs_attrs}; + + return $self->_execute($self->_select_args(@_)); +} + +sub _select_args_to_query { + my $self = shift; + + # localization is neccessary as + # 1) there is no infrastructure to pass this around before SQLA2 + # 2) _select_args sets it and _prep_for_execute consumes it + my $sql_maker = $self->sql_maker; + local $sql_maker->{_dbic_rs_attrs}; + + # my ($op, $bind, $ident, $bind_attrs, $select, $cond, $order, $rows, $offset) + # = $self->_select_args($ident, $select, $cond, $attrs); + my ($op, $bind, $ident, $bind_attrs, @args) = + $self->_select_args(@_); + + # my ($sql, $prepared_bind) = $self->_prep_for_execute($op, $bind, $ident, [ $select, $cond, $order, $rows, $offset ]); + my ($sql, $prepared_bind) = $self->_prep_for_execute($op, $bind, $ident, \@args); + $prepared_bind ||= []; + + return wantarray + ? ($sql, $prepared_bind, $bind_attrs) + : \[ "($sql)", @$prepared_bind ] + ; +} + +sub _select_args { + my ($self, $ident, $select, $where, $attrs) = @_; + + my ($alias2source, $rs_alias) = $self->_resolve_ident_sources ($ident); + + my $sql_maker = $self->sql_maker; + $sql_maker->{_dbic_rs_attrs} = { + %$attrs, + select => $select, + from => $ident, + where => $where, + $rs_alias + ? ( _source_handle => $alias2source->{$rs_alias}->handle ) + : () + , + }; + + # calculate bind_attrs before possible $ident mangling + my $bind_attrs = {}; + for my $alias (keys %$alias2source) { + my $bindtypes = $self->source_bind_attributes ($alias2source->{$alias}) || {}; + for my $col (keys %$bindtypes) { + + my $fqcn = join ('.', $alias, $col); + $bind_attrs->{$fqcn} = $bindtypes->{$col} if $bindtypes->{$col}; + + # Unqialified column names are nice, but at the same time can be + # rather ambiguous. What we do here is basically go along with + # the loop, adding an unqualified column slot to $bind_attrs, + # alongside the fully qualified name. As soon as we encounter + # another column by that name (which would imply another table) + # we unset the unqualified slot and never add any info to it + # to avoid erroneous type binding. If this happens the users + # only choice will be to fully qualify his column name + + if (exists $bind_attrs->{$col}) { + $bind_attrs->{$col} = {}; + } + else { + $bind_attrs->{$col} = $bind_attrs->{$fqcn}; + } + } + } + + # adjust limits + if ( + $attrs->{software_limit} + || + $sql_maker->_default_limit_syntax eq "GenericSubQ" + ) { + $attrs->{software_limit} = 1; + } + else { + $self->throw_exception("rows attribute must be positive if present") + if (defined($attrs->{rows}) && !($attrs->{rows} > 0)); + + # MySQL actually recommends this approach. I cringe. + $attrs->{rows} = 2**48 if not defined $attrs->{rows} and defined $attrs->{offset}; + } + + my @limit; + + # see if we need to tear the prefetch apart (either limited has_many or grouped prefetch) + # otherwise delegate the limiting to the storage, unless software limit was requested + if ( + ( $attrs->{rows} && keys %{$attrs->{collapse}} ) + || + ( $attrs->{group_by} && @{$attrs->{group_by}} && + $attrs->{_prefetch_select} && @{$attrs->{_prefetch_select}} ) + ) { + ($ident, $select, $where, $attrs) + = $self->_adjust_select_args_for_complex_prefetch ($ident, $select, $where, $attrs); + } + elsif (! $attrs->{software_limit} ) { + push @limit, $attrs->{rows}, $attrs->{offset}; + } -sub _query_end { - my ( $self, $sql, @bind ) = @_; +### + # This would be the point to deflate anything found in $where + # (and leave $attrs->{bind} intact). Problem is - inflators historically + # expect a row object. And all we have is a resultsource (it is trivial + # to extract deflator coderefs via $alias2source above). + # + # I don't see a way forward other than changing the way deflators are + # invoked, and that's just bad... +### + + my $order = { map + { $attrs->{$_} ? ( $_ => $attrs->{$_} ) : () } + (qw/order_by group_by having/ ) + }; - if ( $self->debug ) { - @bind = $self->_fix_bind_params(@bind); - $self->debugobj->query_end( $sql, @bind ); - } + return ('select', $attrs->{bind}, $ident, $bind_attrs, $select, $where, $order, @limit); } -sub _dbh_execute { - my ($self, $dbh, $op, $extra_bind, $ident, $bind_attributes, @args) = @_; - - if( blessed($ident) && $ident->isa("DBIx::Class::ResultSource") ) { - $ident = $ident->from(); - } - - my ($sql, $bind) = $self->_prep_for_execute($op, $extra_bind, $ident, \@args); +# +# This is the code producing joined subqueries like: +# SELECT me.*, other.* FROM ( SELECT me.* FROM ... ) JOIN other ON ... +# +sub _adjust_select_args_for_complex_prefetch { + my ($self, $from, $select, $where, $attrs) = @_; - $self->_query_start( $sql, @$bind ); + $self->throw_exception ('Complex prefetches are not supported on resultsets with a custom from attribute') + if (ref $from ne 'ARRAY'); - my $sth = $self->sth($sql,$op); + # copies for mangling + $from = [ @$from ]; + $select = [ @$select ]; + $attrs = { %$attrs }; - my $placeholder_index = 1; + # separate attributes + my $sub_attrs = { %$attrs }; + delete $attrs->{$_} for qw/where bind rows offset group_by having/; + delete $sub_attrs->{$_} for qw/for collapse _prefetch_select _collapse_order_by select as/; - foreach my $bound (@$bind) { - my $attributes = {}; - my($column_name, @data) = @$bound; + my $select_root_alias = $attrs->{alias}; + my $sql_maker = $self->sql_maker; - if ($bind_attributes) { - $attributes = $bind_attributes->{$column_name} - if defined $bind_attributes->{$column_name}; + # create subquery select list - consider only stuff *not* brought in by the prefetch + my $sub_select = []; + my $sub_group_by; + for my $i (0 .. @{$attrs->{select}} - @{$attrs->{_prefetch_select}} - 1) { + my $sel = $attrs->{select}[$i]; + + # alias any functions to the dbic-side 'as' label + # adjust the outer select accordingly + if (ref $sel eq 'HASH' && !$sel->{-select}) { + $sel = { -select => $sel, -as => $attrs->{as}[$i] }; + $select->[$i] = join ('.', $attrs->{alias}, ($attrs->{as}[$i] || "select_$i") ); } - foreach my $data (@data) { - $data = ref $data ? ''.$data : $data; # stringify args + push @$sub_select, $sel; + } - $sth->bind_param($placeholder_index, $data, $attributes); - $placeholder_index++; - } + # bring over all non-collapse-induced order_by into the inner query (if any) + # the outer one will have to keep them all + delete $sub_attrs->{order_by}; + if (my $ord_cnt = @{$attrs->{order_by}} - @{$attrs->{_collapse_order_by}} ) { + $sub_attrs->{order_by} = [ + @{$attrs->{order_by}}[ 0 .. $ord_cnt - 1] + ]; } - # Can this fail without throwing an exception anyways??? - my $rv = $sth->execute(); - $self->throw_exception($sth->errstr) if !$rv; + # mangle {from}, keep in mind that $from is "headless" from here on + my $join_root = shift @$from; + + my %inner_joins; + my %join_info = map { $_->[0]{-alias} => $_->[0] } (@$from); + + # in complex search_related chains $select_root_alias may *not* be + # 'me' so always include it in the inner join + $inner_joins{$select_root_alias} = 1 if ($join_root->{-alias} ne $select_root_alias); + + + # decide which parts of the join will remain on the inside + # + # this is not a very viable optimisation, but it was written + # before I realised this, so might as well remain. We can throw + # away _any_ branches of the join tree that are: + # 1) not mentioned in the condition/order + # 2) left-join leaves (or left-join leaf chains) + # Most of the join conditions will not satisfy this, but for real + # complex queries some might, and we might make some RDBMS happy. + # + # + # since we do not have introspectable SQLA, we fall back to ugly + # scanning of raw SQL for WHERE, and for pieces of ORDER BY + # in order to determine what goes into %inner_joins + # It may not be very efficient, but it's a reasonable stop-gap + { + # produce stuff unquoted, so it can be scanned + local $sql_maker->{quote_char}; + my $sep = $self->_sql_maker_opts->{name_sep} || '.'; + $sep = "\Q$sep\E"; + + my @order_by = (map + { ref $_ ? $_->[0] : $_ } + $sql_maker->_order_by_chunks ($sub_attrs->{order_by}) + ); - $self->_query_end( $sql, @$bind ); + my $where_sql = $sql_maker->where ($where); + my $select_sql = $sql_maker->_recurse_fields ($sub_select); - return (wantarray ? ($rv, $sth, @$bind) : $rv); -} + # sort needed joins + for my $alias (keys %join_info) { -sub _execute { - my $self = shift; - $self->dbh_do($self->can('_dbh_execute'), @_) -} + # any table alias found on a column name in where or order_by + # gets included in %inner_joins + # Also any parent joins that are needed to reach this particular alias + for my $piece ($select_sql, $where_sql, @order_by ) { + if ($piece =~ /\b $alias $sep/x) { + $inner_joins{$alias} = 1; + } + } + } + } -sub insert { - my ($self, $source, $to_insert) = @_; - - my $ident = $source->from; - my $bind_attributes = $self->source_bind_attributes($source); + # scan for non-leaf/non-left joins and mark as needed + # also mark all ancestor joins that are needed to reach this particular alias + # (e.g. join => { cds => 'tracks' } - tracks will bring cds too ) + # + # traverse by the size of the -join_path i.e. reverse depth first + for my $alias (sort { @{$join_info{$b}{-join_path}} <=> @{$join_info{$a}{-join_path}} } (keys %join_info) ) { - $self->_execute('insert' => [], $source, $bind_attributes, $to_insert); + my $j = $join_info{$alias}; + $inner_joins{$alias} = 1 if (! $j->{-join_type} || ($j->{-join_type} !~ /^left$/i) ); - return $to_insert; -} + if ($inner_joins{$alias}) { + $inner_joins{$_} = 1 for (@{$j->{-join_path}}); + } + } -## Still not quite perfect, and EXPERIMENTAL -## Currently it is assumed that all values passed will be "normal", i.e. not -## scalar refs, or at least, all the same type as the first set, the statement is -## only prepped once. -sub insert_bulk { - my ($self, $source, $cols, $data) = @_; - my %colvalues; - my $table = $source->from; - @colvalues{@$cols} = (0..$#$cols); - my ($sql, @bind) = $self->sql_maker->insert($table, \%colvalues); - - $self->_query_start( $sql, @bind ); - my $sth = $self->sth($sql); + # construct the inner $from for the subquery + my $inner_from = [ $join_root ]; + for my $j (@$from) { + push @$inner_from, $j if $inner_joins{$j->[0]{-alias}}; + } -# @bind = map { ref $_ ? ''.$_ : $_ } @bind; # stringify args + # if a multi-type join was needed in the subquery ("multi" is indicated by + # presence in {collapse}) - add a group_by to simulate the collapse in the subq + unless ($sub_attrs->{group_by}) { + for my $alias (keys %inner_joins) { - ## This must be an arrayref, else nothing works! - - my $tuple_status = []; - - ##use Data::Dumper; - ##print STDERR Dumper( $data, $sql, [@bind] ); + # the dot comes from some weirdness in collapse + # remove after the rewrite + if ($attrs->{collapse}{".$alias"}) { + $sub_attrs->{group_by} ||= $sub_select; + last; + } + } + } - my $time = time(); + # generate the subquery + my $subq = $self->_select_args_to_query ( + $inner_from, + $sub_select, + $where, + $sub_attrs + ); + my $subq_joinspec = { + -alias => $select_root_alias, + -source_handle => $join_root->{-source_handle}, + $select_root_alias => $subq, + }; - ## Get the bind_attributes, if any exist - my $bind_attributes = $self->source_bind_attributes($source); + # Generate a new from (really just replace the join slot with the subquery) + # Before we would start the outer chain from the subquery itself (i.e. + # SELECT ... FROM (SELECT ... ) alias JOIN ..., but this turned out to be + # a bad idea for search_related, as the root of the chain was effectively + # lost (i.e. $artist_rs->search_related ('cds'... ) would result in alias + # of 'cds', which would prevent from doing things like order_by artist.*) + # See t/prefetch/via_search_related.t for a better idea + my @outer_from; + if ($join_root->{-alias} eq $select_root_alias) { # just swap the root part and we're done + @outer_from = ( + $subq_joinspec, + @$from, + ) + } + else { # this is trickier + @outer_from = ($join_root); + + for my $j (@$from) { + if ($j->[0]{-alias} eq $select_root_alias) { + push @outer_from, [ + $subq_joinspec, + @{$j}[1 .. $#$j], + ]; + } + else { + push @outer_from, $j; + } + } + } - ## Bind the values and execute - my $placeholder_index = 1; + # This is totally horrific - the $where ends up in both the inner and outer query + # Unfortunately not much can be done until SQLA2 introspection arrives, and even + # then if where conditions apply to the *right* side of the prefetch, you may have + # to both filter the inner select (e.g. to apply a limit) and then have to re-filter + # the outer select to exclude joins you didin't want in the first place + # + # OTOH it can be seen as a plus: (notes that this query would make a DBA cry ;) + return (\@outer_from, $select, $where, $attrs); +} - foreach my $bound (@bind) { +sub _resolve_ident_sources { + my ($self, $ident) = @_; - my $attributes = {}; - my ($column_name, $data_index) = @$bound; + my $alias2source = {}; + my $rs_alias; - if( $bind_attributes ) { - $attributes = $bind_attributes->{$column_name} - if defined $bind_attributes->{$column_name}; - } + # the reason this is so contrived is that $ident may be a {from} + # structure, specifying multiple tables to join + if ( Scalar::Util::blessed($ident) && $ident->isa("DBIx::Class::ResultSource") ) { + # this is compat mode for insert/update/delete which do not deal with aliases + $alias2source->{me} = $ident; + $rs_alias = 'me'; + } + elsif (ref $ident eq 'ARRAY') { - my @data = map { $_->[$data_index] } @$data; + for (@$ident) { + my $tabinfo; + if (ref $_ eq 'HASH') { + $tabinfo = $_; + $rs_alias = $tabinfo->{-alias}; + } + if (ref $_ eq 'ARRAY' and ref $_->[0] eq 'HASH') { + $tabinfo = $_->[0]; + } - $sth->bind_param_array( $placeholder_index, [@data], $attributes ); - $placeholder_index++; + $alias2source->{$tabinfo->{-alias}} = $tabinfo->{-source_handle}->resolve + if ($tabinfo->{-source_handle}); + } } - my $rv = $sth->execute_array({ArrayTupleStatus => $tuple_status}); - $self->throw_exception($sth->errstr) if !$rv; - - $self->_query_end( $sql, @bind ); - return (wantarray ? ($rv, $sth, @bind) : $rv); -} -sub update { - my $self = shift @_; - my $source = shift @_; - my $bind_attributes = $self->source_bind_attributes($source); - - return $self->_execute('update' => [], $source, $bind_attributes, @_); + return ($alias2source, $rs_alias); } +# Takes $ident, \@column_names +# +# returns { $column_name => \%column_info, ... } +# also note: this adds -result_source => $rsrc to the column info +# +# usage: +# my $col_sources = $self->_resolve_column_info($ident, @column_names); +sub _resolve_column_info { + my ($self, $ident, $colnames) = @_; + my ($alias2src, $root_alias) = $self->_resolve_ident_sources($ident); -sub delete { - my $self = shift @_; - my $source = shift @_; - - my $bind_attrs = {}; ## If ever it's needed... - - return $self->_execute('delete' => [], $source, $bind_attrs, @_); -} + my $sep = $self->_sql_maker_opts->{name_sep} || '.'; + $sep = "\Q$sep\E"; -sub _select { - my ($self, $ident, $select, $condition, $attrs) = @_; - my $order = $attrs->{order_by}; + my (%return, %seen_cols); - if (ref $condition eq 'SCALAR') { - $order = $1 if $$condition =~ s/ORDER BY (.*)$//i; + # compile a global list of column names, to be able to properly + # disambiguate unqualified column names (if at all possible) + for my $alias (keys %$alias2src) { + my $rsrc = $alias2src->{$alias}; + for my $colname ($rsrc->columns) { + push @{$seen_cols{$colname}}, $alias; + } } - my $for = delete $attrs->{for}; - my $sql_maker = $self->sql_maker; - local $sql_maker->{for} = $for; + COLUMN: + foreach my $col (@$colnames) { + my ($alias, $colname) = $col =~ m/^ (?: ([^$sep]+) $sep)? (.+) $/x; + + unless ($alias) { + # see if the column was seen exactly once (so we know which rsrc it came from) + if ($seen_cols{$colname} and @{$seen_cols{$colname}} == 1) { + $alias = $seen_cols{$colname}[0]; + } + else { + next COLUMN; + } + } - if (exists $attrs->{group_by} || $attrs->{having}) { - $order = { - group_by => $attrs->{group_by}, - having => $attrs->{having}, - ($order ? (order_by => $order) : ()) + my $rsrc = $alias2src->{$alias}; + $return{$col} = $rsrc && { + %{$rsrc->column_info($colname)}, + -result_source => $rsrc, + -source_alias => $alias, }; } - my $bind_attrs = {}; ## Future support - my @args = ('select', $attrs->{bind}, $ident, $bind_attrs, $select, $condition, $order); - if ($attrs->{software_limit} || - $self->sql_maker->_default_limit_syntax eq "GenericSubQ") { - $attrs->{software_limit} = 1; - } else { - $self->throw_exception("rows attribute must be positive if present") - if (defined($attrs->{rows}) && !($attrs->{rows} > 0)); - # MySQL actually recommends this approach. I cringe. - $attrs->{rows} = 2**48 if not defined $attrs->{rows} and defined $attrs->{offset}; - push @args, $attrs->{rows}, $attrs->{offset}; - } + return \%return; +} + +# Returns a counting SELECT for a simple count +# query. Abstracted so that a storage could override +# this to { count => 'firstcol' } or whatever makes +# sense as a performance optimization +sub _count_select { + #my ($self, $source, $rs_attrs) = @_; + return { count => '*' }; +} - return $self->_execute(@args); +# Returns a SELECT which will end up in the subselect +# There may or may not be a group_by, as the subquery +# might have been called to accomodate a limit +# +# Most databases would be happy with whatever ends up +# here, but some choke in various ways. +# +sub _subq_count_select { + my ($self, $source, $rs_attrs) = @_; + return $rs_attrs->{group_by} if $rs_attrs->{group_by}; + + my @pcols = map { join '.', $rs_attrs->{alias}, $_ } ($source->primary_columns); + return @pcols ? \@pcols : [ 1 ]; } + sub source_bind_attributes { my ($self, $source) = @_; - + my $bind_attributes; foreach my $column ($source->columns) { - + my $data_type = $source->column_info($column)->{data_type} || ''; $bind_attributes->{$column} = $self->bind_attribute_by_data_type($data_type) if $data_type; @@ -1167,6 +1893,10 @@ sub select_single { my $self = shift; my ($rv, $sth, @bind) = $self->_select(@_); my @row = $sth->fetchrow_array; + my @nextrow = $sth->fetchrow_array if @row; + if(@row && @nextrow) { + carp "Query returned more than one row. SQL that returns multiple rows is DEPRECATED for ->find and ->single"; + } # Need to call finish() to work round broken DBDs $sth->finish(); return @row; @@ -1201,7 +1931,7 @@ sub _dbh_sth { sub sth { my ($self, $sql) = @_; - $self->dbh_do($self->can('_dbh_sth'), $sql); + $self->dbh_do('_dbh_sth', $sql); } sub _dbh_columns_info_for { @@ -1263,7 +1993,7 @@ sub _dbh_columns_info_for { sub columns_info_for { my ($self, $table) = @_; - $self->dbh_do($self->can('_dbh_columns_info_for'), $table); + $self->dbh_do('_dbh_columns_info_for', $table); } =head2 last_insert_id @@ -1273,14 +2003,23 @@ Return the row id of the last insert. =cut sub _dbh_last_insert_id { - my ($self, $dbh, $source, $col) = @_; - # XXX This is a SQLite-ism as a default... is there a DBI-generic way? - $dbh->func('last_insert_rowid'); + # All Storage's need to register their own _dbh_last_insert_id + # the old SQLite-based method was highly inappropriate + + my $self = shift; + my $class = ref $self; + $self->throw_exception (<dbh_do($self->can('_dbh_last_insert_id'), @_); + $self->dbh_do('_dbh_last_insert_id', @_); } =head2 sqlt_type @@ -1289,13 +2028,13 @@ Returns the database driver name. =cut -sub sqlt_type { shift->dbh->{Driver}->{Name} } +sub sqlt_type { shift->last_dbh->{Driver}->{Name} } =head2 bind_attribute_by_data_type -Given a datatype from column info, returns a database specific bind attribute for -$dbh->bind_param($val,$attribute) or nothing if we will let the database planner -just handle it. +Given a datatype from column info, returns a database specific bind +attribute for C<< $dbh->bind_param($val,$attribute) >> or nothing if we will +let the database planner just handle it. Generally only needed for special case column types, like bytea in postgres. @@ -1305,145 +2044,208 @@ sub bind_attribute_by_data_type { return; } -=head2 create_ddl_dir +=head2 is_datatype_numeric + +Given a datatype from column_info, returns a boolean value indicating if +the current RDBMS considers it a numeric value. This controls how +L decides whether to mark the column as +dirty - when the datatype is deemed numeric a C<< != >> comparison will +be performed instead of the usual C. + +=cut + +sub is_datatype_numeric { + my ($self, $dt) = @_; + + return 0 unless $dt; + + return $dt =~ /^ (?: + numeric | int(?:eger)? | (?:tiny|small|medium|big)int | dec(?:imal)? | real | float | double (?: \s+ precision)? | (?:big)?serial + ) $/ix; +} + + +=head2 create_ddl_dir (EXPERIMENTAL) =over 4 -=item Arguments: $schema \@databases, $version, $directory, $preversion, $sqlt_args +=item Arguments: $schema \@databases, $version, $directory, $preversion, \%sqlt_args =back Creates a SQL file based on the Schema, for each of the specified -database types, in the given directory. +database engines in C<\@databases> in the given directory. +(note: specify L names, not L driver names). + +Given a previous version number, this will also create a file containing +the ALTER TABLE statements to transform the previous schema into the +current one. Note that these statements may contain C or +C statements that can potentially destroy data. + +The file names are created using the C method below, please +override this method in your schema if you would like a different file +name format. For the ALTER file, the same format is used, replacing +$version in the name with "$preversion-$version". + +See L for a list of values for C<\%sqlt_args>. +The most common value for this would be C<< { add_drop_table => 1 } >> +to have the SQL produced include a C statement for each table +created. For quoting purposes supply C and +C. + +If no arguments are passed, then the following default values are assumed: + +=over 4 + +=item databases - ['MySQL', 'SQLite', 'PostgreSQL'] + +=item version - $schema->schema_version + +=item directory - './' + +=item preversion - + +=back + +By default, C<\%sqlt_args> will have + + { add_drop_table => 1, ignore_constraint_names => 1, ignore_index_names => 1 } + +merged with the hash passed in. To disable any of those features, pass in a +hashref like the following + + { ignore_constraint_names => 0, # ... other options } + + +Note that this feature is currently EXPERIMENTAL and may not work correctly +across all databases, or fully handle complex relationships. + +WARNING: Please check all SQL files created, before applying them. =cut -sub create_ddl_dir -{ +sub create_ddl_dir { my ($self, $schema, $databases, $version, $dir, $preversion, $sqltargs) = @_; - if(!$dir || !-d $dir) - { - warn "No directory given, using ./\n"; + if(!$dir || !-d $dir) { + carp "No directory given, using ./\n"; $dir = "./"; } $databases ||= ['MySQL', 'SQLite', 'PostgreSQL']; $databases = [ $databases ] if(ref($databases) ne 'ARRAY'); - $version ||= $schema->VERSION || '1.x'; - $sqltargs = { ( add_drop_table => 1 ), %{$sqltargs || {}} }; - $self->throw_exception(q{Can't create a ddl file without SQL::Translator 0.09: '} + my $schema_version = $schema->schema_version || '1.x'; + $version ||= $schema_version; + + $sqltargs = { + add_drop_table => 1, + ignore_constraint_names => 1, + ignore_index_names => 1, + %{$sqltargs || {}} + }; + + $self->throw_exception(q{Can't create a ddl file without SQL::Translator 0.09003: '} . $self->_check_sqlt_message . q{'}) if !$self->_check_sqlt_version; - my $sqlt = SQL::Translator->new({ - add_drop_table => 1, - }); + my $sqlt = SQL::Translator->new( $sqltargs ); $sqlt->parser('SQL::Translator::Parser::DBIx::Class'); - my $sqlt_schema = $sqlt->translate({ data => $schema }) or die $sqlt->error; + my $sqlt_schema = $sqlt->translate({ data => $schema }) + or $self->throw_exception ($sqlt->error); - foreach my $db (@$databases) - { + foreach my $db (@$databases) { $sqlt->reset(); - $sqlt = $self->configure_sqlt($sqlt, $db); $sqlt->{schema} = $sqlt_schema; $sqlt->producer($db); my $file; - my $filename = $schema->ddl_filename($db, $dir, $version); - if(-e $filename) - { - warn("$filename already exists, skipping $db"); - next unless ($preversion); - } else { - my $output = $sqlt->translate; - if(!$output) - { - warn("Failed to translate to $db, skipping. (" . $sqlt->error . ")"); - next; - } - if(!open($file, ">$filename")) - { - $self->throw_exception("Can't open $filename for writing ($!)"); - next; - } - print $file $output; - close($file); - } - if($preversion) + my $filename = $schema->ddl_filename($db, $version, $dir); + if (-e $filename && ($version eq $schema_version )) { + # if we are dumping the current version, overwrite the DDL + carp "Overwriting existing DDL file - $filename"; + unlink($filename); + } + + my $output = $sqlt->translate; + if(!$output) { + carp("Failed to translate to $db, skipping. (" . $sqlt->error . ")"); + next; + } + if(!open($file, ">$filename")) { + $self->throw_exception("Can't open $filename for writing ($!)"); + next; + } + print $file $output; + close($file); + + next unless ($preversion); + + require SQL::Translator::Diff; + + my $prefilename = $schema->ddl_filename($db, $preversion, $dir); + if(!-e $prefilename) { + carp("No previous schema file found ($prefilename)"); + next; + } + + my $difffile = $schema->ddl_filename($db, $version, $dir, $preversion); + if(-e $difffile) { + carp("Overwriting existing diff file - $difffile"); + unlink($difffile); + } + + my $source_schema; { - require SQL::Translator::Diff; + my $t = SQL::Translator->new($sqltargs); + $t->debug( 0 ); + $t->trace( 0 ); - my $prefilename = $schema->ddl_filename($db, $dir, $preversion); -# print "Previous version $prefilename\n"; - if(!-e $prefilename) - { - warn("No previous schema file found ($prefilename)"); - next; - } + $t->parser( $db ) + or $self->throw_exception ($t->error); - my $difffile = $schema->ddl_filename($db, $dir, $version, $preversion); - print STDERR "Diff: $difffile: $db, $dir, $version, $preversion \n"; - if(-e $difffile) - { - warn("$difffile already exists, skipping"); - next; - } + my $out = $t->translate( $prefilename ) + or $self->throw_exception ($t->error); - my $source_schema; - { - my $t = SQL::Translator->new; - $t->debug( 0 ); - $t->trace( 0 ); - $t->parser( $db ) or die $t->error; - my $out = $t->translate( $prefilename ) or die $t->error; - $source_schema = $t->schema; - unless ( $source_schema->name ) { - $source_schema->name( $prefilename ); - } - } + $source_schema = $t->schema; - # The "new" style of producers have sane normalization and can support - # diffing a SQL file against a DBIC->SQLT schema. Old style ones don't - # And we have to diff parsed SQL against parsed SQL. - my $dest_schema = $sqlt_schema; - - unless ( "SQL::Translator::Producer::$db"->can('preprocess_schema') ) { - my $t = SQL::Translator->new; - $t->debug( 0 ); - $t->trace( 0 ); - $t->parser( $db ) or die $t->error; - my $out = $t->translate( $filename ) or die $t->error; - $dest_schema = $t->schema; - $dest_schema->name( $filename ) - unless $dest_schema->name; - } + $source_schema->name( $prefilename ) + unless ( $source_schema->name ); + } - my $diff = SQL::Translator::Diff::schema_diff($source_schema, $db, - $dest_schema, $db, - {} - ); - if(!open $file, ">$difffile") - { - $self->throw_exception("Can't write to $difffile ($!)"); - next; - } - print $file $diff; - close($file); + # The "new" style of producers have sane normalization and can support + # diffing a SQL file against a DBIC->SQLT schema. Old style ones don't + # And we have to diff parsed SQL against parsed SQL. + my $dest_schema = $sqlt_schema; + + unless ( "SQL::Translator::Producer::$db"->can('preprocess_schema') ) { + my $t = SQL::Translator->new($sqltargs); + $t->debug( 0 ); + $t->trace( 0 ); + + $t->parser( $db ) + or $self->throw_exception ($t->error); + + my $out = $t->translate( $filename ) + or $self->throw_exception ($t->error); + + $dest_schema = $t->schema; + + $dest_schema->name( $filename ) + unless $dest_schema->name; } - } -} -sub configure_sqlt() { - my $self = shift; - my $tr = shift; - my $db = shift || $self->sqlt_type; - if ($db eq 'PostgreSQL') { - $tr->quote_table_names(0); - $tr->quote_field_names(0); + my $diff = SQL::Translator::Diff::schema_diff($source_schema, $db, + $dest_schema, $db, + $sqltargs + ); + if(!open $file, ">$difffile") { + $self->throw_exception("Can't write to $difffile ($!)"); + next; + } + print $file $diff; + close($file); } - return $tr; } =head2 deployment_statements @@ -1455,8 +2257,9 @@ sub configure_sqlt() { =back Returns the statements used by L and L. -The database driver name is given by C<$type>, though the value from -L is used if it is not specified. + +The L (not L) database driver name can be explicitly +provided in C<$type>, otherwise the result of L is used as default. C<$directory> is used to return statements from files in a previously created L directory and is optional. The filenames are constructed @@ -1472,22 +2275,22 @@ See L for a list of values for C<$sqlt_args>. sub deployment_statements { my ($self, $schema, $type, $version, $dir, $sqltargs) = @_; # Need to be connected to get the correct sqlt_type - $self->ensure_connected() unless $type; + $self->last_dbh() unless $type; $type ||= $self->sqlt_type; - $version ||= $schema->VERSION || '1.x'; + $version ||= $schema->schema_version || '1.x'; $dir ||= './'; - my $filename = $schema->ddl_filename($type, $dir, $version); + my $filename = $schema->ddl_filename($type, $version, $dir); if(-f $filename) { my $file; - open($file, "<$filename") + open($file, "<$filename") or $self->throw_exception("Can't open $filename ($!)"); my @rows = <$file>; close($file); return join('', @rows); } - $self->throw_exception(q{Can't deploy without SQL::Translator 0.09: '} + $self->throw_exception(q{Can't deploy without SQL::Translator 0.09003: '} . $self->_check_sqlt_message . q{'}) if !$self->_check_sqlt_version; @@ -1495,7 +2298,7 @@ sub deployment_statements { eval qq{use SQL::Translator::Producer::${type}}; $self->throw_exception($@) if $@; - # sources needs to be a parser arg, but for simplicty allow at top level + # sources needs to be a parser arg, but for simplicty allow at top level # coming in $sqltargs->{parser_args}{sources} = delete $sqltargs->{sources} if exists $sqltargs->{sources}; @@ -1503,29 +2306,39 @@ sub deployment_statements { my $tr = SQL::Translator->new(%$sqltargs); SQL::Translator::Parser::DBIx::Class::parse( $tr, $schema ); return "SQL::Translator::Producer::${type}"->can('produce')->($tr); - - return; - } sub deploy { my ($self, $schema, $type, $sqltargs, $dir) = @_; - foreach my $statement ( $self->deployment_statements($schema, $type, undef, $dir, { no_comments => 1, %{ $sqltargs || {} } } ) ) { - foreach my $line ( split(";\n", $statement)) { - next if($line =~ /^--/); - next if(!$line); -# next if($line =~ /^DROP/m); - next if($line =~ /^BEGIN TRANSACTION/m); - next if($line =~ /^COMMIT/m); - next if $line =~ /^\s+$/; # skip whitespace only - $self->_query_start($line); - eval { - $self->dbh->do($line); # shouldn't be using ->dbh ? - }; - if ($@) { - warn qq{$@ (running "${line}")}; - } - $self->_query_end($line); + my $deploy = sub { + my $line = shift; + return if($line =~ /^--/); + return if(!$line); + # next if($line =~ /^DROP/m); + return if($line =~ /^BEGIN TRANSACTION/m); + return if($line =~ /^COMMIT/m); + return if $line =~ /^\s+$/; # skip whitespace only + $self->_query_start($line); + eval { + # a previous error may invalidate $dbh - thus we need to use dbh() + # to guarantee a healthy $dbh (this is temporary until we get + # proper error handling on deploy() ) + $self->dbh->do($line); + }; + if ($@) { + carp qq{$@ (running "${line}")}; + } + $self->_query_end($line); + }; + my @statements = $self->deployment_statements($schema, $type, undef, $dir, { %{ $sqltargs || {} }, no_comments => 1 } ); + if (@statements > 1) { + foreach my $statement (@statements) { + $deploy->( $statement ); + } + } + elsif (@statements == 1) { + foreach my $line ( split(";\n", $statements[0])) { + $deploy->( $line ); } } } @@ -1539,7 +2352,7 @@ Returns the datetime parser class sub datetime_parser { my $self = shift; return $self->{datetime_parser} ||= do { - $self->ensure_connected; + $self->last_dbh; $self->build_datetime_parser(@_); }; } @@ -1572,7 +2385,7 @@ sub build_datetime_parser { my $_check_sqlt_message; # private sub _check_sqlt_version { return $_check_sqlt_version if defined $_check_sqlt_version; - eval 'use SQL::Translator "0.09"'; + eval 'use SQL::Translator "0.09003"'; $_check_sqlt_message = $@ || ''; $_check_sqlt_version = !$@; } @@ -1583,49 +2396,57 @@ sub build_datetime_parser { } } -sub DESTROY { - my $self = shift; - return if !$self->_dbh; - $self->_verify_pid; - $self->_dbh(undef); -} - -1; +=head2 is_replicating -=head1 SQL METHODS +A boolean that reports if a particular L is set to +replicate from a master database. Default is undef, which is the result +returned by databases that don't support replication. -The module defines a set of methods within the DBIC::SQL::Abstract -namespace. These build on L to provide the -SQL query functions. +=cut -The following methods are extended:- +sub is_replicating { + return; -=over 4 +} -=item delete +=head2 lag_behind_master -=item insert +Returns a number that represents a certain amount of lag behind a master db +when a given storage is replicating. The number is database dependent, but +starts at zero and increases with the amount of lag. Default in undef -=item select +=cut -=item update +sub lag_behind_master { + return; +} -=item limit_dialect +sub DESTROY { + my $self = shift; + return if !$self->_dbh; + $self->_verify_pid; + $self->_dbh(undef); +} -See L for details. -For setting, this method is deprecated in favor of L. +1; -=item quote_char +=head1 USAGE NOTES -See L for details. -For setting, this method is deprecated in favor of L. +=head2 DBIx::Class and AutoCommit -=item name_sep +DBIx::Class can do some wonderful magic with handling exceptions, +disconnections, and transactions when you use C<< AutoCommit => 1 >> +(the default) combined with C for transaction support. -See L for details. -For setting, this method is deprecated in favor of L. +If you set C<< AutoCommit => 0 >> in your connect info, then you are always +in an assumed transaction between commits, and you're telling us you'd +like to manage that manually. A lot of the magic protections offered by +this module will go away. We can't protect you from exceptions due to database +disconnects because we don't know anything about how to restart your +transactions. You're on your own for handling all sorts of exceptional +cases if you choose the C<< AutoCommit => 0 >> path, just as you would +be with raw DBI. -=back =head1 AUTHORS