X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FDBIx%2FClass%2FStorage%2FDBIHacks.pm;h=7da10cc4da2502b9088af8326429bfbf09b8176b;hb=229401a04e99e27e256fdcd24b3c34087c9c2bc1;hp=d78ab7483a79c95598b7ea378bde20cef06e1435;hpb=302d35f8b3225b4da3755dd3e3f45efede130533;p=dbsrgits%2FDBIx-Class.git

diff --git a/lib/DBIx/Class/Storage/DBIHacks.pm b/lib/DBIx/Class/Storage/DBIHacks.pm
index d78ab74..7da10cc 100644
--- a/lib/DBIx/Class/Storage/DBIHacks.pm
+++ b/lib/DBIx/Class/Storage/DBIHacks.pm
@@ -15,8 +15,9 @@ use mro 'c3';
 
 use List::Util 'first';
 use Scalar::Util 'blessed';
-use Sub::Name 'subname';
-use DBIx::Class::_Util qw(is_plain_value is_literal_value);
+use DBIx::Class::_Util qw(UNRESOLVABLE_CONDITION serialize);
+use SQL::Abstract qw(is_plain_value is_literal_value);
+use DBIx::Class::Carp;
 use namespace::clean;
 
 #
@@ -111,8 +112,8 @@ sub _adjust_select_args_for_complex_prefetch {
   my $outer_attrs = { %$attrs };
   delete @{$outer_attrs}{qw(from bind rows offset group_by _grouped_by_distinct having)};
 
-  my $inner_attrs = { %$attrs };
-  delete @{$inner_attrs}{qw(for collapse select as _related_results_construction)};
+  my $inner_attrs = { %$attrs, _simple_passthrough_construction => 1 };
+  delete @{$inner_attrs}{qw(for collapse select as)};
 
   # there is no point of ordering the insides if there is no limit
   delete $inner_attrs->{order_by} if (
@@ -416,7 +417,7 @@ sub _resolve_aliastypes_from_select_args {
   # generate sql chunks
   my $to_scan = {
     restricting => [
-      $sql_maker->_recurse_where ($attrs->{where}),
+      ($sql_maker->_recurse_where ($attrs->{where}))[0],
       $sql_maker->_parse_rs_attrs ({ having => $attrs->{having} }),
     ],
     grouping => [
@@ -429,111 +430,115 @@ sub _resolve_aliastypes_from_select_args {
       ),
     ],
     selecting => [
-      map { ($sql_maker->_recurse_fields($_))[0] } @{$attrs->{select}},
+      # kill all selectors which look like a proper subquery
+      # this is a sucky heuristic *BUT* - if we get it wrong the query will simply
+      # fail to run, so we are relatively safe
+      grep
+        { $_ !~ / \A \s* \( \s* SELECT \s+ .+? \s+ FROM \s+ .+? \) \s* \z /xsi }
+        map
+          { ($sql_maker->_recurse_fields($_))[0] }
+          @{$attrs->{select}}
     ],
-    ordering => [
-      map { $_->[0] } $self->_extract_order_criteria ($attrs->{order_by}, $sql_maker),
+    ordering => [ map
+      {
+        ( my $sql = (ref $_ ? $_->[0] : $_) ) =~ s/ \s+ (?: ASC | DESC ) \s* \z //xi;
+        $sql;
+      }
+      $sql_maker->_order_by_chunks( $attrs->{order_by} ),
     ],
   };
 
-  # throw away empty chunks and all 2-value arrayrefs: the thinking is that these are
-  # bind value specs left in by the sloppy renderer above. It is ok to do this
-  # at this point, since we are going to end up rewriting this crap anyway
-  for my $v (values %$to_scan) {
-    my @nv;
-    for (@$v) {
-      next if (
-        ! defined $_
-          or
-        (
-          ref $_ eq 'ARRAY'
-            and
-          ( @$_ == 0 or @$_ == 2 )
-        )
-      );
+  # throw away empty-string chunks, and make sure no binds snuck in
+  # note that we operate over @{$to_scan->{$type}}, hence the
+  # semi-mindbending ... map ... for values ...
+  ( $_ = [ map {
 
-      if (ref $_) {
-        require Data::Dumper::Concise;
-        $self->throw_exception("Unexpected ref in scan-plan: " . Data::Dumper::Concise::Dumper($v) );
-      }
+      (not $_)        ? ()
+    : (length ref $_) ? (require Data::Dumper::Concise && $self->throw_exception(
+                          "Unexpected ref in scan-plan: " . Data::Dumper::Concise::Dumper($_)
+                        ))
+    :                   $_
 
-      push @nv, $_;
-    }
+  } @$_ ] ) for values %$to_scan;
 
-    $v = \@nv;
-  }
+  # throw away empty to-scan's
+  (
+    @{$to_scan->{$_}}
+      or
+    delete $to_scan->{$_}
+  ) for keys %$to_scan;
 
-  # kill all selectors which look like a proper subquery
-  # this is a sucky heuristic *BUT* - if we get it wrong the query will simply
-  # fail to run, so we are relatively safe
-  $to_scan->{selecting} = [ grep {
-    $_ !~ / \A \s* \( \s* SELECT \s+ .+? \s+ FROM \s+ .+? \) \s* \z /xsi
-  } @{ $to_scan->{selecting} || [] } ];
 
-  # first see if we have any exact matches (qualified or unqualified)
+  # the actual scan, per type
   for my $type (keys %$to_scan) {
+
+    # first see if we have any exact matches (qualified or unqualified)
     for my $piece (@{$to_scan->{$type}}) {
       if ($colinfo->{$piece} and my $alias = $colinfo->{$piece}{-source_alias}) {
         $aliases_by_type->{$type}{$alias} ||= { -parents => $alias_list->{$alias}{-join_path}||[] };
         $aliases_by_type->{$type}{$alias}{-seen_columns}{$colinfo->{$piece}{-fq_colname}} = $piece;
       }
     }
-  }
 
-  # now loop through all fully qualified columns and get the corresponding
-  # alias (should work even if they are in scalarrefs)
-  for my $alias (keys %$alias_list) {
-    my $al_re = qr/
-      $lquote $alias $rquote $sep (?: $lquote ([^$rquote]+) $rquote )?
-        |
-      \b $alias \. ([^\s\)\($rquote]+)?
-    /x;
-
-    for my $type (keys %$to_scan) {
-      for my $piece (@{$to_scan->{$type}}) {
-        if (my @matches = $piece =~ /$al_re/g) {
-          $aliases_by_type->{$type}{$alias} ||= { -parents => $alias_list->{$alias}{-join_path}||[] };
-          $aliases_by_type->{$type}{$alias}{-seen_columns}{"$alias.$_"} = "$alias.$_"
-            for grep { defined $_ } @matches;
-        }
+    # we will be bulk-scanning anyway - pieces will not matter in that case
+    # (unlike in the direct-equivalence above)
+    my $scan_string = join ' ', @{$to_scan->{$type}};
+
+    # now loop through all fully qualified columns and get the corresponding
+    # alias (should work even if they are in scalarrefs)
+    for my $alias (keys %$alias_list) {
+      my $al_re = qr/
+        $lquote $alias $rquote $sep (?: $lquote ([^$rquote]+) $rquote )?
+          |
+        \b $alias \. ([^\s\)\($rquote]+)?
+      /x;
+
+      if (my @matches = $scan_string =~ /$al_re/g) {
+        $aliases_by_type->{$type}{$alias} ||= { -parents => $alias_list->{$alias}{-join_path}||[] };
+        $aliases_by_type->{$type}{$alias}{-seen_columns}{"$alias.$_"} = "$alias.$_"
+          for grep { defined $_ } @matches;
       }
     }
-  }
 
-  # now loop through unqualified column names, and try to locate them within
-  # the chunks
-  for my $col (keys %$colinfo) {
-    next if $col =~ / \. /x;   # if column is qualified it was caught by the above
+    # now loop through unqualified column names, and try to locate them within
+    # the chunks
+    for my $col (keys %$colinfo) {
+      next if $col =~ / \. /x;   # if column is qualified it was caught by the above
 
-    my $col_re = qr/ $lquote ($col) $rquote /x;
+      my $col_re = qr/ $lquote ($col) $rquote /x;
 
-    for my $type (keys %$to_scan) {
-      for my $piece (@{$to_scan->{$type}}) {
-        if ( my @matches = $piece =~ /$col_re/g) {
-          my $alias = $colinfo->{$col}{-source_alias};
-          $aliases_by_type->{$type}{$alias} ||= { -parents => $alias_list->{$alias}{-join_path}||[] };
-          $aliases_by_type->{$type}{$alias}{-seen_columns}{"$alias.$_"} = $_
-            for grep { defined $_ } @matches;
-        }
+      if ( my @matches = $scan_string =~ /$col_re/g) {
+        my $alias = $colinfo->{$col}{-source_alias};
+        $aliases_by_type->{$type}{$alias} ||= { -parents => $alias_list->{$alias}{-join_path}||[] };
+        $aliases_by_type->{$type}{$alias}{-seen_columns}{"$alias.$_"} = $_
+          for grep { defined $_ } @matches;
       }
     }
   }
 
   # Add any non-left joins to the restriction list (such joins are indeed restrictions)
-  for my $j (values %$alias_list) {
-    my $alias = $j->{-alias} or next;
-    $aliases_by_type->{restricting}{$alias} ||= { -parents => $j->{-join_path}||[] } if (
-      (not $j->{-join_type})
+  (
+    $_->{-alias}
+      and
+    ! $aliases_by_type->{restricting}{ $_->{-alias} }
+      and
+    (
+      not $_->{-join_type}
         or
-      ($j->{-join_type} !~ /^left (?: \s+ outer)? $/xi)
-    );
-  }
+      $_->{-join_type} !~ /^left (?: \s+ outer)? $/xi
+    )
+      and
+    $aliases_by_type->{restricting}{ $_->{-alias} } = { -parents => $_->{-join_path}||[] }
+  ) for values %$alias_list;
 
-  for (keys %$aliases_by_type) {
-    delete $aliases_by_type->{$_} unless keys %{$aliases_by_type->{$_}};
-  }
+  # final cleanup
+  (
+    keys %{$aliases_by_type->{$_}}
+      or
+    delete $aliases_by_type->{$_}
+  ) for keys %$aliases_by_type;
 
-  return $aliases_by_type;
+  $aliases_by_type;
 }
 
 # This is the engine behind { distinct => 1 } and the general
@@ -714,53 +719,63 @@ sub _resolve_column_info {
 
   return {} if $colnames and ! @$colnames;
 
-  my $alias2src = $self->_resolve_ident_sources($ident);
+  my $sources = $self->_resolve_ident_sources($ident);
+
+  $_ = { rsrc => $_, colinfos => $_->columns_info }
+    for values %$sources;
 
   my (%seen_cols, @auto_colnames);
 
   # compile a global list of column names, to be able to properly
   # disambiguate unqualified column names (if at all possible)
-  for my $alias (keys %$alias2src) {
-    my $rsrc = $alias2src->{$alias};
-    for my $colname ($rsrc->columns) {
-      push @{$seen_cols{$colname}}, $alias;
-      push @auto_colnames, "$alias.$colname" unless $colnames;
-    }
+  for my $alias (keys %$sources) {
+    (
+      ++$seen_cols{$_}{$alias}
+        and
+      ! $colnames
+        and
+      push @auto_colnames, "$alias.$_"
+    ) for keys %{ $sources->{$alias}{colinfos} };
   }
 
   $colnames ||= [
     @auto_colnames,
-    grep { @{$seen_cols{$_}} == 1 } (keys %seen_cols),
+    ( grep { keys %{$seen_cols{$_}} == 1 } keys %seen_cols ),
   ];
 
-  my (%return, $colinfos);
-  foreach my $col (@$colnames) {
-    my ($source_alias, $colname) = $col =~ m/^ (?: ([^\.]+) \. )? (.+) $/x;
+  my %return;
+  for (@$colnames) {
+    my ($colname, $source_alias) = reverse split /\./, $_;
 
-    # if the column was seen exactly once - we know which rsrc it came from
-    $source_alias ||= $seen_cols{$colname}[0]
-      if ($seen_cols{$colname} and @{$seen_cols{$colname}} == 1);
-
-    next unless $source_alias;
+    my $assumed_alias =
+      $source_alias
+        ||
+      # if the column was seen exactly once - we know which rsrc it came from
+      (
+        $seen_cols{$colname}
+          and
+        keys %{$seen_cols{$colname}} == 1
+          and
+        ( %{$seen_cols{$colname}} )[0]
+      )
+        ||
+      next
+    ;
 
-    my $rsrc = $alias2src->{$source_alias}
-      or next;
+    $self->throw_exception(
+      "No such column '$colname' on source " . $sources->{$assumed_alias}{rsrc}->source_name
+    ) unless $seen_cols{$colname}{$assumed_alias};
 
-    $return{$col} = {
-      %{
-          ( $colinfos->{$source_alias} ||= $rsrc->columns_info )->{$colname}
-            ||
-          $self->throw_exception(
-            "No such column '$colname' on source " . $rsrc->source_name
-          );
-      },
-      -result_source => $rsrc,
-      -source_alias => $source_alias,
-      -fq_colname => $col eq $colname ? "$source_alias.$col" : $col,
+    $return{$_} = {
+      %{ $sources->{$assumed_alias}{colinfos}{$colname} },
+      -result_source => $sources->{$assumed_alias}{rsrc},
+      -source_alias => $assumed_alias,
+      -fq_colname => "$assumed_alias.$colname",
       -colname => $colname,
     };
 
-    $return{"$source_alias.$colname"} = $return{$col} if $col eq $colname;
+    $return{"$assumed_alias.$colname"} = $return{$_}
+      unless $source_alias;
   }
 
   return \%return;
@@ -887,7 +902,7 @@ sub _order_by_is_stable {
 
   my @cols = (
     ( map { $_->[0] } $self->_extract_order_criteria($order_by) ),
-    ( $where ? @{ $self->_extract_fixed_condition_columns($where) || [] } : () ),
+    ( $where ? keys %{ $self->_extract_fixed_condition_columns($where) } : () ),
   ) or return 0;
 
   my $colinfo = $self->_resolve_column_info($ident, \@cols);
@@ -965,7 +980,7 @@ sub _extract_colinfo_of_stable_main_source_order_by_portion {
           ? $colinfos->{$_}{-colname}
           : ()
       }
-      @{$self->_extract_fixed_condition_columns($attrs->{where}) || []}
+      keys %{ $self->_extract_fixed_condition_columns($attrs->{where}) }
     )
     : ()
   ];
@@ -986,6 +1001,8 @@ sub _extract_colinfo_of_stable_main_source_order_by_portion {
 sub _collapse_cond {
   my ($self, $where, $where_is_anded_array) = @_;
 
+  my $fin;
+
   if (! $where) {
     return;
   }
@@ -998,17 +1015,33 @@ sub _collapse_cond {
       my $chunk = shift @pieces;
 
       if (ref $chunk eq 'HASH') {
-        push @pairs, map { [ $_ => $chunk->{$_} ] } sort keys %$chunk;
+        for (sort keys %$chunk) {
+
+          # Match SQLA 1.79 behavior
+          if ($_ eq '') {
+            is_literal_value($chunk->{$_})
+              ? carp 'Hash-pairs consisting of an empty string with a literal are deprecated, use -and => [ $literal ] instead'
+              : $self->throw_exception("Supplying an empty left hand side argument is not supported in hash-pairs")
+            ;
+          }
+
+          push @pairs, $_ => $chunk->{$_};
+        }
       }
       elsif (ref $chunk eq 'ARRAY') {
-        push @pairs, [ -or => $chunk ]
+        push @pairs, -or => $chunk
           if @$chunk;
       }
-      elsif ( ! ref $chunk) {
-        push @pairs, [ $chunk, shift @pieces ];
+      elsif ( ! length ref $chunk) {
+
+        # Match SQLA 1.79 behavior
+        $self->throw_exception("Supplying an empty left hand side argument is not supported in array-pairs")
+          if $where_is_anded_array and (! defined $chunk or $chunk eq '');
+
+        push @pairs, $chunk, shift @pieces;
       }
       else {
-        push @pairs, [ '', $chunk ];
+        push @pairs, '', $chunk;
       }
     }
 
@@ -1018,25 +1051,31 @@ sub _collapse_cond {
       or return;
 
     # Consolidate various @conds back into something more compact
-    my $fin;
-
     for my $c (@conds) {
       if (ref $c ne 'HASH') {
         push @{$fin->{-and}}, $c;
       }
       else {
         for my $col (sort keys %$c) {
-          if (exists $fin->{$col}) {
-            my ($l, $r) = ($fin->{$col}, $c->{$col});
-
-            (ref $_ ne 'ARRAY' or !@$_) and $_ = [ -and => $_ ] for ($l, $r);
 
-            if (@$l and @$r and $l->[0] eq $r->[0] and $l->[0] eq '-and') {
-              $fin->{$col} = [ -and => map { @$_[1..$#$_] } ($l, $r) ];
-            }
-            else {
-              $fin->{$col} = [ -and => $fin->{$col}, $c->{$col} ];
-            }
+          # consolidate all -and nodes
+          if ($col =~ /^\-and$/i) {
+            push @{$fin->{-and}},
+              ref $c->{$col} eq 'ARRAY' ? @{$c->{$col}}
+            : ref $c->{$col} eq 'HASH' ? %{$c->{$col}}
+            : { $col => $c->{$col} }
+            ;
+          }
+          elsif ($col =~ /^\-/) {
+            push @{$fin->{-and}}, { $col => $c->{$col} };
+          }
+          elsif (exists $fin->{$col}) {
+            $fin->{$col} = [ -and => map {
+              (ref $_ eq 'ARRAY' and ($_->[0]||'') =~ /^\-and$/i )
+                ? @{$_}[1..$#$_]
+                : $_
+              ;
+            } ($fin->{$col}, $c->{$col}) ];
           }
           else {
             $fin->{$col} = $c->{$col};
@@ -1044,58 +1083,144 @@ sub _collapse_cond {
         }
       }
     }
-
-    if ( ref $fin->{-and} eq 'ARRAY' and @{$fin->{-and}} == 1 ) {
-      my $piece = (delete $fin->{-and})->[0];
-      if (ref $piece eq 'ARRAY') {
-        $fin->{-or} = $fin->{-or} ? [ $piece, $fin->{-or} ] : $piece;
-      }
-      elsif (! exists $fin->{''}) {
-        $fin->{''} = $piece;
-      }
-    }
-
-    return $fin;
   }
   elsif (ref $where eq 'ARRAY') {
-    my @w = @$where;
+    # we are always at top-level here, it is safe to dump empty *standalone* pieces
+    my $fin_idx;
 
-    while ( @w and (
-      (ref $w[0] eq 'ARRAY' and ! @{$w[0]} )
-        or
-      (ref $w[0] eq 'HASH' and ! keys %{$w[0]})
-    )) { shift @w };
+    for (my $i = 0; $i <= $#$where; $i++ ) {
 
-    return unless @w;
+      # Match SQLA 1.79 behavior
+      $self->throw_exception(
+        "Supplying an empty left hand side argument is not supported in array-pairs"
+      ) if (! defined $where->[$i] or ! length $where->[$i]);
 
-    if ( @w == 1 ) {
-      return ( ref $w[0] )
-        ? $self->_collapse_cond($w[0])
-        : { $w[0] => undef }
-      ;
-    }
-    elsif ( ref $w[0] ) {
-      return \@w;
-    }
-    elsif ( @w == 2 ) {
-      if ( ( $w[0]||'' ) =~ /^\-and$/i ) {
-        return (ref $w[1] eq 'HASH' or ref $w[1] eq 'ARRAY')
-          ? $self->_collapse_cond($w[1], (ref $w[1] eq 'ARRAY') )
-          : $self->throw_exception("Unsupported top-level op/arg pair: [ $w[0] => $w[1] ]")
-        ;
+      my $logic_mod = lc ( ($where->[$i] =~ /^(\-(?:and|or))$/i)[0] || '' );
+
+      if ($logic_mod) {
+        $i++;
+        $self->throw_exception("Unsupported top-level op/arg pair: [ $logic_mod => $where->[$i] ]")
+          unless ref $where->[$i] eq 'HASH' or ref $where->[$i] eq 'ARRAY';
+
+        my $sub_elt = $self->_collapse_cond({ $logic_mod => $where->[$i] })
+          or next;
+
+        my @keys = keys %$sub_elt;
+        if ( @keys == 1 and $keys[0] !~ /^\-/ ) {
+          $fin_idx->{ "COL_$keys[0]_" . serialize $sub_elt } = $sub_elt;
+        }
+        else {
+          $fin_idx->{ "SER_" . serialize $sub_elt } = $sub_elt;
+        }
+      }
+      elsif (! length ref $where->[$i] ) {
+        my $sub_elt = $self->_collapse_cond({ @{$where}[$i, $i+1] })
+          or next;
+
+        $fin_idx->{ "COL_$where->[$i]_" . serialize $sub_elt } = $sub_elt;
+        $i++;
       }
       else {
-        return $self->_collapse_cond({ @w });
+        $fin_idx->{ "SER_" . serialize $where->[$i] } = $self->_collapse_cond( $where->[$i] ) || next;
+      }
+    }
+
+    if (! $fin_idx) {
+      return;
+    }
+    elsif ( keys %$fin_idx == 1 ) {
+      $fin = (values %$fin_idx)[0];
+    }
+    else {
+      my @or;
+
+      # at this point everything is at most one level deep - unroll if needed
+      for (sort keys %$fin_idx) {
+        if ( ref $fin_idx->{$_} eq 'HASH' and keys %{$fin_idx->{$_}} == 1 ) {
+          my ($l, $r) = %{$fin_idx->{$_}};
+
+          if (
+            ref $r eq 'ARRAY'
+              and
+            (
+              ( @$r == 1 and $l =~ /^\-and$/i )
+                or
+              $l =~ /^\-or$/i
+            )
+          ) {
+            push @or, @$r
+          }
+
+          elsif (
+            ref $r eq 'HASH'
+              and
+            keys %$r == 1
+              and
+            $l =~ /^\-(?:and|or)$/i
+          ) {
+            push @or, %$r;
+          }
+
+          else {
+            push @or, $l, $r;
+          }
+        }
+        else {
+          push @or, $fin_idx->{$_};
+        }
       }
+
+      $fin->{-or} = \@or;
     }
   }
   else {
     # not a hash not an array
-    return { '' => $where };
+    $fin = { -and => [ $where ] };
+  }
+
+  # unroll single-element -and's
+  while (
+    $fin->{-and}
+      and
+    @{$fin->{-and}} < 2
+  ) {
+    my $and = delete $fin->{-and};
+    last if @$and == 0;
+
+    # at this point we have @$and == 1
+    if (
+      ref $and->[0] eq 'HASH'
+        and
+      ! grep { exists $fin->{$_} } keys %{$and->[0]}
+    ) {
+      $fin = {
+        %$fin, %{$and->[0]}
+      };
+    }
+    else {
+      $fin->{-and} = $and;
+      last;
+    }
   }
 
-  # catchall, some of the things above fall through
-  return $where;
+  # compress same-column conds found in $fin
+  for my $col ( grep { $_ !~ /^\-/ } keys %$fin ) {
+    next unless ref $fin->{$col} eq 'ARRAY' and ($fin->{$col}[0]||'') =~ /^\-and$/i;
+    my $val_bag = { map {
+      (! defined $_ )                          ? ( UNDEF => undef )
+    : ( ! length ref $_ or is_plain_value $_ ) ? ( "VAL_$_" => $_ )
+    : ( ( 'SER_' . serialize $_ ) => $_ )
+    } @{$fin->{$col}}[1 .. $#{$fin->{$col}}] };
+
+    if (keys %$val_bag == 1 ) {
+      ($fin->{$col}) = values %$val_bag;
+    }
+    else {
+      $fin->{$col} = [ -and => map { $val_bag->{$_} } sort keys %$val_bag ];
+    }
+  }
+
+  return keys %$fin ? $fin : ();
 }
 
 sub _collapse_cond_unroll_pairs {
@@ -1104,7 +1229,7 @@ sub _collapse_cond_unroll_pairs {
   my @conds;
 
   while (@$pairs) {
-    my ($lhs, $rhs) = @{ shift @$pairs };
+    my ($lhs, $rhs) = splice @$pairs, 0, 2;
 
     if ($lhs eq '') {
       push @conds, $self->_collapse_cond($rhs);
@@ -1121,25 +1246,44 @@ sub _collapse_cond_unroll_pairs {
       if (ref $rhs eq 'HASH' and ! keys %$rhs) {
         # FIXME - SQLA seems to be doing... nothing...?
       }
+      # normalize top level -ident, for saner extract_fixed_condition_columns code
+      elsif (ref $rhs eq 'HASH' and keys %$rhs == 1 and exists $rhs->{-ident}) {
+        push @conds, { $lhs => { '=', $rhs } };
+      }
+      elsif (ref $rhs eq 'HASH' and keys %$rhs == 1 and exists $rhs->{-value} and is_plain_value $rhs->{-value}) {
+        push @conds, { $lhs => $rhs->{-value} };
+      }
       elsif (ref $rhs eq 'HASH' and keys %$rhs == 1 and exists $rhs->{'='}) {
-        for my $p ($self->_collapse_cond_unroll_pairs([ [ $lhs => $rhs->{'='} ] ])) {
-
-          # extra sanity check
-          if (keys %$p > 1) {
-            require Data::Dumper::Concise;
-            local $Data::Dumper::Deepcopy = 1;
-            $self->throw_exception(
-              "Internal error: unexpected collapse unroll:"
-            . Data::Dumper::Concise::Dumper { in => { $lhs => $rhs }, out => $p }
-            );
-          }
-
-          my ($l, $r) = %$p;
+        if ( length ref $rhs->{'='} and is_literal_value $rhs->{'='} ) {
+          push @conds, { $lhs => $rhs };
+        }
+        else {
+          for my $p ($self->_collapse_cond_unroll_pairs([ $lhs => $rhs->{'='} ])) {
+
+            # extra sanity check
+            if (keys %$p > 1) {
+              require Data::Dumper::Concise;
+              local $Data::Dumper::Deepcopy = 1;
+              $self->throw_exception(
+                "Internal error: unexpected collapse unroll:"
+              . Data::Dumper::Concise::Dumper { in => { $lhs => $rhs }, out => $p }
+              );
+            }
 
-          push @conds, ( ! length ref $r or is_plain_value($r) )
-            ? { $l => $r }
-            : { $l => { '=' => $r } }
-          ;
+            my ($l, $r) = %$p;
+
+            push @conds, (
+              ! length ref $r
+                or
+              # the unroller recursion may return a '=' prepended value already
+              ref $r eq 'HASH' and keys %$rhs == 1 and exists $rhs->{'='}
+                or
+              is_plain_value($r)
+            )
+              ? { $l => $r }
+              : { $l => { '=' => $r } }
+            ;
+          }
         }
       }
       elsif (ref $rhs eq 'ARRAY') {
@@ -1153,23 +1297,35 @@ sub _collapse_cond_unroll_pairs {
             if  @$rhs == 1;
 
           if( $rhs->[0] =~ /^\-and$/i ) {
-            unshift @$pairs, map { [ $lhs => $_ ] } @{$rhs}[1..$#$rhs];
+            unshift @$pairs, map { $lhs => $_ } @{$rhs}[1..$#$rhs];
           }
           # if not an AND then it's an OR
           elsif(@$rhs == 2) {
-            unshift @$pairs, [ $lhs => $rhs->[1] ];
+            unshift @$pairs, $lhs => $rhs->[1];
           }
           else {
-            push @conds, { $lhs => $rhs };
+            push @conds, { $lhs => [ @{$rhs}[1..$#$rhs] ] };
           }
         }
         elsif (@$rhs == 1) {
-          unshift @$pairs, [ $lhs => $rhs->[0] ];
+          unshift @$pairs, $lhs => $rhs->[0];
         }
         else {
           push @conds, { $lhs => $rhs };
         }
       }
+      # unroll func + { -value => ... }
+      elsif (
+        ref $rhs eq 'HASH'
+          and
+        ( my ($subop) = keys %$rhs ) == 1
+          and
+        length ref ((values %$rhs)[0])
+          and
+        my $vref = is_plain_value( (values %$rhs)[0] )
+      ) {
+        push @conds, { $lhs => { $subop => $$vref } }
+      }
       else {
         push @conds, { $lhs => $rhs };
       }
@@ -1179,48 +1335,89 @@ sub _collapse_cond_unroll_pairs {
   return @conds;
 }
 
-
-# returns an arrayref of column names which *definitely* have some
-# sort of non-nullable *single* equality requested in the given condition
-# specification. This is used to figure out if a resultset is
-# constrained to a column which is part of a unique constraint,
-# which in turn allows us to better predict how ordering will behave
-# etc.
+# Analyzes a given condition and attempts to extract all columns
+# with a definitive fixed-condition criteria. Returns a hashref
+# of k/v pairs suitable to be passed to set_columns(), with a
+# MAJOR CAVEAT - multi-value (contradictory) equalities are still
+# represented as a reference to the UNRESOVABLE_CONDITION constant
+# The reason we do this is that some codepaths only care about the
+# codition being stable, as opposed to actually making sense
+#
+# The normal mode is used to figure out if a resultset is constrained
+# to a column which is part of a unique constraint, which in turn
+# allows us to better predict how ordering will behave etc.
+#
+# With the optional "consider_nulls" boolean argument, the function
+# is instead used to infer inambiguous values from conditions
+# (e.g. the inheritance of resultset conditions on new_result)
 #
-# this is a rudimentary, incomplete, and error-prone extractor
-# however this is OK - it is conservative, and if we can not find
-# something that is in fact there - the stack will recover gracefully
 sub _extract_fixed_condition_columns {
-  my $self = shift;
-  my $where_hash = $self->_collapse_cond(shift);
-
-  my $res;
-  for my $c (keys %$where_hash) {
-    if (defined (my $v = $where_hash->{$c}) ) {
-      if (
-        ! length ref $v
-          or
-        is_plain_value ($v)
-          or
+  my ($self, $where, $consider_nulls) = @_;
+  my $where_hash = $self->_collapse_cond($_[1]);
+
+  my $res = {};
+  my ($c, $v);
+  for $c (keys %$where_hash) {
+    my $vals;
+
+    if (!defined ($v = $where_hash->{$c}) ) {
+      $vals->{UNDEF} = $v if $consider_nulls
+    }
+    elsif (
+      ref $v eq 'HASH'
+        and
+      keys %$v == 1
+    ) {
+      if (exists $v->{-value}) {
+        if (defined $v->{-value}) {
+          $vals->{"VAL_$v->{-value}"} = $v->{-value}
+        }
+        elsif( $consider_nulls ) {
+          $vals->{UNDEF} = $v->{-value};
+        }
+      }
+      # do not need to check for plain values - _collapse_cond did it for us
+      elsif(
+        length ref $v->{'='}
+          and
         (
-          ref $v eq 'HASH'
-            and
-          keys %$v == 1
-            and
-          ref $v->{'='}
-            and
+          ( ref $v->{'='} eq 'HASH' and keys %{$v->{'='}} == 1 and exists $v->{'='}{-ident} )
+            or
           is_literal_value($v->{'='})
         )
-      ) {
-        $res->{$c} = 1;
+       ) {
+        $vals->{ 'SER_' . serialize $v->{'='} } = $v->{'='};
       }
-      elsif (ref $v eq 'ARRAY' and ($v->[0]||'') eq '-and') {
-        $res->{$_} = 1 for map { @{ $self->_extract_fixed_condition_columns({ $c => $_ }) } } @{$v}[1..$#$v];
+    }
+    elsif (
+      ! length ref $v
+        or
+      is_plain_value ($v)
+    ) {
+      $vals->{"VAL_$v"} = $v;
+    }
+    elsif (ref $v eq 'ARRAY' and ($v->[0]||'') eq '-and') {
+      for ( @{$v}[1..$#$v] ) {
+        my $subval = $self->_extract_fixed_condition_columns({ $c => $_ }, 'consider nulls');  # always fish nulls out on recursion
+        next unless exists $subval->{$c};  # didn't find anything
+        $vals->{
+          ! defined $subval->{$c}                                        ? 'UNDEF'
+        : ( ! length ref $subval->{$c} or is_plain_value $subval->{$c} ) ? "VAL_$subval->{$c}"
+        : ( 'SER_' . serialize $subval->{$c} )
+        } = $subval->{$c};
       }
     }
+
+    if (keys %$vals == 1) {
+      ($res->{$c}) = (values %$vals)
+        unless !$consider_nulls and exists $vals->{UNDEF};
+    }
+    elsif (keys %$vals > 1) {
+      $res->{$c} = UNRESOLVABLE_CONDITION;
+    }
   }
 
-  return [ sort keys %$res ];
+  $res;
 }
 
 1;