package SQL::Translator::Producer::MySQL;
# -------------------------------------------------------------------
-# $Id: MySQL.pm,v 1.53 2007-10-24 10:55:44 schiffbruechige Exp $
+# $Id: MySQL.pm,v 1.54 2007-11-10 03:36:43 mwz444 Exp $
# -------------------------------------------------------------------
# Copyright (C) 2002-4 SQLFairy Authors
#
Set the MySQL field options of the same name.
+=item field.renamed_from
+
+Used when producing diffs to say this column is the new name fo the specified
+old column.
+
=item table.mysql_table_type
Set the type of the table e.g. 'InnoDB', 'MyISAM'. This will be
automatically set for tables involved in foreign key constraints if it is
not already set explicitly. See L<"Table Types">.
-=item mysql_character_set
-
-MySql-4.1+. Set the tables character set.
-Run SHOW CHARACTER SET to see list.
-
-=item mysql_collate
-
-MySql-4.1+. Set the tables colation order.
-
=item table.mysql_charset, table.mysql_collate
Set the tables default charater set and collation order.
use strict;
use warnings;
use vars qw[ $VERSION $DEBUG %used_names ];
-$VERSION = sprintf "%d.%02d", q$Revision: 1.53 $ =~ /(\d+)\.(\d+)/;
+$VERSION = sprintf "%d.%02d", q$Revision: 1.54 $ =~ /(\d+)\.(\d+)/;
$DEBUG = 0 unless defined $DEBUG;
use Data::Dumper;
'datetime' => 'datetime',
);
+
+sub preprocess_schema {
+ my ($class, $schema) = @_;
+
+ # extra->{mysql_table_type} used to be the type. It belongs in options, so
+ # move it if we find it. Return Engine type if found in extra or options
+ my $mysql_table_type_to_options = sub {
+ my ($table) = @_;
+
+ my $extra = $table->extra;
+
+ my $extra_type = delete $extra->{mysql_table_type};
+
+ # Now just to find if there is already an Engine or Type option...
+ # and lets normalize it to ENGINE since:
+ #
+ # The ENGINE table option specifies the storage engine for the table.
+ # TYPE is a synonym, but ENGINE is the preferred option name.
+ #
+
+ # We have to use the hash directly here since otherwise there is no way
+ # to remove options.
+ my $options = ( $table->{options} ||= []);
+
+ # This assumes that there isn't both a Type and an Engine option.
+ for my $idx ( 0..$#{$options} ) {
+ my ($key, $value) = %{ $options->[$idx] };
+
+ next unless uc $key eq 'ENGINE' || uc $key eq 'TYPE';
+
+ # if the extra.mysql_table_type is given, use that
+ delete $options->[$idx]{$key};
+ return $options->[$idx]{ENGINE} = $value || $extra_type;
+
+ }
+
+ if ($extra_type) {
+ push @$options, { ENGINE => $extra_type };
+ return $extra_type;
+ }
+
+ };
+
+ # Names are only specific to a given schema
+ local %used_names = ();
+
+ #
+ # Work out which tables need to be InnoDB to support foreign key
+ # constraints. We do this first as we need InnoDB at both ends.
+ #
+ foreach my $table ( $schema->get_tables ) {
+
+ $mysql_table_type_to_options->($table);
+
+ foreach my $c( $table->get_constraints ) {
+ next unless $c->type eq FOREIGN_KEY;
+
+ # Normalize constraint names here.
+ my $c_name = $c->name;
+ # Give the constraint a name if it doesn't have one, so it doens't feel
+ # left out
+ $c_name = $table->name . '_fk' unless length $c_name;
+
+ $c->name( next_unused_name($c_name) );
+
+ for my $meth (qw/table reference_table/) {
+ my $table = $schema->get_table($c->$meth) || next;
+ next if $mysql_table_type_to_options->($table);
+ $table->options( { 'ENGINE' => 'InnoDB' } );
+ }
+ }
+ }
+}
+
sub produce {
my $translator = shift;
local $DEBUG = $translator->debug;
# \todo Don't set if MySQL 3.x is set on command line
$create .= "SET foreign_key_checks=0;\n\n";
- #
- # Work out which tables need to be InnoDB to support foreign key
- # constraints. We do this first as we need InnoDB at both ends.
- #
- foreach ( map { $_->get_constraints } $schema->get_tables ) {
- next unless $_->type eq FOREIGN_KEY;
- foreach my $meth (qw/table reference_table/) {
- my $table = $schema->get_table($_->$meth) || next;
- next if $table->extra('mysql_table_type');
- $table->extra( 'mysql_table_type' => 'InnoDB');
- }
- }
+ __PACKAGE__->preprocess_schema($schema);
#
# Generate sql
#
my @table_defs =();
+
for my $table ( $schema->get_tables ) {
# print $table->name, "\n";
push @table_defs, create_table($table,
if uc $key eq 'ENGINE' or uc $key eq 'TYPE';
$create .= " $key=$value";
}
+
my $mysql_table_type = $table->extra('mysql_table_type');
- #my $charset = $table->extra('mysql_character_set');
- #my $collate = $table->extra('mysql_collate');
- #$create .= " Type=$mysql_table_type" if $mysql_table_type;
- #$create .= " DEFAULT CHARACTER SET $charset" if $charset;
- #$create .= " COLLATE $collate" if $collate;
- $create .= " Type=$mysql_table_type"
+ $create .= " ENGINE=$mysql_table_type"
if $mysql_table_type && !$table_type_defined;
my $charset = $table->extra('mysql_charset');
my $collate = $table->extra('mysql_collate');
my $qf = $options->{quote_field_names} || '';
my $qt = $options->{quote_table_names} || '';
my $leave_name = $options->{leave_name} || undef;
- my $counter = ($options->{fk_name_counter} ||= {});
my @fields = $c->fields or next;
# Make sure FK field is indexed or MySQL complains.
#
+ my $table = $c->table;
my $c_name = $c->name;
- $counter->{$c->table} ||= {};
+
my $def = join(' ',
map { $_ || () }
'CONSTRAINT',
- $qt . join('_', next_unused_name($c_name)
- ) . $qt,
+ $qt . $c_name . $qt,
'FOREIGN KEY'
);
my @rfields = map { $_ || () } $c->reference_fields;
unless ( @rfields ) {
my $rtable_name = $c->reference_table;
- if ( my $ref_table = $c->table->schema->get_table( $rtable_name ) ) {
+ if ( my $ref_table = $table->schema->get_table( $rtable_name ) ) {
push @rfields, $ref_table->primary_key;
}
else {
$def .= ' (' . $qf . join( "$qf, $qf", @rfields ) . $qf . ')';
}
else {
- warn "FK constraint on " . $c->table->name . '.' .
+ warn "FK constraint on " . $table->name . '.' .
join('', @fields) . " has no reference fields\n"
if $options->{show_warnings};
}
return $out;
}
+sub rename_field { alter_field(@_) }
sub alter_field
{
my ($from_field, $to_field, $options) = @_;
my $out = sprintf('ALTER TABLE %s CHANGE COLUMN %s %s',
$qt . $to_field->table->name . $qt,
- $qf . $to_field->name . $qf,
+ $qf . $from_field->name . $qf,
create_field($to_field, $options));
return $out;
}
+sub batch_alter_table {
+ my ($table, $diff_hash, $options) = @_;
+
+ my @stmts = map {
+ if (@{ $diff_hash->{$_} || [] }) {
+ my $meth = __PACKAGE__->can($_) or die __PACKAGE__ . " cant $_";
+ map { $meth->(ref $_ eq 'ARRAY' ? @$_ : $_) } @{ $diff_hash->{$_} }
+ } else { () }
+ } qw/alter_drop_constraint
+ alter_drop_index
+ drop_field
+ add_field
+ alter_field
+ rename_field
+ alter_create_index
+ alter_create_constraint
+ alter_table/;
+
+ return unless @stmts;
+ # Just zero or one stmts. return now
+ return "@stmts;" unless @stmts > 1;
+
+ # Now strip off the 'ALTER TABLE xyz' of all but the first one
+
+ my $qt = $options->{quote_table_name} || '';
+ my $table_name = $qt . $table->name . $qt;
+
+ my $first = shift @stmts;
+ my ($alter_table) = $first =~ /^(ALTER TABLE \Q$table_name\E )/;
+ my $re = qr/^$alter_table/;
+ my $padd = " " x length($alter_table);
+
+ return join( ",\n", $first, map { s/$re//; $padd . $_ } @stmts) . ';';
+}
+
+sub drop_table {
+ my ($table) = @_;
+
+ # Drop (foreign key) constraints so table drops cleanly
+ my @sql = batch_alter_table($table, { alter_drop_constraint => [ grep { $_->type eq 'FOREIGN KEY' } $table->get_constraints ] });
+
+ return join("\n", @sql, "DROP TABLE $table;");
+
+}
+
sub next_unused_name {
my $name = shift || '';
if ( !defined($used_names{$name}) ) {
projects / dbsrgits/SQL-Translator.git / blobdiff