X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FDBIx%2FClass%2FStorage%2FDBIHacks.pm;h=0c4b507ba0d216631f08cf2a3c1a8a0cd29aaf4c;hb=7027fcdb42f20465bd1155f7dbc503d21b342ca8;hp=5b4b56e268f1c92214384b3b05d31c3a448c5ab9;hpb=560978e22520434c67eebb2de72f0e571e47ee40;p=dbsrgits%2FDBIx-Class.git

diff --git a/lib/DBIx/Class/Storage/DBIHacks.pm b/lib/DBIx/Class/Storage/DBIHacks.pm
index 5b4b56e..0c4b507 100644
--- a/lib/DBIx/Class/Storage/DBIHacks.pm
+++ b/lib/DBIx/Class/Storage/DBIHacks.pm
@@ -16,6 +16,7 @@ use mro 'c3';
 use List::Util 'first';
 use Scalar::Util 'blessed';
 use Sub::Name 'subname';
+use Data::Query::ExprHelpers;
 use namespace::clean;
 
 #
@@ -34,8 +35,8 @@ sub _prune_unused_joins {
 
   my $aliastypes = $self->_resolve_aliastypes_from_select_args(@_);
 
-  # don't care
-  delete $aliastypes->{joining};
+  my $orig_joins = delete $aliastypes->{joining};
+  my $orig_multiplying = $aliastypes->{multiplying};
 
   # a grouped set will not be affected by amount of rows. Thus any
   # {multiplying} joins can go
@@ -56,13 +57,17 @@ sub _prune_unused_joins {
 
   for my $j (@{$from}[1..$#$from]) {
     push @newfrom, $j if (
-      (! $j->[0]{-alias}) # legacy crap
+      (! defined $j->[0]{-alias}) # legacy crap
         ||
       $need_joins{$j->[0]{-alias}}
     );
   }
 
-  return \@newfrom;
+  return ( \@newfrom, {
+    multiplying => { map { $need_joins{$_} ? ($_  => $orig_multiplying->{$_}) : () } keys %$orig_multiplying },
+    %$aliastypes,
+    joining => { map { $_ => $orig_joins->{$_} } keys %need_joins },
+  } );
 }
 
 #
@@ -79,10 +84,10 @@ sub _adjust_select_args_for_complex_prefetch {
 
   # generate inner/outer attribute lists, remove stuff that doesn't apply
   my $outer_attrs = { %$attrs };
-  delete $outer_attrs->{$_} for qw/where bind rows offset group_by _grouped_by_distinct having/;
+  delete @{$outer_attrs}{qw(where bind rows offset group_by _grouped_by_distinct having)};
 
   my $inner_attrs = { %$attrs };
-  delete $inner_attrs->{$_} for qw/from for collapse select as _related_results_construction/;
+  delete @{$inner_attrs}{qw(from for collapse select as _related_results_construction)};
 
   # there is no point of ordering the insides if there is no limit
   delete $inner_attrs->{order_by} if (
@@ -147,7 +152,7 @@ sub _adjust_select_args_for_complex_prefetch {
   # join collapse *will not work* on heavy data types.
   my $connecting_aliastypes = $self->_resolve_aliastypes_from_select_args(
     $from,
-    [],
+    undef,
     $where,
     $inner_attrs
   );
@@ -175,13 +180,10 @@ sub _adjust_select_args_for_complex_prefetch {
     local $self->{_use_join_optimizer} = 1;
 
     # throw away multijoins since we def. do not care about those inside the subquery
-    my $inner_from = $self->_prune_unused_joins ($from, $inner_select, $where, {
+    my ($inner_from, $inner_aliastypes) = $self->_prune_unused_joins ($from, $inner_select, $where, {
       %$inner_attrs, _force_prune_multiplying_joins => 1
     });
 
-    my $inner_aliastypes =
-      $self->_resolve_aliastypes_from_select_args( $inner_from, $inner_select, $where, $inner_attrs );
-
     # uh-oh a multiplier (which is not us) left in, this is a problem
     if (
       $inner_aliastypes->{multiplying}
@@ -193,7 +195,7 @@ sub _adjust_select_args_for_complex_prefetch {
     ) {
 
       # if none of the multipliers came from an order_by (guaranteed to have been combined
-      # with a limit) - easy - just slap a group_by to simulate a collape and be on our way
+      # with a limit) - easy - just slap a group_by to simulate a collapse and be on our way
       if (
         ! $inner_aliastypes->{ordering}
           or
@@ -225,7 +227,7 @@ sub _adjust_select_args_for_complex_prefetch {
         # exactly what we expect
 
         # supplement the main selection with pks if not already there,
-        # as they will have to be a part of the group_by to colapse
+        # as they will have to be a part of the group_by to collapse
         # things properly
         my $cur_sel = { map { $_ => 1 } @$inner_select };
 
@@ -247,21 +249,28 @@ sub _adjust_select_args_for_complex_prefetch {
         my $sql_maker = $self->sql_maker;
         my ($lquote, $rquote, $sep) = map { quotemeta $_ } ($sql_maker->_quote_chars, $sql_maker->name_sep);
         my $own_re = qr/ $lquote \Q$root_alias\E $rquote $sep | \b \Q$root_alias\E $sep /x;
-        my @order_chunks = map { ref $_ eq 'ARRAY' ? $_ : [ $_ ] } $sql_maker->_order_by_chunks($attrs->{order_by});
-        my @new_order = map { \$_ } @order_chunks;
         my $inner_columns_info = $self->_resolve_column_info($inner_from);
 
+        my $order_dq = $sql_maker->converter
+                                 ->_order_by_to_dq($attrs->{order_by});
+
+        my @new_order;
+
         # loop through and replace stuff that is not "ours" with a min/max func
         # everything is a literal at this point, since we are likely properly
         # quoted and stuff
-        for my $i (0 .. $#new_order) {
-          my $chunk = $order_chunks[$i][0];
+        while (is_Order($order_dq)) {
+          my ($chunk, @args) = $sql_maker->_render_dq($order_dq->{by});
+
+          my $is_desc = $order_dq->{reverse};
+
+          push @new_order, \[ $chunk.($is_desc ? ' DESC' : ''), @args ];
+
+          $order_dq = $order_dq->{from};
 
           # skip ourselves
           next if $chunk =~ $own_re;
 
-          ($chunk, my $is_desc) = $sql_maker->_split_order_chunk($chunk);
-
           # maybe our own unqualified column
           my $ord_bit = (
             $lquote and $sep and $chunk =~ /^ $lquote ([^$sep]+) $rquote $/x
@@ -275,14 +284,14 @@ sub _adjust_select_args_for_complex_prefetch {
             $inner_columns_info->{$ord_bit}{-source_alias} eq $root_alias
           );
 
-          $new_order[$i] = \[
+          $new_order[-1] = \[
             sprintf(
               '%s(%s)%s',
               ($is_desc ? 'MAX' : 'MIN'),
               $chunk,
               ($is_desc ? ' DESC' : ''),
             ),
-            @ {$order_chunks[$i]} [ 1 .. $#{$order_chunks[$i]} ]
+            @args
           ];
         }
 
@@ -352,7 +361,7 @@ sub _adjust_select_args_for_complex_prefetch {
 
   # scan the *remaining* from spec against different attributes, and see which joins are needed
   # in what role
-  my $outer_aliastypes =
+  my $outer_aliastypes = $outer_attrs->{_aliastypes} =
     $self->_resolve_aliastypes_from_select_args( $from, $outer_select, $where, $outer_attrs );
 
   # unroll parents
@@ -398,7 +407,7 @@ sub _adjust_select_args_for_complex_prefetch {
   # Unfortunately not much can be done until SQLA2 introspection arrives, and even
   # then if where conditions apply to the *right* side of the prefetch, you may have
   # to both filter the inner select (e.g. to apply a limit) and then have to re-filter
-  # the outer select to exclude joins you didin't want in the first place
+  # the outer select to exclude joins you didn't want in the first place
   #
   # OTOH it can be seen as a plus: <ash> (notes that this query would make a DBA cry ;)
   return (\@outer_from, $outer_select, $where, $outer_attrs);
@@ -409,7 +418,7 @@ sub _adjust_select_args_for_complex_prefetch {
 #
 # Due to a lack of SQLA2 we fall back to crude scans of all the
 # select/where/order/group attributes, in order to determine what
-# aliases are neded to fulfill the query. This information is used
+# aliases are needed to fulfill the query. This information is used
 # throughout the code to prune unnecessary JOINs from the queries
 # in an attempt to reduce the execution time.
 # Although the method is pretty horrific, the worst thing that can
@@ -471,16 +480,29 @@ sub _resolve_aliastypes_from_select_args {
     $sql_maker->{name_sep} = '';
   }
 
+  # local is not enough - need to ensure the inner objects get rebuilt
+  $sql_maker->clear_renderer;
+  $sql_maker->clear_converter;
+
   my ($lquote, $rquote, $sep) = map { quotemeta $_ } ($sql_maker->_quote_chars, $sql_maker->name_sep);
 
   # generate sql chunks
   my $to_scan = {
     restricting => [
-      $sql_maker->_recurse_where ($where),
-      $sql_maker->_parse_rs_attrs ({ having => $attrs->{having} }),
+      ($where
+        ? ($sql_maker->_recurse_where($where))[0]
+        : ()
+      ),
+      ($attrs->{having}
+        ? ($sql_maker->_recurse_where($attrs->{having}))[0]
+        : ()
+      ),
     ],
     grouping => [
-      $sql_maker->_parse_rs_attrs ({ group_by => $attrs->{group_by} }),
+      ($attrs->{group_by}
+        ? ($sql_maker->_render_sqla(group_by => $attrs->{group_by}))[0]
+        : (),
+      )
     ],
     joining => [
       $sql_maker->_recurse_from (
@@ -489,13 +511,19 @@ sub _resolve_aliastypes_from_select_args {
       ),
     ],
     selecting => [
-      $sql_maker->_recurse_fields ($select),
+      ($select
+        ? ($sql_maker->_render_sqla(select_select => $select))[0]
+        : ()),
     ],
     ordering => [
       map { $_->[0] } $self->_extract_order_criteria ($attrs->{order_by}, $sql_maker),
     ],
   };
 
+  # local is not enough - need to ensure the inner objects get rebuilt
+  $sql_maker->clear_renderer;
+  $sql_maker->clear_converter;
+
   # throw away empty chunks
   $_ = [ map { $_ || () } @$_ ] for values %$to_scan;
 
@@ -783,6 +811,18 @@ sub _inner_join_to_node {
 sub _extract_order_criteria {
   my ($self, $order_by, $sql_maker) = @_;
 
+  $sql_maker ||= $self->sql_maker;
+
+  my $order_dq = $sql_maker->converter->_order_by_to_dq($order_by);
+
+  my @by;
+  while (is_Order($order_dq)) {
+    push @by, $order_dq->{by};
+    $order_dq = $order_dq->{from};
+  }
+
+  return map { [ $sql_maker->_render_dq($_) ] } @by;
+
   my $parser = sub {
     my ($sql_maker, $order_by, $orig_quote_chars) = @_;
 
@@ -917,7 +957,7 @@ sub _main_source_order_by_portion_is_stable {
   die 'How did we get here...';
 }
 
-# returns an arrayref of column names which *definitely* have som
+# returns an arrayref of column names which *definitely* have some
 # sort of non-nullable 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,