More FAQs!

[dbsrgits/DBIx-Class.git] / lib / DBIx / Class / ResultSet.pm

diff --git a/lib/DBIx/Class/ResultSet.pm b/lib/DBIx/Class/ResultSet.pm
index 4f5f722..689586f 100644 (file)
--- a/lib/DBIx/Class/ResultSet.pm
+++ b/lib/DBIx/Class/ResultSet.pm
@@ -157,6 +157,12 @@ always return a resultset, even in list context.
 sub search_rs {
   my $self = shift;
 
+  my $rows;
+
+  unless (@_) {                 # no search, effectively just a clone
+    $rows = $self->get_cache;
+  }
+
   my $attrs = {};
   $attrs = pop(@_) if @_ > 1 and ref $_[$#_] eq 'HASH';
   my $our_attrs = exists $attrs->{_parent_attrs}
@@ -189,12 +195,6 @@ sub search_rs {
     $our_attrs->{join}, $attrs->{_live_join_h}
   ) if ($attrs->{_live_join_h});
 
-  if (defined $our_attrs->{prefetch}) {
-    $our_attrs->{join} = $self->_merge_attr(
-      $our_attrs->{join}, $our_attrs->{prefetch}
-    );
-  }
-
   my $new_attrs = { %{$our_attrs}, %{$attrs} };
   my $where = (@_
     ? (
@@ -236,11 +236,8 @@ sub search_rs {
   my $rs = (ref $self)->new($self->result_source, $new_attrs);
   $rs->{_parent_source} = $self->{_parent_source} if $self->{_parent_source};
 
-  unless (@_) {                 # no search, effectively just a clone
-    my $rows = $self->get_cache;
-    if ($rows) {
-      $rs->set_cache($rows);
-    }
+  if ($rows) {
+    $rs->set_cache($rows);
   }
   return $rs;
 }
@@ -365,6 +362,7 @@ sub find {
 sub _unique_queries {
   my ($self, $query, $attrs) = @_;
 
+  my $alias = $self->{attrs}{alias};
   my @constraint_names = exists $attrs->{key}
     ? ($attrs->{key})
     : $self->result_source->unique_constraint_names;
@@ -374,15 +372,21 @@ sub _unique_queries {
     my @unique_cols = $self->result_source->unique_constraint_columns($name);
     my $unique_query = $self->_build_unique_query($query, \@unique_cols);
 
-    next unless scalar keys %$unique_query;
+    my $num_query = scalar keys %$unique_query;
+    next unless $num_query;
 
     # Add the ResultSet's alias
-    my $alias = $self->{attrs}{alias};
-    foreach my $key (grep { ! m/\./ } keys %$unique_query) {
-      $unique_query->{"$alias.$key"} = delete $unique_query->{$key};
+    foreach my $col (grep { ! m/\./ } keys %$unique_query) {
+      $unique_query->{"$alias.$col"} = delete $unique_query->{$col};
     }
 
-    push @unique_queries, $unique_query;
+    # XXX: Assuming quite a bit about $self->{attrs}{where}
+    my $num_cols = scalar @unique_cols;
+    my $num_where = exists $self->{attrs}{where}
+      ? scalar keys %{ $self->{attrs}{where} }
+      : 0;
+    push @unique_queries, $unique_query
+      if $num_query + $num_where == $num_cols;
   }
 
   return @unique_queries;
@@ -555,9 +559,9 @@ sub _collapse_query {
     }
     else {
 #      warn "LEAF: " . Dumper $query;
-      foreach my $key (keys %$query) {
-        my $value = $query->{$key};
-        $collapsed->{$key}{$value}++;
+      foreach my $col (keys %$query) {
+        my $value = $query->{$col};
+        $collapsed->{$col}{$value}++;
       }
     }
   }
@@ -693,13 +697,14 @@ sub _resolved_attrs {
   my $self = shift;
   return $self->{_attrs} if $self->{_attrs};
 
-  my $attrs = $self->{attrs};
+  my $attrs = { %{$self->{attrs}||{}} };
   my $source = $self->{_parent_source} || $self->{result_source};
   my $alias = $attrs->{_orig_alias};
 
   # XXX - lose storable dclone
   my $record_filter = delete $attrs->{record_filter};
-  $attrs = Storable::dclone($attrs || {}); # { %{ $attrs || {} } };
+  #$attrs = Storable::dclone($attrs || {}); # { %{ $attrs || {} } };
+
   $attrs->{record_filter} = $record_filter if $record_filter;
 
   $attrs->{columns} ||= delete $attrs->{cols} if exists $attrs->{cols};
@@ -734,15 +739,16 @@ sub _resolved_attrs {
 
   $attrs->{from} ||= [ { $alias => $source->from } ];
   $attrs->{seen_join} ||= {};
-  my %seen;
-  if (my $join = delete $attrs->{join}) {
-    foreach my $j (ref $join eq 'ARRAY' ? @$join : ($join)) {
-      if (ref $j eq 'HASH') {
-        $seen{$_} = 1 foreach keys %$j;
-      } else {
-        $seen{$j} = 1;
-      }
+  if (exists $attrs->{join} || exists $attrs->{prefetch}) {
+
+    my $join = delete $attrs->{join} || {};
+
+    if (defined $attrs->{prefetch}) {
+      $join = $self->_merge_attr(
+        $join, $attrs->{prefetch}
+      );
     }
+
     push(@{$attrs->{from}},
       $source->resolve_join($join, $alias, $attrs->{seen_join})
     );
@@ -759,15 +765,6 @@ sub _resolved_attrs {
   if (my $prefetch = delete $attrs->{prefetch}) {
     my @pre_order;
     foreach my $p (ref $prefetch eq 'ARRAY' ? @$prefetch : ($prefetch)) {
-      if ( ref $p eq 'HASH' ) {
-        foreach my $key (keys %$p) {
-          push(@{$attrs->{from}}, $source->resolve_join($p, $alias))
-            unless $seen{$key};
-        }
-      } else {
-        push(@{$attrs->{from}}, $source->resolve_join($p, $alias))
-          unless $seen{$p};
-      }
       # bring joins back to level of current class
       $p = $self->_reduce_joins($p, $attrs) if $attrs->{_live_join_stack};
       if ($p) {