require DBIx::Class::Storage; # loaded for type constraint
require DBIx::Class::ResultSet; # loaded for type constraint
use Carp::Clan '^DBIx::Class::DeploymentHandler';
+use SQL::Translator;
+
+BEGIN {
+ use Moose::Util::TypeConstraints;
+ subtype 'DBIx::Class::DeploymentHandler::Databases'
+ => as 'ArrayRef[Str]';
+
+ coerce 'DBIx::Class::DeploymentHandler::Databases'
+ => from 'Str'
+ => via { [$_] };
+ no Moose::Util::TypeConstraints;
+}
has schema => (
isa => 'DBIx::Class::Schema',
handles => [qw( is_installed db_version )],
);
+has databases => (
+ coerce => 1,
+ isa => 'DBIx::Class::DeploymentHandler::Databases',
+ is => 'ro',
+ default => sub { [qw( MySQL SQLite PostgreSQL )] },
+);
+
+has sqltargs => (
+ isa => 'HashRef',
+ is => 'ro',
+ default => sub { {} },
+);
+
method _build_version_rs {
$self->schema->set_us_up_the_bomb;
$self->schema->resultset('__VERSION')
});
}
-method create_ddl_dir($databases, $version, $dir, $preversion, $sqltargs) {
- my $schema = $self->schema;
- if(!$dir || !-d $dir) {
- carp "No directory given, using ./\n";
+method create_ddl_dir($version, $preversion) {
+ my $schema = $self->schema;
+ my $databases = $self->databases;
+ my $dir = $self->upgrade_directory;
+ my $sqltargs = $self->sqltargs;
+ unless( -d $dir ) {
+ carp "Upgrade directory $dir does not exist, using ./\n";
$dir = "./";
}
- $databases ||= ['MySQL', 'SQLite', 'PostgreSQL'];
- $databases = [ $databases ] if(ref($databases) ne 'ARRAY');
my $schema_version = $schema->schema_version || '1.x';
$version ||= $schema_version;
%{$sqltargs || {}}
};
- unless (DBIx::Class::Optional::Dependencies->req_ok_for ('deploy')) {
- $self->throw_exception("Can't create a ddl file without " . DBIx::Class::Optional::Dependencies->req_missing_for ('deploy') );
- }
-
my $sqlt = SQL::Translator->new( $sqltargs );
$sqlt->parser('SQL::Translator::Parser::DBIx::Class');
or $self->throw_exception ($sqlt->error);
foreach my $db (@$databases) {
- $sqlt->reset();
+ $sqlt->reset;
$sqlt->{schema} = $sqlt_schema;
$sqlt->producer($db);
- my $file;
- my $filename = $schema->ddl_filename($db, $version, $dir);
+ my $filename = $self->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);
+ unlink $filename;
}
my $output = $sqlt->translate;
carp("Failed to translate to $db, skipping. (" . $sqlt->error . ")");
next;
}
- if(!open($file, ">$filename")) {
+ my $file;
+ unless( open $file, q(>), $filename ) {
$self->throw_exception("Can't open $filename for writing ($!)");
next;
}
- print $file $output;
- close($file);
+ print {$file} $output;
+ close $file;
- next unless ($preversion);
+ next unless $preversion;
require SQL::Translator::Diff;
- my $prefilename = $schema->ddl_filename($db, $preversion, $dir);
- if(!-e $prefilename) {
+ my $prefilename = $self->ddl_filename($db, $preversion, $dir);
+ unless(-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 $diff_file = $self->ddl_filename($db, $version, $dir, $preversion);
+ if(-e $diff_file) {
+ carp("Overwriting existing diff file - $diff_file");
+ unlink $diff_file;
}
my $source_schema;
{
- my $t = SQL::Translator->new($sqltargs);
- $t->debug( 0 );
- $t->trace( 0 );
+ my $t = SQL::Translator->new({
+ %{$sqltargs},
+ debug => 0,
+ trace => 0,
+ });
- $t->parser( $db )
+ $t->parser( $db ) # could this really throw an exception?
or $self->throw_exception ($t->error);
my $out = $t->translate( $prefilename )
$source_schema = $t->schema;
$source_schema->name( $prefilename )
- unless ( $source_schema->name );
+ unless $source_schema->name;
}
# The "new" style of producers have sane normalization and can support
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 );
+ my $t = SQL::Translator->new({
+ %{$sqltargs},
+ debug => 0,
+ trace => 0,
+ });
- $t->parser( $db )
+ $t->parser( $db ) # could this really throw an exception?
or $self->throw_exception ($t->error);
my $out = $t->translate( $filename )
unless $dest_schema->name;
}
- 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 ($!)");
+ my $diff = SQL::Translator::Diff::schema_diff(
+ $source_schema, $db,
+ $dest_schema, $db,
+ $sqltargs
+ );
+ unless(open $file, q(>), $diff_file) {
+ $self->throw_exception("Can't write to $diff_file ($!)");
next;
}
- print $file $diff;
- close($file);
+ print {$file} $diff;
+ close $file;
}
}