# Input/option accessors
__PACKAGE__->mk_accessors(qw/
ignore_index_names ignore_constraint_names ignore_view_sql
- ignore_proc_sql output_db source_schema target_schema
+ ignore_proc_sql output_db source_schema target_schema
case_insensitive no_batch_alters ignore_missing_methods producer_args
/);
unless ( $src_table ) {
## table is new
- ## add table(s) later.
+ ## add table(s) later.
push @{$self->tables_to_create}, $tar_table;
next;
}
table_renamed_from => 'rename_table',
);
my @diffs;
-
- if (!$self->no_batch_alters &&
- (my $batch_alter = $producer_class->can('batch_alter_table')) )
+
+ if (!$self->no_batch_alters &&
+ (my $batch_alter = $producer_class->can('batch_alter_table')) )
{
# Good - Producer supports batch altering of tables.
foreach my $table ( sort keys %{$self->table_diff_hash} ) {
push @diffs, $batch_alter->($tar_table,
{ map {
$func_map{$_} => $self->table_diff_hash->{$table}{$_}
- } keys %func_map
- },
+ } keys %func_map
+ },
$self->producer_args
);
}
push @diffs, map( {
if (@{ $flattened_diffs{$_} || [] }) {
my $meth = $producer_class->can($_);
-
- $meth ? map {
+
+ $meth ? map {
my $sql = $meth->( (ref $_ eq 'ARRAY' ? @$_ : $_), $self->producer_args );
- $sql ? ("$sql") : ();
+ $sql ? ("$sql") : ();
} @{ $flattened_diffs{$_} }
: $self->ignore_missing_methods
? "-- $producer_class cant $_"
$schema->add_table($_) for @tables;
- unshift @diffs,
+ unshift @diffs,
# Remove begin/commit here, since we wrap everything in one.
grep { $_ !~ /^(?:COMMIT|START(?: TRANSACTION)?|BEGIN(?: TRANSACTION)?)/ } $producer_class->can('produce')->($translator);
}
if (my @tables_to_drop = @{ $self->{tables_to_drop} || []} ) {
my $meth = $producer_class->can('drop_table');
-
+
push @diffs, $meth ? ( map { $meth->($_, $self->producer_args) } @tables_to_drop)
: $self->ignore_missing_methods
? "-- $producer_class cant drop_table"
unshift(@diffs, "-- Output database @{[$self->output_db]} is untested/unsupported!!!");
}
- my @return =
+ my @return =
map { $_ ? ( $_ =~ /;$/xms ? $_ : "$_;\n\n" ) : "\n" }
("-- Convert schema '$src_name' to '$tar_name':", @diffs);
next;
}
- # field exists, something changed. This is a bit complex. Parsers can
+ # field exists, something changed. This is a bit complex. Parsers can
# normalize types, but only some of them do, so compare the normalized and
# parsed types for each field to each other
if ( !$tar_table_field->equals($src_table_field, $self->case_insensitive) &&
- !$tar_table_field->equals($src_table_field->parsed_field, $self->case_insensitive) &&
- !$tar_table_field->parsed_field->equals($src_table_field, $self->case_insensitive) &&
+ !$tar_table_field->equals($src_table_field->parsed_field, $self->case_insensitive) &&
+ !$tar_table_field->parsed_field->equals($src_table_field, $self->case_insensitive) &&
!$tar_table_field->parsed_field->equals($src_table_field->parsed_field, $self->case_insensitive) ) {
# Some producers might need src field to diff against
=head1 DESCRIPTION
-Takes two input SQL::Translator::Schemas (or SQL files) and produces ALTER
+Takes two input SQL::Translator::Schemas (or SQL files) and produces ALTER
statments to make them the same
=head1 SNYOPSIS
=head1 PRODUCER FUNCTIONS
The following producer functions should be implemented for completeness. If
-any of them are needed for a given diff, but not found, an error will be
+any of them are needed for a given diff, but not found, an error will be
thrown.
=over
=item * C<batch_alter_table($table, $hash)> (optional)
-If the producer supports C<batch_alter_table>, it will be called with the
+If the producer supports C<batch_alter_table>, it will be called with the
table to alter and a hash, the keys of which will be the method names listed
-above; values will be arrays of fields or constraints to operate on. In the
+above; values will be arrays of fields or constraints to operate on. In the
case of the field functions that take two arguments this will appear as a hash.
I.e. the hash might look something like the following:
schema should be done here, so that a diff between a parsed SQL file and (say)
a parsed DBIx::Class::Schema object will be sane.
-(As an aside, DBIx::Class, for instance, uses the presence of a
+(As an aside, DBIx::Class, for instance, uses the presence of a
C<preprocess_schema> function on the producer to know that it can diff between
the previous SQL file and its own internal representation. Without this method
-on th producer it will diff the two SQL files which is slower, but known to
+on th producer it will diff the two SQL files which is slower, but known to
work better on old-style producers.)
=back