X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FDBIx%2FClass%2FResultSource%2FMultipleTableInheritance.pm;h=0a45aa8eabf31394f3e32491255e81ddc085186c;hb=2816c8ed6bd9d17cf62277b0c3133ecfe7f44429;hp=f77553060da600057bf45c688024b9b28fb30dff;hpb=388d83fc4aa8769c09efc050d53de2168d0d1989;p=dbsrgits%2FDBIx-Class-ResultSource-MultipleTableInheritance.git

diff --git a/lib/DBIx/Class/ResultSource/MultipleTableInheritance.pm b/lib/DBIx/Class/ResultSource/MultipleTableInheritance.pm
index f775530..0a45aa8 100644
--- a/lib/DBIx/Class/ResultSource/MultipleTableInheritance.pm
+++ b/lib/DBIx/Class/ResultSource/MultipleTableInheritance.pm
@@ -26,7 +26,7 @@ use namespace::autoclean;
 #
 # deploying the postgres rules through SQLT may be a pain though.
 
-__PACKAGE__->mk_group_accessors(simple => qw(parent_source));
+__PACKAGE__->mk_group_accessors(simple => qw(parent_source additional_parents));
 
 method new ($class: @args) {
   my $new = $class->next::method(@args);
@@ -41,15 +41,50 @@ method new ($class: @args) {
   return $new;
 }
 
+method add_additional_parent ($source) {
+  my ($our_pk, $their_pk) = map {
+    join('|',sort $_->primary_columns)
+  } ($self, $source);
+
+  confess "Can't attach additional parent ${\$source->name} - it has different PKs ($their_pk versus our $our_pk)"
+    unless $their_pk eq $our_pk;
+  $self->additional_parents([
+    @{$self->additional_parents||[]}, $source
+  ]);
+  $self->add_columns(
+    map {
+      $_ => # put the extra key first to default it
+      { originally_defined_in => $source->name, %{$source->column_info($_)}, },
+    } grep !$self->has_column($_), $source->columns
+  );
+  foreach my $rel ($source->relationships) {
+    my $rel_info = $source->relationship_info($rel);
+    $self->add_relationship(
+      $rel, $rel_info->{source}, $rel_info->{cond},
+      # extra key first to default it
+      {originally_defined_in => $source->name, %{$rel_info->{attrs}}},
+    );
+  }
+}
+
 method schema (@args) {
   my $ret = $self->next::method(@args);
   if (@args) {
-    $self->_attach_additional_sources;
+    if ($self->parent_source) {
+      my $schema = $self->schema;
+      my $parent_name = $self->parent_source->name;
+      my ($parent) = 
+        grep { $_->name eq $parent_name }
+          map $schema->source($_), $schema->sources;
+      confess "Couldn't find attached source for parent $parent_name - did you use load_classes? This module is only compatible with load_namespaces"
+        unless $parent;
+      $self->parent_source($parent); # so our parent is the one in this schema
+    }
   }
   return $ret;
 }
 
-method _attach_additional_sources () {
+method attach_additional_sources () {
   my $raw_name = $self->raw_source_name;
   my $schema = $self->schema;
 
@@ -77,17 +112,26 @@ method _attach_additional_sources () {
   # we don't need to add the PK cols explicitly if we're the root table
   # since they'll get added below
 
+  my %pk_join;
+
   if ($parent) {
-    my %join;
     foreach my $pri ($self->primary_columns) {
       my %info = %{$self->column_info($pri)};
       delete @info{qw(is_auto_increment sequence auto_nextval)};
       $table->add_column($pri => \%info);
-      $join{"foreign.${pri}"} = "self.${pri}";
+      $pk_join{"foreign.${pri}"} = "self.${pri}";
     }
     # have to use source name lookups rather than result class here
     # because we don't actually have a result class on the raw sources
-    $table->add_relationship('parent', $parent->raw_source_name, \%join);
+    $table->add_relationship('parent', $parent->raw_source_name, \%pk_join);
+    $self->depends_on->{$parent->source_name} = 1;
+  }
+
+  foreach my $add (@{$self->additional_parents||[]}) {
+    $table->add_relationship(
+      'parent_'.$add->name, $add->source_name, \%pk_join
+    );
+    $self->depends_on->{$add->source_name} = 1;
   }
 
   # add every column that's actually a concrete part of us
@@ -98,6 +142,56 @@ method _attach_additional_sources () {
         $self->columns
   );
   $table->set_primary_key($self->primary_columns);
+
+  # we need to copy our rels to the raw object as well
+  # note that ->add_relationship on a source object doesn't create an
+  # accessor so we can leave that part in the attributes
+
+  # if the other side is a table then we need to copy any rels it has
+  # back to us, as well, so that they point at the raw table. if the
+  # other side is an MTI view then we need to create the rels to it to
+  # point at -its- raw table; we don't need to worry about backrels because
+  # it's going to run this method too (and its raw source might not exist
+  # yet so we can't, anyway)
+
+  foreach my $rel ($self->relationships) {
+    my $rel_info = $self->relationship_info($rel);
+
+    # if we got this from the superclass, -its- raw table will nail this.
+    # if we got it from an additional parent, it's its problem.
+    next unless $rel_info->{attrs}{originally_defined_in} eq $self->name;
+
+    my $f_source = $schema->source($rel_info->{source});
+
+    # __PACKAGE__ is correct here because subclasses should be caught
+
+    my $one_of_us = $f_source->isa(__PACKAGE__);
+
+    my $f_source_name = $f_source->${\
+                        ($one_of_us ? 'raw_source_name' : 'source_name')
+                      };
+    
+    $table->add_relationship(
+      '_'.$rel, $f_source_name, @{$rel_info}{qw(cond attrs)}
+    );
+
+    unless ($one_of_us) {
+      my $reverse = do {
+        # we haven't been registered yet, so reverse_ cries
+        # XXX this is evil and will probably break eventually
+        local @{$schema->source_registrations}
+               {map $self->$_, qw(source_name result_class)}
+          = ($self, $self);
+        $self->reverse_relationship_info($rel);
+      };
+      foreach my $rev_rel (keys %$reverse) {
+        $f_source->add_relationship(
+          '_raw_'.$rev_rel, $raw_name, @{$reverse->{$rev_rel}}{qw(cond attrs)}
+        );
+      }
+    }
+  }
+
   $schema->register_source($raw_name => $table);
 }
 
@@ -125,6 +219,13 @@ method add_columns (@args) {
   return $ret;
 }
 
+method add_relationship ($name, $f_source, $cond, $attrs) {
+  $self->next::method(
+    $name, $f_source, $cond,
+    { originally_defined_in => $self->name, %{$attrs||{}}, }
+  );
+}
+
 BEGIN {
 
   # helper routines, constructed as anon subs so autoclean nukes them
@@ -190,7 +291,7 @@ BEGIN {
       CREATE RULE _[% to %]_[% on %]_rule AS
         ON [% on | upper %] TO [% to %]
         DO INSTEAD (
-          SELECT _[% to %]_[% on %]([% arglist %])
+          SELECT [% to %]_[% on %]([% arglist %])
         );
     };
   };
@@ -207,30 +308,38 @@ method view_definition () {
   confess "Can't generate view without connected schema, sorry"
     unless $schema && $schema->storage;
   my $sqla = $schema->storage->sql_maker;
-  my @sources = my $table = $self->schema->source($self->raw_source_name);
+  my $table = $self->schema->source($self->raw_source_name);
   my $super_view = $self->parent_source;
-  push(@sources, $super_view) if defined($super_view);
+  my @all_parents = my @other_parents = @{$self->additional_parents||[]};
+  push(@all_parents, $super_view) if defined($super_view);
+  my @sources = ($table, @all_parents);
   my @body_cols = map body_cols($_), @sources;
   my @pk_cols = pk_cols $self;
 
   # SELECT statement
 
+  my $am_root = !($super_view || @other_parents);
+
   my $select = $sqla->select(
-    ($super_view
-      ? ([   # FROM _tbl _tbl
+    ($am_root
+      ? ($table->name)
+      : ([   # FROM _tbl _tbl
            { $table->name => $table->name },
-           [ # JOIN view view
-             { $super_view->name => $super_view->name },
-             # ON _tbl.id = view.id
-             { map +(qualify_with($super_view, $_), qualify_with($table, $_)),
-                 names_of @pk_cols }
-           ]
+           map {
+             my $parent = $_;
+             [ # JOIN view view
+               { $parent->name => $parent->name },
+               # ON _tbl.id = view.id
+               { map +(qualify_with($parent, $_), qualify_with($table, $_)),
+                   names_of @pk_cols }
+             ]
+           } @all_parents
          ])
-      : ($table->name)),
+      ),
     [ (qualify_with $table, names_of @pk_cols), names_of @body_cols ],
   ).';';
 
-  my ($now, $next) = grep defined, $super_view, $table;
+  my ($now, @next) = grep defined, $super_view, $table, @other_parents;
 
   # INSERT function
 
@@ -241,21 +350,20 @@ method view_definition () {
       $self->name.'_insert',
       \@body_cols,
       [
-        $sqla->insert( # INSERT INTO _tbl (foo, ...) VALUES (_foo, ...)
+        $sqla->insert( # INSERT INTO tbl/super_view (foo, ...) VALUES (_foo, ...)
           $now->name,
           { arg_hash $now },
         ),
-        ($next
-          ? $sqla->insert( # INSERT INTO super_view (id, ...)
-                           #   VALUES (currval('_root_tbl_id_seq'), ...)
-              $next->name,
-              {
-                (arg_hash $next),
-                id => \"currval('${\$self->root_table->name}_id_seq')",
-              }
-            )
-          : ()
-        )
+        (map {
+          $sqla->insert( # INSERT INTO parent (id, ...)
+                         #   VALUES (currval('_root_tbl_id_seq'), ...)
+            $_->name,
+            {
+              (arg_hash $_),
+              id => \"currval('${\$self->root_table->name}_id_seq')",
+            }
+          )
+        } @next)
       ];
 
   # note - similar to arg_hash but not quite enough to share code sanely