-package SQL::Translator::Parser::DBIx::Class;
+package # hide from PAUSE
+ SQL::Translator::Parser::DBIx::Class;
# AUTHOR: Jess Robinson
# -------------------------------------------------------------------
# parse($tr, $data)
#
-# Note that $data, in the case of this parser, is unuseful.
+# Note that $data, in the case of this parser, is not useful.
# We're working with DBIx::Class Schemas, not data streams.
# -------------------------------------------------------------------
sub parse {
}
$table->primary_key($source->primary_columns);
+ my @primary = $source->primary_columns;
+ my %unique_constraints = $source->unique_constraints;
+ foreach my $uniq (keys %unique_constraints) {
+ if (!equal_keys($unique_constraints{$uniq}, \@primary)) {
+ $table->add_constraint(
+ type => 'unique',
+ name => "$uniq",
+ fields => $unique_constraints{$uniq}
+ );
+ }
+ }
my @rels = $source->relationships();
foreach my $rel (@rels)
{
my $rel_info = $source->relationship_info($rel);
- next if(!exists $rel_info->{attrs}{accessor} ||
- $rel_info->{attrs}{accessor} eq 'multi');
- # Going by the accessor type isn't such a good idea (yes, I know
- # I suggested it). I think the best way to tell if something's a
- # foreign key constraint is to assume if it doesn't include our
- # primaries then it is (dumb but it'll do). Ignore any rel cond
- # that isn't a straight hash, but get both sets of keys in full
- # so you don't barf on multi-primaries. Oh, and a dog-simple
- # deploy method to chuck the results of this exercise at a db
- # for testing is
- # $schema->storage->dbh->do($_) for split(";\n", $sql);
- # -- mst (03:42 local time, please excuse any mistakes)
+
my $rel_table = $source->related_source($rel)->name;
- my $cond = (keys (%{$rel_info->{cond}}))[0];
- my ($refkey) = $cond =~ /^\w+\.(\w+)$/;
- if($rel_table && $refkey)
- {
- $table->add_constraint(
- type => 'foreign_key',
- name => "fk_${rel}_id",
- fields => $rel,
- reference_fields => $refkey,
- reference_table => $rel_table,
- );
+
+ # Ignore any rel cond that isn't a straight hash
+ next unless ref $rel_info->{cond} eq 'HASH';
+
+ # Get the key information, mapping off the foreign/self markers
+ my @cond = keys(%{$rel_info->{cond}});
+ my @refkeys = map {/^\w+\.(\w+)$/} @cond;
+ my @keys = map {$rel_info->{cond}->{$_} =~ /^\w+\.(\w+)$/} @cond;
+
+ if($rel_table)
+ {
+
+ #Decide if this is a foreign key based on whether the self
+ #items are our primary columns.
+
+ # If the sets are different, then we assume it's a foreign key from
+ # us to another table.
+ if (!equal_keys(\@keys, \@primary)) {
+ $table->add_constraint(
+ type => 'foreign_key',
+ name => "fk_$keys[0]",
+ fields => \@keys,
+ reference_fields => \@refkeys,
+ reference_table => $rel_table,
+ );
+ }
+ }
+ }
+ }
+ return 1;
+}
+
+# -------------------------------------------------------------------
+# equal_keys($key1, $key2)
+#
+# See if the set of keys in $key1 is equal to the set of keys in $key2
+# -------------------------------------------------------------------
+sub equal_keys {
+ my ($key1, $key2) = @_;
+
+ # Make sure every key1 is in key2
+ my $found;
+ foreach my $key (@$key1) {
+ $found = 0;
+ foreach my $prim (@$key2) {
+ if ($prim eq $key) {
+ $found = 1;
+ last;
+ }
+ }
+ last unless $found;
+ }
+
+ # Make sure every key2 is in key1
+ if ($found) {
+ foreach my $prim (@$key2) {
+ $found = 0;
+ foreach my $key (@$key1) {
+ if ($prim eq $key) {
+ $found = 1;
+ last;
+ }
}
+ last unless $found;
}
}
-}
+ return $found;
+}
1;