X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FSQL%2FTranslator%2FParser%2FDBIx%2FClass.pm;h=527d5e51185d23e0ba3d64bd45a25b07036469ff;hb=72cd40076ba3fc9db6056c3413492e7df01ff546;hp=d69e42c8de8bcae7238f1756515842efa0549c81;hpb=176213794ea19cf2c3c0d52d189d2731411e8d4d;p=dbsrgits%2FDBIx-Class.git diff --git a/lib/SQL/Translator/Parser/DBIx/Class.pm b/lib/SQL/Translator/Parser/DBIx/Class.pm index d69e42c..527d5e5 100644 --- a/lib/SQL/Translator/Parser/DBIx/Class.pm +++ b/lib/SQL/Translator/Parser/DBIx/Class.pm @@ -8,14 +8,15 @@ package SQL::Translator::Parser::DBIx::Class; use strict; use warnings; -use vars qw($DEBUG $VERSION @EXPORT_OK); +our ($DEBUG, $VERSION, @EXPORT_OK); $VERSION = '1.10'; $DEBUG = 0 unless defined $DEBUG; use Exporter; use SQL::Translator::Utils qw(debug normalize_name); -use Carp::Clan qw/^SQL::Translator|^DBIx::Class|^Try::Tiny/; -use Scalar::Util 'weaken'; +use DBIx::Class::Carp qw/^SQL::Translator|^DBIx::Class|^Try::Tiny/; +use DBIx::Class::Exception; +use Scalar::Util 'blessed'; use Try::Tiny; use namespace::clean; @@ -33,26 +34,42 @@ use base qw(Exporter); # We're working with DBIx::Class Schemas, not data streams. # ------------------------------------------------------------------- sub parse { - # this is a hack to prevent schema leaks due to a retarded SQLT implementation - # DO NOT REMOVE (until SQLT2 is out, the all of this will be rewritten anyway) - weaken $_[1] if ref ($_[1]); - my ($tr, $data) = @_; my $args = $tr->parser_args; - my $dbicschema = $args->{'DBIx::Class::Schema'} || $args->{"DBIx::Schema"} ||$data; - $dbicschema ||= $args->{'package'}; - my $limit_sources = $args->{'sources'}; - croak 'No DBIx::Class::Schema' unless ($dbicschema); - if (!ref $dbicschema) { - try { - eval "require $dbicschema;" - } - catch { - croak "Can't load $dbicschema ($_)"; + my $dbicschema = $data || $args->{dbic_schema}; + + for (qw(DBIx::Class::Schema DBIx::Schema package)) { + if (defined (my $s = delete $args->{$_} )) { + carp_unique("Supplying a schema via ... parser_args => { '$_' => \$schema } is deprecated. Please use parser_args => { dbic_schema => \$schema } instead"); + + # move it from the deprecated to the proper $args slot + unless ($dbicschema) { + $args->{dbic_schema} = $dbicschema = $s; + } } } + DBIx::Class::Exception->throw('No DBIx::Class::Schema') unless ($dbicschema); + + if (!ref $dbicschema) { + eval "require $dbicschema" + or DBIx::Class::Exception->throw("Can't load $dbicschema: $@"); + } + + if ( + ref $args->{dbic_schema} + and + $args->{dbic_schema}->storage + ) { + # we have a storage-holding $schema instance in $args + # we need to dissociate it from that $storage + # otherwise SQLT insanity may ensue due to how some + # serializing producers treat $args (crazy crazy shit) + local $args->{dbic_schema}{storage}; + $args->{dbic_schema} = $args->{dbic_schema}->clone; + } + my $schema = $tr->schema; my $table_no = 0; @@ -60,7 +77,7 @@ sub parse { unless ($schema->name); my @monikers = sort $dbicschema->sources; - if ($limit_sources) { + if (my $limit_sources = $args->{'sources'}) { my $ref = ref $limit_sources || ''; $dbicschema->throw_exception ("'sources' parameter must be an array or hash ref") unless( $ref eq 'ARRAY' || ref eq 'HASH' ); @@ -154,7 +171,11 @@ sub parse { # Ignore any rel cond that isn't a straight hash next unless ref $rel_info->{cond} eq 'HASH'; - my $relsource = $source->related_source($rel); + my $relsource = try { $source->related_source($rel) }; + unless ($relsource) { + carp "Ignoring relationship '$rel' - related resultsource '$rel_info->{class}' is not registered with this schema\n"; + next; + }; # related sources might be excluded via a {sources} filter or might be views next unless exists $table_monikers{$relsource->source_name}; @@ -284,7 +305,7 @@ sub parse { # the hook might have already removed the table if ($schema->get_table($table) && $table =~ /^ \s* \( \s* SELECT \s+/ix) { - warn <<'EOW'; + carp <<'EOW'; Custom SQL through ->name(\'( SELECT ...') is DEPRECATED, for more details see "Arbitrary SQL through a custom ResultSource" in DBIx::Class::Manual::Cookbook @@ -299,17 +320,22 @@ EOW } my %views; + my @views = map { $dbicschema->source($_) } keys %view_monikers; + + my $view_dependencies = { + map { + $_ => _resolve_deps( $dbicschema->source($_), \%view_monikers ) + } ( keys %view_monikers ) + }; my @view_sources = - sort { - keys %{ $a->deploy_depends_on || {} } - <=> - keys %{ $b->deploy_depends_on || {} } - || - $a->source_name cmp $b->source_name - } - map { $dbicschema->source($_) } - keys %view_monikers; + sort { + keys %{ $view_dependencies->{ $a->source_name } || {} } <=> + keys %{ $view_dependencies->{ $b->source_name } || {} } + || $a->source_name cmp $b->source_name + } + map { $dbicschema->source($_) } + keys %view_monikers; foreach my $source (@view_sources) { @@ -349,35 +375,51 @@ EOW # Quick and dirty dependency graph calculator # sub _resolve_deps { - my ($table, $tables, $seen) = @_; - - my $ret = {}; - $seen ||= {}; - - # copy and bump all deps by one (so we can reconstruct the chain) - my %seen = map { $_ => $seen->{$_} + 1 } (keys %$seen); - $seen{$table} = 1; - - for my $dep (keys %{$tables->{$table}{foreign_table_deps}} ) { - - if ($seen->{$dep}) { - - # warn and remove the circular constraint so we don't get flooded with the same warning over and over - #carp sprintf ("Circular dependency detected, schema may not be deployable:\n%s\n", - # join (' -> ', (sort { $seen->{$b} <=> $seen->{$a} } (keys %$seen) ), $table, $dep ) - #); - #delete $tables->{$table}{foreign_table_deps}{$dep}; - - return {}; + my ( $question, $answers, $seen ) = @_; + my $ret = {}; + $seen ||= {}; + my @deps; + + # copy and bump all deps by one (so we can reconstruct the chain) + my %seen = map { $_ => $seen->{$_} + 1 } ( keys %$seen ); + if ( blessed($question) + && $question->isa('DBIx::Class::ResultSource::View') ) + { + $seen{ $question->result_class } = 1; + @deps = keys %{ $question->{deploy_depends_on} }; + } + else { + $seen{$question} = 1; + @deps = keys %{ $answers->{$question}{foreign_table_deps} }; } - my $subdeps = _resolve_deps ($dep, $tables, \%seen); - $ret->{$_} += $subdeps->{$_} for ( keys %$subdeps ); - - ++$ret->{$dep}; - } + for my $dep (@deps) { + if ( $seen->{$dep} ) { + return {}; + } + my $next_dep; - return $ret; + if ( blessed($question) + && $question->isa('DBIx::Class::ResultSource::View') ) + { + no warnings 'uninitialized'; + my ($next_dep_source_name) = + grep { + $question->schema->source($_)->result_class eq $dep + && !( $question->schema->source($_) + ->isa('DBIx::Class::ResultSource::Table') ) + } @{ [ $question->schema->sources ] }; + return {} unless $next_dep_source_name; + $next_dep = $question->schema->source($next_dep_source_name); + } + else { + $next_dep = $dep; + } + my $subdeps = _resolve_deps( $next_dep, $answers, \%seen ); + $ret->{$_} += $subdeps->{$_} for ( keys %$subdeps ); + ++$ret->{$dep}; + } + return $ret; } 1; @@ -404,7 +446,7 @@ from a DBIx::Class::Schema instance my $trans = SQL::Translator->new ( parser => 'SQL::Translator::Parser::DBIx::Class', parser_args => { - package => $schema, + dbic_schema => $schema, add_fk_index => 0, sources => [qw/ Artist @@ -434,6 +476,27 @@ L. =head1 PARSER OPTIONS +=head2 dbic_schema + +The DBIx::Class schema (either an instance or a class name) to be parsed. +This argument is in fact optional - instead one can supply it later at +translation time as an argument to L. In +other words both of the following invocations are valid and will produce +conceptually identical output: + + my $yaml = SQL::Translator->new( + parser => 'SQL::Translator::Parser::DBIx::Class', + parser_args => { + dbic_schema => $schema, + }, + producer => 'SQL::Translator::Producer::YAML', + )->translate; + + my $yaml = SQL::Translator->new( + parser => 'SQL::Translator::Parser::DBIx::Class', + producer => 'SQL::Translator::Producer::YAML', + )->translate(data => $schema); + =head2 add_fk_index Create an index for each foreign key.