From: Peter Rabbitson <ribasushi@cpan.org>
Date: Sat, 30 May 2009 15:15:57 +0000 (+0000)
Subject: Greatly simplify _order_by override to fallback on new SQLA
X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=commitdiff_plain;h=1cbd30341b52723431f4ae937df004ba81428619;p=dbsrgits%2FDBIx-Class-Historic.git

Greatly simplify _order_by override to fallback on new SQLA
---

diff --git a/Makefile.PL b/Makefile.PL
index 8033b36..77d1c6f 100644
--- a/Makefile.PL
+++ b/Makefile.PL
@@ -15,7 +15,7 @@ configure_requires 'DBD::SQLite';
 
 requires 'DBD::SQLite'              => 1.25;
 requires 'Data::Page'               => 2.00;
-requires 'SQL::Abstract'            => 1.55;
+requires 'SQL::Abstract'            => 1.56;
 requires 'SQL::Abstract::Limit'     => 0.13;
 requires 'Class::C3::Componentised' => 1.0005;
 requires 'Carp::Clan'               => 6.0;
diff --git a/lib/DBIx/Class/SQLAHacks.pm b/lib/DBIx/Class/SQLAHacks.pm
index 2aca425..f05970b 100644
--- a/lib/DBIx/Class/SQLAHacks.pm
+++ b/lib/DBIx/Class/SQLAHacks.pm
@@ -103,6 +103,7 @@ sub _Top {
   my $last = $rows + $offset;
 
   my $req_order = $self->_order_by ($order->{order_by});
+
   my $limit_order = $req_order ? $order->{order_by} : $order->{_virtual_order_by};
 
   delete $order->{$_} for qw/order_by _virtual_order_by/;
@@ -138,8 +139,8 @@ sub _find_syntax {
 
 sub select {
   my ($self, $table, $fields, $where, $order, @rest) = @_;
-  local $self->{having_bind} = [];
-  local $self->{from_bind} = [];
+
+  $self->{"${_}_bind"} = [] for (qw/having from order/);
 
   if (ref $table eq 'SCALAR') {
     $table = $$table;
@@ -164,7 +165,7 @@ sub select {
     ) :
     ''
   ;
-  return wantarray ? ($sql, @{$self->{from_bind}}, @where_bind, @{$self->{having_bind}}) : $sql;
+  return wantarray ? ($sql, @{$self->{from_bind}}, @where_bind, @{$self->{having_bind}}, @{$self->{order_bind}} ) : $sql;
 }
 
 sub insert {
@@ -243,96 +244,46 @@ sub _recurse_fields {
 }
 
 sub _order_by {
-  my $self = shift;
-  my $ret = '';
-  my @extra;
-  if (ref $_[0] eq 'HASH') {
+  my ($self, $arg) = @_;
 
-    if (defined $_[0]->{group_by}) {
+  if (ref $arg eq 'HASH' and keys %$arg and not grep { $_ =~ /^-(?:desc|asc)/i } keys %$arg ) {
+
+    my $ret = '';
+
+    if (defined $arg->{group_by}) {
       $ret = $self->_sqlcase(' group by ')
-        .$self->_recurse_fields($_[0]->{group_by}, { no_rownum_hack => 1 });
+        .$self->_recurse_fields($arg->{group_by}, { no_rownum_hack => 1 });
     }
 
-    if (defined $_[0]->{having}) {
-      my $frag;
-      ($frag, @extra) = $self->_recurse_where($_[0]->{having});
-      push(@{$self->{having_bind}}, @extra);
+    if (defined $arg->{having}) {
+      my ($frag, @bind) = $self->_recurse_where($arg->{having});
+      push(@{$self->{having_bind}}, @bind);
       $ret .= $self->_sqlcase(' having ').$frag;
     }
 
-    if (defined $_[0]->{order_by}) {
-      $ret .= $self->_order_by($_[0]->{order_by});
-    }
-
-    if (grep { $_ =~ /^-(desc|asc)/i } keys %{$_[0]}) {
-      return $self->SUPER::_order_by($_[0]);
+    if (defined $arg->{order_by}) {
+      my ($frag, @bind) = $self->SUPER::_order_by($arg->{order_by});
+      push(@{$self->{order_bind}}, @bind);
+      $ret .= $frag;
     }
 
-  } elsif (ref $_[0] eq 'SCALAR') {
-    $ret = $self->_sqlcase(' order by ').${ $_[0] };
-  } elsif (ref $_[0] eq 'ARRAY' && @{$_[0]}) {
-    my @order = map {
-      my $r = $self->_order_by($_, @_);
-      $r =~ s/^ ?ORDER BY //i;
-      $r || ();
-    } @{+shift};
-
-    $ret = $self->_sqlcase(' order by ') . join(', ', @order) if @order;
-
-  } else {
-    $ret = $self->SUPER::_order_by(@_);
-  }
-  return $ret;
-}
-
-sub _order_directions {
-  my ($self, $order) = @_;
-  return $self->SUPER::_order_directions( $self->_resolve_order($order) );
-}
-
-sub _resolve_order {
-  my ($self, $order) = @_;
-
-  if (ref $order eq 'HASH') {
-    $order = [$self->_resolve_order_hash($order)];
+    return $ret;
   }
-  elsif (ref $order eq 'ARRAY') {
-    $order = [map {
-      if (ref ($_) eq 'SCALAR') {
-        $$_
-      }
-      elsif (ref ($_) eq 'HASH') {
-        $self->_resolve_order_hash($_)
-      }
-      else {
-        $_
-      }
-    }  @$order];
+  else {
+    my ($sql, @bind) = $self->SUPER::_order_by ($arg);
+    push(@{$self->{order_bind}}, @bind);
+    return $sql;
   }
-
-  return $order;
 }
 
-sub _resolve_order_hash {
+sub _order_directions {
   my ($self, $order) = @_;
-  my @new_order;
-  foreach my $key (keys %{ $order }) {
-    if ($key =~ /^-(desc|asc)/i ) {
-      my $direction = $1;
-      my $type = ref $order->{ $key };
-      if ($type eq 'ARRAY') {
-        push @new_order, map( "$_ $direction", @{ $order->{ $key } } );
-      } elsif (!$type) {
-        push @new_order, "$order->{$key} $direction";
-      } else {
-        croak "hash order_by can only contain Scalar or Array, not $type";
-      }
-    } else {
-      croak "$key is not a valid direction, use -asc or -desc";
-    }
-  }
 
-  return @new_order;
+  # strip bind values - none of the current _order_directions users support them
+  return $self->SUPER::_order_directions( [ map
+    { ref $_ ? $_->[0] : $_ }
+    $self->_order_by_chunks ($order)
+  ]);
 }
 
 sub _table {