Another revamp of the selector resolution - now supporting unbalanced select/as
Peter Rabbitson [Tue, 16 Nov 2010 17:02:45 +0000 (18:02 +0100)]
Builds on top of 37aafa2e

Changes
lib/DBIx/Class/ResultSet.pm
t/count/count_rs.t
t/prefetch/grouped.t
t/search/select_chains.t
t/search/select_chains_unbalanced.t [new file with mode: 0644]

diff --git a/Changes b/Changes
index 4d54a76..2870ce9 100644 (file)
--- a/Changes
+++ b/Changes
@@ -5,14 +5,16 @@ Revision history for DBIx::Class
           pairs of column name/info at once
         - $rs->search now throws when called in void context, as it makes
           no sense (and is nearly always a sign of a bug/misdesign)
+        - Restore long-lost ability to supply unbalanced select/as pairs
+          e.g. +select => \'DISTINCT(foo, bar)', +as => ['foo', 'bar']
+        - +columns now behaves just like columns by not stripping a
+          fully-qualified 'as' spec (i.e. foo.bar results in $obj->foo->bar)
         - Deprecate legacy $rs->search( %condition ) syntax (warn once per
           callsite)
         - NULL is now supplied unquoted to all debug-objects, in order to
           differentiate between a real NULL and the string 'NULL'
         - New search() condition operator -value used to pass complex bind
           values to DBI: search({ array_col => { -value => [1,2,3] }})
-        - +columns now behaves just like columns by not stripping a
-          fully-qualified 'as' spec (i.e. foo.bar results in $obj->foo->bar)
         - Add full INSERT...RETURNING support for Oracle
         - Deprecate use of -nest in search conditions (warn once per
           callsite)
index 7b659ef..733c82d 100644 (file)
@@ -22,6 +22,7 @@ use namespace::clean;
 
 BEGIN {
   # De-duplication in _merge_attr() is disabled, but left in for reference
+  # (the merger is used for other things that ought not to be de-duped)
   *__HM_DEDUP = sub () { 0 };
 }
 
@@ -206,6 +207,10 @@ sub new {
 
   $attrs->{alias} ||= 'me';
 
+  # default selection list
+  $attrs->{columns} = [ $source->resolve->columns ]
+    unless List::Util::first { exists $attrs->{$_} } qw/columns cols select as _trailing_select/;
+
   # Creation of {} and bless separated to mitigate RH perl bug
   # see https://bugzilla.redhat.com/show_bug.cgi?id=196836
   my $self = {
@@ -332,27 +337,63 @@ sub search_rs {
     $cache = $self->get_cache;
   }
 
+  my $rsrc = $self->result_source;
+
   my $old_attrs = { %{$self->{attrs}} };
   my $old_having = delete $old_attrs->{having};
   my $old_where = delete $old_attrs->{where};
 
-  # reset the selector list
-  if (List::Util::first { exists $call_attrs->{$_} } qw{columns select as}) {
-     delete @{$old_attrs}{qw{select as columns +select +as +columns include_columns}};
-  }
 
+  # start with blind overwriting merge
   my $new_attrs = { %{$old_attrs}, %{$call_attrs} };
 
-  # merge new attrs into inherited
+  # join/prefetch use their own crazy merging heuristics
   foreach my $key (qw/join prefetch/) {
-    next unless exists $call_attrs->{$key};
-    $new_attrs->{$key} = $self->_merge_joinpref_attr($old_attrs->{$key}, $call_attrs->{$key});
+    $new_attrs->{$key} = $self->_merge_joinpref_attr($old_attrs->{$key}, $call_attrs->{$key})
+      if exists $call_attrs->{$key};
   }
-  foreach my $key (qw/+select +as +columns include_columns bind/) {
-    next unless exists $call_attrs->{$key};
-    $new_attrs->{$key} = $self->_merge_attr($old_attrs->{$key}, $call_attrs->{$key});
+
+  # stack binds together
+  $new_attrs->{bind} = [ @{ $old_attrs->{bind} || [] }, @{ $call_attrs->{bind} || [] } ];
+
+  # take care of selects (only if anything changed)
+  if (keys %$call_attrs) {
+
+    $self->throw_exception ('_trailing_select is not a public attribute - do not use it in search()')
+      if exists $call_attrs->{_trailing_select};
+
+    my @selector_attrs = qw/select as columns cols +select +as +columns include_columns/;
+
+    # reset the current selector list if new selectors are supplied
+    if (List::Util::first { exists $call_attrs->{$_} } qw/columns cols select as/) {
+      # the new/old acrobatics is because of the merger in the next loop
+      for ($new_attrs, $old_attrs) {
+        delete @{$_}{@selector_attrs, '_trailing_select'};
+      }
+    }
+
+    for (@selector_attrs) {
+      $new_attrs->{$_} = $self->_merge_attr($old_attrs->{$_}, $call_attrs->{$_})
+        if ( exists $old_attrs->{$_} or exists $call_attrs->{$_} );
+    }
+
+    # older deprecated name, use only if {columns} is not there
+    if (my $c = delete $new_attrs->{cols}) {
+      if ($new_attrs->{columns}) {
+        carp "Resultset specifies both the 'columns' and the legacy 'cols' attributes - ignoring 'cols'";
+      }
+      else {
+        $new_attrs->{columns} = $c;
+      }
+    }
+
+    # Normalize the selector list (operates on the passed-in attr structure)
+    # Need to do it on every chain instead of only once on _resolved_attrs, in
+    # order to separate 'as'-ed from blind 'select's
+    $self->_normalize_selection ($new_attrs);
   }
 
+
   # rip apart the rest of @_, parse a condition
   my $call_cond = do {
 
@@ -371,7 +412,7 @@ sub search_rs {
 
   } if @_;
 
-  if( @_ > 1 and ! $self->result_source->result_class->isa('DBIx::Class::CDBICompat') ) {
+  if( @_ > 1 and ! $rsrc->result_class->isa('DBIx::Class::CDBICompat') ) {
     # determine callsite obeying Carp::Clan rules (fucking ugly but don't have better ideas)
     my $callsite = do {
       my $w;
@@ -397,13 +438,104 @@ sub search_rs {
     )
   }
 
-  my $rs = (ref $self)->new($self->result_source, $new_attrs);
+  my $rs = (ref $self)->new($rsrc, $new_attrs);
 
   $rs->set_cache($cache) if ($cache);
 
   return $rs;
 }
 
+sub _normalize_selection {
+  my ($self, $attrs) = @_;
+
+  # merge all balanced selectors into the 'columns' stack, deleting the rest
+  foreach my $key (qw/+columns include_columns/) {
+    $attrs->{columns} = $self->_merge_attr($attrs->{columns}, delete $attrs->{$key})
+      if exists $attrs->{$key};
+  }
+
+  # select/as +select/+as pairs need special handling - the amount of select/as
+  # elements in each pair does *not* have to be equal (think multicolumn
+  # selectors like distinct(foo, bar) ). If the selector is bare (no 'as'
+  # supplied at all) - try to infer the alias, either from the -as parameter
+  # of the selector spec, or use the parameter whole if it looks like a column
+  # name (ugly legacy heuristic). If all fails - leave the selector bare (which
+  # is ok as well), but transport it over a separate attribute to make sure it is
+  # the last thing in the select list, thus unable to throw off the corresponding
+  # 'as' chain
+  for my $pref ('', '+') {
+
+    my ($sel, $as) = map {
+      my $key = "${pref}${_}";
+
+      my $val = [ ref $attrs->{$key} eq 'ARRAY'
+        ? @{$attrs->{$key}}
+        : $attrs->{$key} || ()
+      ];
+      delete $attrs->{$key};
+      $val;
+    } qw/select as/;
+
+    if (! @$as and ! @$sel ) {
+      next;
+    }
+    elsif (@$as and ! @$sel) {
+      $self->throw_exception(
+        "Unable to handle ${pref}as specification (@$as) without a corresponding ${pref}select"
+      );
+    }
+    elsif( ! @$as ) {
+      # no as part supplied at all - try to deduce
+      # if any @$as has been supplied we assume the user knows what (s)he is doing
+      # and blindly keep stacking up pieces
+      my (@new_sel, @new_trailing);
+      for (@$sel) {
+        if ( ref $_ eq 'HASH' and exists $_->{-as} ) {
+          push @$as, $_->{-as};
+          push @new_sel, $_;
+        }
+        # assume any plain no-space, no-parenthesis string to be a column spec
+        # FIXME - this is retarded but is necessary to support shit like 'count(foo)'
+        elsif ( ! ref $_ and $_ =~ /^ [^\s\(\)]+ $/x) {
+          push @$as, $_;
+          push @new_sel, $_;
+        }
+        # if all else fails - shove the selection to the trailing stack and move on
+        else {
+          push @new_trailing, $_;
+        }
+      }
+
+      @$sel = @new_sel;
+      $attrs->{'_trailing_select'} = $self->_merge_attr($attrs->{'_trailing_select'}, \@new_trailing)
+        if @new_trailing;
+    }
+    elsif (@$as < @$sel) {
+      $self->throw_exception(
+        "Unable to handle an ${pref}as specification (@$as) with less elements than the corresponding ${pref}select"
+      );
+    }
+
+    # now see what the result for this pair looks like:
+
+    if (@$as == @$sel) {
+      # if balanced - treat as a columns entry
+      $attrs->{columns} = $self->_merge_attr(
+        $attrs->{columns},
+        { map { $as->[$_] => $sel->[$_] } ( 0 .. $#$as ) }
+      );
+    }
+    else {
+      # unbalanced - shove in select/as, not subject to deduplication in _resolved_attrs
+      $attrs->{select} = $self->_merge_attr($attrs->{select}, $sel);
+      $attrs->{as} = $self->_merge_attr($attrs->{as}, $as);
+    }
+  }
+
+  # simplify
+  delete $attrs->{$_} for grep { $attrs->{$_} and ! @{$attrs->{$_}} } qw/select as columns/;
+}
+
 sub _stack_cond {
   my ($self, $left, $right) = @_;
   if (defined $left xor defined $right) {
@@ -1286,6 +1418,7 @@ sub _count_rs {
   # overwrite the selector (supplied by the storage)
   $tmp_attrs->{select} = $rsrc->storage->_count_select ($rsrc, $attrs);
   $tmp_attrs->{as} = 'count';
+  delete @{$tmp_attrs}{qw/columns _trailing_select/};
 
   my $tmp_rs = $rsrc->resultset_class->new($rsrc, $tmp_attrs)->get_column ('count');
 
@@ -1303,7 +1436,7 @@ sub _count_subq_rs {
 
   my $sub_attrs = { %$attrs };
   # extra selectors do not go in the subquery and there is no point of ordering it, nor locking it
-  delete @{$sub_attrs}{qw/collapse select _prefetch_select as order_by for/};
+  delete @{$sub_attrs}{qw/collapse columns as select _prefetch_select _trailing_select order_by for/};
 
   # if we multi-prefetch we group_by primary keys only as this is what we would
   # get out of the rs via ->next/->all. We *DO WANT* to clobber old group_by regardless
@@ -3081,134 +3214,46 @@ sub _resolved_attrs {
   my $source = $self->result_source;
   my $alias  = $attrs->{alias};
 
-########
-# resolve selectors, this one is quite hairy
-
-  my $selection_pieces;
-
-  $attrs->{columns} ||= delete $attrs->{cols}
-    if exists $attrs->{cols};
-
-  # disassemble columns / +columns
-  (
-    $selection_pieces->{columns}{select},
-    $selection_pieces->{columns}{as},
-    $selection_pieces->{'+columns'}{select},
-    $selection_pieces->{'+columns'}{as},
-  ) = map
-    {
-      my (@sel, @as);
-
-      for my $colbit (@$_) {
-
-        if (ref $colbit eq 'HASH') {
-          for my $as (keys %$colbit) {
-            push @sel, $colbit->{$as};
-            push @as, $as;
-          }
-        }
-        elsif ($colbit) {
-          push @sel, $colbit;
-          push @as, $colbit;
-        }
+  # take care of any selector merging
+  $self->_normalize_selection ($attrs);
+
+  # disassemble columns
+  my (@sel, @as);
+  for my $c (@{
+    ref $attrs->{columns} eq 'ARRAY' ? $attrs->{columns} : [ $attrs->{columns} || () ]
+  }) {
+    if (ref $c eq 'HASH') {
+      for my $as (keys %$c) {
+        push @sel, $c->{$as};
+        push @as, $as;
       }
-
-      (\@sel, \@as)
-    }
-    (
-      (ref $attrs->{columns} eq 'ARRAY' ? delete $attrs->{columns} : [ delete $attrs->{columns} ]),
-      # include_columns is a legacy add-on to +columns
-      [ map { ref $_ eq 'ARRAY' ? @$_ : ($_ || () ) } delete @{$attrs}{qw/+columns include_columns/} ] )
-  ;
-
-  # make copies of select/as and +select/+as
-  (
-    $selection_pieces->{'select/as'}{select},
-    $selection_pieces->{'select/as'}{as},
-    $selection_pieces->{'+select/+as'}{select},
-    $selection_pieces->{'+select/+as'}{as},
-  ) = map
-    { $_ ? [ ref $_ eq 'ARRAY' ? @$_ : $_ ] : [] }
-    ( delete @{$attrs}{qw/select as +select +as/} )
-  ;
-
-  # default to * only when neither no non-plus selectors are available
-  if (
-    ! @{$selection_pieces->{'select/as'}{select}}
-      and
-    ! @{$selection_pieces->{'columns'}{select}}
-  ) {
-    for ($source->columns) {
-      push @{$selection_pieces->{'select/as'}{select}}, $_;
-      push @{$selection_pieces->{'select/as'}{as}}, $_;
+    }
+    else {
+      push @sel, $c;
+      push @as, $c;
     }
   }
 
-  # final composition order (important)
-  my @sel_pairs = grep {
-    $selection_pieces->{$_}
-      &&
-    (
-      ( $selection_pieces->{$_}{select} && @{$selection_pieces->{$_}{select}} )
-        ||
-      ( $selection_pieces->{$_}{as} && @{$selection_pieces->{$_}{as}} )
-    )
-  } qw|columns select/as +columns +select/+as|;
-
-  # fill in missing as bits for each pair
-  # if it's the last pair we can let things slide ( bare +select is sadly popular)
-  my $out_of_sync;
-
-  for my $i (0 .. $#sel_pairs) {
+  # when trying to weed off duplicates later do not go past this point -
+  # everything added from here on is unbalanced "anyone's guess" stuff
+  my $dedup_stop_idx = $#as;
 
-    my $pairname = $sel_pairs[$i];
-
-    my ($sel, $as) = @{$selection_pieces->{$pairname}}{qw/select as/};
-
-    $self->throw_exception(
-      "Unable to assemble final selection list: $pairname specified in addition to unbalanced $sel_pairs[$i-1]"
-    ) if ($out_of_sync);
+  push @as, @{ ref $attrs->{as} eq 'ARRAY' ? $attrs->{as} : [ $attrs->{as} ] }
+    if $attrs->{as};
+  push @sel, @{ ref $attrs->{select} eq 'ARRAY' ? $attrs->{select} : [ $attrs->{select} ] }
+    if $attrs->{select};
 
-    if (@$sel == @$as) {
-      next;
-    }
-    elsif (@$sel < @$as) {
-      $self->throw_exception(
-        "More 'as' elements than 'select' elements for $pairname, unable to continue"
-      );
-    }
-    else {
-      # try to deduce the 'as' part, will work only if all the selectors are "plain", or contain an explicit -as
-      # if we can not deduce something - stop right there and leave the rest of the selector un-as'ed
-      # if there is an extra selection pair coming after that - it will die due to out_of_sync being set
-      for my $j ($#$as+1 .. $#$sel) {
-        if (my $ref = ref $sel->[$j]) {
-          if ($ref eq 'HASH' and exists $sel->[$j]{-as}) {
-            push @$as, $sel->[$j]{-as};
-          }
-          else {
-            $out_of_sync++;
-            last;
-          }
-        }
-        else {
-          push @$as, $sel->[$j];
-        }
-      }
-    }
-  }
+  push @sel, @{$attrs->{_trailing_select}}
+    if $attrs->{_trailing_select};
 
   # assume all unqualified selectors to apply to the current alias (legacy stuff)
-  # disqualify all $alias.col as-bits (collapser mandated)
-  for (values %$selection_pieces) {
-    $_->{select} = [ map { (ref $_ or $_ =~ /\./) ? $_ : "$alias.$_" } @{$_->{select}} ];
-    $_->{as} = [  map { $_ =~ /^\Q$alias.\E(.+)$/ ? $1 : $_ } @{$_->{as}} ];
+  for (@sel) {
+    $_ = (ref $_ or $_ =~ /\./) ? $_ : "$alias.$_";
   }
 
-  # merge everything
-  for (@sel_pairs) {
-    $attrs->{select} = $self->_merge_attr ($attrs->{select}, $selection_pieces->{$_}{select});
-    $attrs->{as} = $self->_merge_attr ($attrs->{as}, $selection_pieces->{$_}{as});
+  # disqualify all $alias.col as-bits (collapser mandated)
+  for (@as) {
+    $_ = ($_ =~ /^\Q$alias.\E(.+)$/) ? $1 : $_;
   }
 
   # de-duplicate the result (remove *identical* select/as pairs)
@@ -3216,16 +3261,15 @@ sub _resolved_attrs {
   # not using a c-style for as the condition is prone to shrinkage
   my $seen;
   my $i = 0;
-  while ($i <= $#{$attrs->{as}} ) {
-    my ($sel, $as) = map { $attrs->{$_}[$i] } (qw/select as/);
-
-    if ($seen->{"$sel \x00\x00 $as"}++) {
-      splice @$_, $i, 1
-        for @{$attrs}{qw/select as/};
+  while ($i <= $dedup_stop_idx) {
+    if ($seen->{"$sel[$i] \x00\x00 $as[$i]"}++) {
+      splice @sel, $i, 1;
+      splice @as, $i, 1;
+      $dedup_stop_idx--;
     }
-    elsif ($seen->{$as}++) {
+    elsif ($seen->{$as[$i]}++) {
       $self->throw_exception(
-        "inflate_result() alias '$as' specified twice with different SQL-side {select}-ors"
+        "inflate_result() alias '$as[$i]' specified twice with different SQL-side {select}-ors"
       );
     }
     else {
@@ -3233,9 +3277,8 @@ sub _resolved_attrs {
     }
   }
 
-## selector resolution done
-########
-
+  $attrs->{select} = \@sel;
+  $attrs->{as} = \@as;
 
   $attrs->{from} ||= [{
     -source_handle => $source->handle,
@@ -3248,7 +3291,7 @@ sub _resolved_attrs {
     $self->throw_exception ('join/prefetch can not be used with a custom {from}')
       if ref $attrs->{from} ne 'ARRAY';
 
-    my $join = delete $attrs->{join} || {};
+    my $join = (delete $attrs->{join}) || {};
 
     if ( defined $attrs->{prefetch} ) {
       $join = $self->_merge_joinpref_attr( $join, $attrs->{prefetch} );
@@ -3295,8 +3338,8 @@ sub _resolved_attrs {
   }
 
   $attrs->{collapse} ||= {};
-  if ( my $prefetch = delete $attrs->{prefetch} ) {
-    $prefetch = $self->_merge_joinpref_attr( {}, $prefetch );
+  if ($attrs->{prefetch}) {
+    my $prefetch = $self->_merge_joinpref_attr( {}, delete $attrs->{prefetch} );
 
     my $prefetch_ordering = [];
 
@@ -3473,13 +3516,13 @@ sub _merge_joinpref_attr {
             my ($defl, $defr) = map { defined $_ } (@_[0,1]);
 
             if ($defl xor $defr) {
-              return $defl ? $_[0] : $_[1];
+              return [ $defl ? $_[0] : $_[1] ];
             }
             elsif (! $defl) {
-              return ();
+              return [];
             }
             elsif (__HM_DEDUP and $_[0] eq $_[1]) {
-              return $_[0];
+              return [ $_[0] ];
             }
             else {
               return [$_[0], $_[1]];
@@ -3491,8 +3534,8 @@ sub _merge_joinpref_attr {
             return [$_[0], @{$_[1]}]
           },
           HASH  => sub {
-            return $_[1] if !defined $_[0];
-            return $_[0] if !keys %{$_[1]};
+            return [ $_[1] ] if !defined $_[0];
+            return [ $_[0] ] if !keys %{$_[1]};
             return [$_[0], $_[1]]
           },
         },
@@ -3518,20 +3561,20 @@ sub _merge_joinpref_attr {
         },
         HASH => {
           SCALAR => sub {
-            return $_[0] if !defined $_[1];
-            return $_[1] if !keys %{$_[0]};
+            return [ $_[0] ] if !defined $_[1];
+            return [ $_[1] ] if !keys %{$_[0]};
             return [$_[0], $_[1]]
           },
           ARRAY => sub {
-            return $_[0] if !@{$_[1]};
+            return [ $_[0] ] if !@{$_[1]};
             return $_[1] if !keys %{$_[0]};
             return $_[1] if __HM_DEDUP and List::Util::first { $_ eq $_[0] } @{$_[1]};
             return [ $_[0], @{$_[1]} ];
           },
           HASH => sub {
-            return $_[0] if !keys %{$_[1]};
-            return $_[1] if !keys %{$_[0]};
-            return $_[0] if $_[0] eq $_[1];
+            return [ $_[0] ] if !keys %{$_[1]};
+            return [ $_[1] ] if !keys %{$_[0]};
+            return [ $_[0] ] if $_[0] eq $_[1];
             return [ $_[0], $_[1] ];
           },
         }
index b2c2827..a5e4098 100644 (file)
@@ -133,7 +133,7 @@ my $schema = DBICTest->init_schema();
     $crs->as_query,
     '(SELECT COUNT( * )
       FROM (
-        SELECT me.artistid, MAX( cds.year ) AS newest_cd_year 
+        SELECT MAX( cds.year ) AS newest_cd_year, me.artistid
           FROM artist me 
           LEFT JOIN cd cds ON cds.artist = me.artistid 
         GROUP BY me.artistid 
index d0b8e6c..2f43e03 100644 (file)
@@ -160,11 +160,11 @@ for ($cd_rs->all) {
   is_same_sql_bind (
     $most_tracks_rs->as_query,
     '(
-      SELECT  me.cdid, me.track_count, me.maxtr,
+      SELECT  me.maxtr, me.cdid, me.track_count,
               tracks.trackid, tracks.cd, tracks.position, tracks.title, tracks.last_updated_on, tracks.last_updated_at,
               liner_notes.liner_id, liner_notes.notes
         FROM (
-          SELECT me.cdid, COUNT( tracks.trackid ) AS track_count, MAX( tracks.trackid ) AS maxtr
+          SELECT MAX( tracks.trackid ) AS maxtr, me.cdid, COUNT( tracks.trackid ) AS track_count,
             FROM cd me
             LEFT JOIN track tracks ON tracks.cd = me.cdid
           WHERE ( me.cdid IS NOT NULL )
index 8873608..6adbca5 100644 (file)
@@ -2,7 +2,6 @@ use strict;
 use warnings;
 
 use Test::More;
-use Test::Exception;
 
 use lib qw(t/lib);
 use DBIC::SqlMakerTest;
@@ -23,7 +22,7 @@ my @chain = (
     '+columns'  => [ { max_year => { max => 'me.year', -as => 'last_y' }}, ],
     '+select'   => [ { count => 'me.cdid' }, ],
     '+as'       => [ 'cnt' ],
-  } => 'SELECT me.cdid, LOWER( title ) AS lctitle, MAX( me.year ) AS last_y, me.genreid, COUNT( me.cdid ) FROM cd me',
+  } => 'SELECT me.cdid, LOWER( title ) AS lctitle, me.genreid, MAX( me.year ) AS last_y, COUNT( me.cdid ) FROM cd me',
 
   {
     select      => [ { min => 'me.cdid' }, ],
@@ -99,9 +98,9 @@ is_same_sql_bind (
   $rs->as_query,
   '( SELECT
       me.title,
+      COUNT( artistid ) AS baz,
       me.year AS foo,
-      me.artistid AS bar,
-      COUNT( artistid ) AS baz
+      me.artistid AS bar
         FROM cd me
   )',
   [],
diff --git a/t/search/select_chains_unbalanced.t b/t/search/select_chains_unbalanced.t
new file mode 100644 (file)
index 0000000..d0facb8
--- /dev/null
@@ -0,0 +1,104 @@
+use strict;
+use warnings;
+
+use Test::More;
+
+use lib qw(t/lib);
+use DBIC::SqlMakerTest;
+use DBICTest;
+
+
+my $schema = DBICTest->init_schema();
+
+my $multicol_rs = $schema->resultset('Artist')->search({ artistid => \'1' }, { columns => [qw/name rank/] });
+
+my @chain = (
+  {
+    select      => 'title',
+    as          => 'title',
+    columns     => [ 'cdid' ],
+  } => 'SELECT
+          me.cdid,
+          me.title
+        FROM cd me'
+    => [qw/cdid title/],
+
+  {
+    '+select'   => \ 'DISTINCT(foo, bar)',
+    '+as'       => [qw/foo bar/],
+  } => 'SELECT
+          me.cdid,
+          me.title,
+          DISTINCT(foo, bar)
+        FROM cd me'
+    => [qw/cdid title foo bar/],
+
+  {
+    '+select'   => [ 'genreid', $multicol_rs->as_query ],
+    '+as'       => [qw/genreid name rank/],
+  } => 'SELECT
+          me.cdid,
+          me.title,
+          DISTINCT(foo, bar),
+          me.genreid,
+          (SELECT me.name, me.rank FROM artist me WHERE ( artistid 1 ))
+        FROM cd me'
+    => [qw/cdid title foo bar genreid name rank/],
+
+  {
+    '+select'   => { count => 'me.cdid', -as => 'cnt' },  # lack of 'as' infers from '-as'
+    '+columns'  => { len => { length => 'me.title' } },
+  } => 'SELECT
+          me.cdid,
+          me.title,
+          LENGTH( me.title ),
+          COUNT( me.cdid ) AS cnt,
+          DISTINCT(foo, bar),
+          me.genreid,
+          (SELECT me.name, me.rank FROM artist me WHERE ( artistid 1 ))
+        FROM cd me'
+    => [qw/cdid title len cnt foo bar genreid name rank/],
+
+  {
+    '+select'   => \'unaliased randomness',
+  } => 'SELECT
+          me.cdid,
+          me.title,
+          LENGTH( me.title ),
+          COUNT( me.cdid ) AS cnt,
+          DISTINCT(foo, bar),
+          me.genreid,
+          (SELECT me.name, me.rank FROM artist me WHERE ( artistid 1 )),
+          unaliased randomness
+        FROM cd me'
+    => [qw/cdid title len cnt foo bar genreid name rank/],
+
+);
+
+my $rs = $schema->resultset('CD');
+
+my $testno = 1;
+while (@chain) {
+  my $attrs = shift @chain;
+  my $sql = shift @chain;
+  my $as = shift @chain;
+
+  $rs = $rs->search ({}, $attrs);
+
+  is_same_sql_bind (
+    $rs->as_query,
+    "($sql)",
+    [],
+    "Test $testno of SELECT assembly ok",
+  );
+
+  is_deeply(
+    $rs->_resolved_attrs->{as},
+    $as,
+    'Correct dbic-side aliasing',
+  );
+
+  $testno++;
+}
+
+done_testing;