X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FDBIx%2FClass%2FStorage%2FDBI%2Fmysql.pm;h=06059834e00622bb9745e34a0b139625b6e12e4a;hb=b6a469f7;hp=486594e6a5a49c39c2ac29790ec4b799240682bf;hpb=406760d8097f4420dca9d141f7a397a290867938;p=dbsrgits%2FDBIx-Class.git diff --git a/lib/DBIx/Class/Storage/DBI/mysql.pm b/lib/DBIx/Class/Storage/DBI/mysql.pm index 486594e..0605983 100644 --- a/lib/DBIx/Class/Storage/DBI/mysql.pm +++ b/lib/DBIx/Class/Storage/DBI/mysql.pm @@ -3,13 +3,15 @@ package DBIx::Class::Storage::DBI::mysql; use strict; use warnings; -use base qw/ - DBIx::Class::Storage::DBI::MultiColumnIn - DBIx::Class::Storage::DBI -/; -use mro 'c3'; +use base qw/DBIx::Class::Storage::DBI/; -__PACKAGE__->sql_maker_class('DBIx::Class::SQLAHacks::MySQL'); +use namespace::clean; + +__PACKAGE__->sql_maker_class('DBIx::Class::SQLMaker::MySQL'); +__PACKAGE__->sql_limit_dialect ('LimitXY'); +__PACKAGE__->sql_quote_char ('`'); + +__PACKAGE__->_use_multicolumn_in (1); sub with_deferred_fk_checks { my ($self, $sub) = @_; @@ -32,41 +34,128 @@ sub _dbh_last_insert_id { $dbh->{mysql_insertid}; } +sub _prep_for_execute { + my $self = shift; + #(my $op, $ident, $args) = @_; + + # Only update and delete need special double-subquery treatment + # Insert referencing the same table (i.e. SELECT MAX(id) + 1) seems + # to work just fine on MySQL + return $self->next::method(@_) if ( $_[0] eq 'select' or $_[0] eq 'insert' ); + + + # FIXME FIXME FIXME - this is a terrible, gross, incomplete hack + # it should be trivial for mst to port this to DQ (and a good + # exercise as well, since we do not yet have such wide tree walking + # in place). For the time being this will work in limited cases, + # mainly complex update/delete, which is really all we want it for + # currently (allows us to fix some bugs without breaking MySQL in + # the process, and is also crucial for Shadow to be usable) + + # extract the source name, construct modification indicator re + my $sm = $self->sql_maker; + + my $target_name = $_[1]->from; + + if (ref $target_name) { + if ( + ref $target_name eq 'SCALAR' + and + $$target_name =~ /^ (?: + \` ( [^`]+ ) \` #` + | ( [\w\-]+ ) + ) $/x + ) { + # this is just a plain-ish name, which has been literal-ed for + # whatever reason + $target_name = (defined $1) ? $1 : $2; + } + else { + # this is something very complex, perhaps a custom result source or whatnot + # can't deal with it + undef $target_name; + } + } + + local $sm->{_modification_target_referenced_re} = + qr/ (?next::method(@_); +} + +# here may seem like an odd place to override, but this is the first +# method called after we are connected *and* the driver is determined +# ($self is reblessed). See code flow in ::Storage::DBI::_populate_dbh +sub _run_connection_actions { + my $self = shift; + + # default mysql_auto_reconnect to off unless explicitly set + if ( + $self->_dbh->{mysql_auto_reconnect} + and + ! exists $self->_dbic_connect_attributes->{mysql_auto_reconnect} + ) { + $self->_dbh->{mysql_auto_reconnect} = 0; + } + + $self->next::method(@_); +} + # we need to figure out what mysql version we're running sub sql_maker { my $self = shift; - unless ($self->_sql_maker) { - my $maker = $self->next::method (@_); + # it is critical to get the version *before* calling next::method + # otherwise the potential connect will obliterate the sql_maker + # next::method will populate in the _sql_maker accessor + my $mysql_ver = $self->_server_info->{normalized_dbms_version}; - # mysql 3 does not understand a bare JOIN - my $mysql_ver = $self->_get_dbh->get_info(18); - $maker->{_default_jointype} = 'INNER' if $mysql_ver =~ /^3/; - } + my $sm = $self->next::method(@_); - return $self->_sql_maker; + # mysql 3 does not understand a bare JOIN + $sm->{_default_jointype} = 'INNER' if $mysql_ver < 4; + + $sm; } sub sqlt_type { return 'MySQL'; } -sub _svp_begin { +sub deployment_statements { + my $self = shift; + my ($schema, $type, $version, $dir, $sqltargs, @rest) = @_; + + $sqltargs ||= {}; + + if ( + ! exists $sqltargs->{producer_args}{mysql_version} + and + my $dver = $self->_server_info->{normalized_dbms_version} + ) { + $sqltargs->{producer_args}{mysql_version} = $dver; + } + + $self->next::method($schema, $type, $version, $dir, $sqltargs, @rest); +} + +sub _exec_svp_begin { my ($self, $name) = @_; - $self->_get_dbh->do("SAVEPOINT $name"); + $self->_dbh->do("SAVEPOINT $name"); } -sub _svp_release { +sub _exec_svp_release { my ($self, $name) = @_; - $self->_get_dbh->do("RELEASE SAVEPOINT $name"); + $self->_dbh->do("RELEASE SAVEPOINT $name"); } -sub _svp_rollback { +sub _exec_svp_rollback { my ($self, $name) = @_; - $self->_get_dbh->do("ROLLBACK TO SAVEPOINT $name") + $self->_dbh->do("ROLLBACK TO SAVEPOINT $name") } sub is_replicating { @@ -78,12 +167,6 @@ sub lag_behind_master { return shift->_get_dbh->selectrow_hashref('show slave status')->{Seconds_Behind_Master}; } -# MySql can not do subquery update/deletes, only way is slow per-row operations. -# This assumes you have set proper transaction isolation and use innodb. -sub _subq_update_delete { - return shift->_per_row_update_delete (@_); -} - 1; =head1 NAME @@ -95,11 +178,16 @@ DBIx::Class::Storage::DBI::mysql - Storage::DBI class implementing MySQL specifi Storage::DBI autodetects the underlying MySQL database, and re-blesses the C<$storage> object into this class. - my $schema = MyDb::Schema->connect( $dsn, $user, $pass, { on_connect_call => 'set_strict_mode' } ); + my $schema = MyApp::Schema->connect( $dsn, $user, $pass, { on_connect_call => 'set_strict_mode' } ); =head1 DESCRIPTION -This class implements MySQL specific bits of L. +This class implements MySQL specific bits of L, +like AutoIncrement column support and savepoints. Also it augments the +SQL maker to support the MySQL-specific C join type, which +you can use by specifying C<< join_type => 'straight' >> in the +L + It also provides a one-stop on-connect macro C which sets session variables such that MySQL behaves more predictably as far as the