SQLT-DIFF(1p) User Contributed Perl Documentation SQLT-DIFF(1p)NAME
sqlt-diff - find the differences b/w two schemas
SYNOPSIS
For help:
sqlt-diff -h|--help
For a list of all valid parsers:
sqlt -l|--list
To diff two schemas:
sqlt-diff [options] file_name1=parser1 file_name2=parser2
Options:
-d|--debug Show debugging info
-t|--trace Turn on tracing for Parse::RecDescent
-c|--case-insensitive Compare tables/columns case-insensitively
--ignore-index-names Ignore index name differences
--ignore-constraint-names Ignore constraint name differences
--mysql_parser_version=<#####> Specify a target MySQL parser version
for dealing with /*! comments
--output-db=<Producer> This Producer will be used instead of one
corresponding to parser1 to format output
for new tables
--ignore-view-sql Ignore view SQL differences
--ignore-proc-sql Ignore procedure SQL differences
--no-batch-alters Do not clump multile alters to the same table into a
single ALTER TABLE statement where possible.
--quote=<character> Use <character> to quote all table and field
names in statements
DESCRIPTION
sqlt-diff is a utility for creating a file of SQL commands necessary to transform the first schema provided to the second. While not yet
exhaustive in its ability to mutate the entire schema, it will report the following
o New tables
Using the Producer class of the target (second) schema, any tables missing in the first schema will be generated in their entirety
(fields, constraints, indices).
o Missing/altered fields
Any fields missing or altered between the two schemas will be reported as:
ALTER TABLE <table_name>
[DROP <field_name>]
[CHANGE <field_name> <datatype> (<size>)] ;
o Missing/altered indices
Any indices missing or of a different type or on different fields will be indicated. Indices that should be dropped will be reported
as such:
DROP INDEX <index_name> ON <table_name> ;
An index of a different type or on different fields will be reported as a new index as such:
CREATE [<index_type>] INDEX [<index_name>] ON <table_name>
( <field_name>[,<field_name>] ) ;
ALTER, CREATE, DROP statements are created by SQL::Translator::Producer::*, see there for support/problems.
Currently (v0.0900), only MySQL is supported by this code.
AUTHOR
Ken Youens-Clark <kclark@cpan.org>.
SEE ALSO
SQL::Translator, <http://sqlfairy.sourceforge.net>.
perl v5.14.2 2012-01-18 SQLT-DIFF(1p)
Check Out this Related Man Page
SQL::Translator::Diff(3pm) User Contributed Perl Documentation SQL::Translator::Diff(3pm)NAME
SQL::Translator::Diff - determine differences between two schemas
DESCRIPTION
Takes two input SQL::Translator::Schemas (or SQL files) and produces ALTER statments to make them the same
SNYOPSIS
Simplest usage:
use SQL::Translator::Diff;
my $sql = SQL::Translator::Diff::schema_diff($source_schema, 'MySQL', $target_schema, 'MySQL', $options_hash)
OO usage:
use SQL::Translator::Diff;
my $diff = SQL::Translator::Diff->new({
output_db => 'MySQL',
source_schema => $source_schema,
target_schema => $target_schema,
%$options_hash,
})->compute_differences->produce_diff_sql;
OPTIONS
ignore_index_names
Match indexes based on types and fields, ignoring name.
ignore_constraint_names
Match constrains based on types, fields and tables, ignoring name.
output_db
Which producer to use to produce the output.
case_insensitive
Ignore case of table, field, index and constraint names when comparing
no_batch_alters
Produce each alter as a distinct "ALTER TABLE" statement even if the producer supports the ability to do all alters for a table as one
statement.
ignore_missing_methods
If the diff would need a method that is missing from the producer, just emit a comment showing the method is missing, rather than
dieing with an error
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 thrown.
o "alter_create_constraint($con)"
o "alter_drop_constraint($con)"
o "alter_create_index($idx)"
o "alter_drop_index($idx)"
o "add_field($fld)"
o "alter_field($old_fld, $new_fld)"
o "rename_field($old_fld, $new_fld)"
o "drop_field($fld)"
o "alter_table($table)"
o "drop_table($table)"
o "rename_table($old_table, $new_table)" (optional)
o "batch_alter_table($table, $hash)" (optional)
If the producer supports "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 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:
{
alter_create_constraint => [ $constraint1, $constraint2 ],
add_field => [ $field ],
alter_field => [ [$old_field, $new_field] ]
}
o "preprocess_schema($class, $schema)" (optional)
"preprocess_schema" is called by the Diff code to allow the producer to normalize any data it needs to first. For example, the MySQL
producer uses this method to ensure that FK contraint names are unique.
Basicaly any changes that need to be made to produce the SQL file for the 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 "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 work better on old-style producers.)
AUTHOR
Original Author(s) unknown.
Refactor/re-write and more comprehensive tests by Ash Berlin "ash@cpan.org".
Redevelopment sponsored by Takkle Inc.
perl v5.14.2 2012-05-01 SQL::Translator::Diff(3pm)