dbic uses _order_by_chunks, unsure how to unit test

[dbsrgits/SQL-Abstract.git] / lib / SQL / Abstract.pm

diff --git a/lib/SQL/Abstract.pm b/lib/SQL/Abstract.pm
index 25885f0..f8518de 100644 (file)
--- a/lib/SQL/Abstract.pm
+++ b/lib/SQL/Abstract.pm
@@ -155,7 +155,8 @@ sub new {
   $opt{sqlfalse} ||= '0=1';
 
   # special operators
-  $opt{user_special_ops} = [ @{$opt{special_ops} ||= []} ];
+  $opt{special_ops} ||= [];
+
   # regexes are applied in order, thus push after user-defines
   push @{$opt{special_ops}}, @BUILTIN_SPECIAL_OPS;
 
@@ -381,6 +382,7 @@ sub _expand_update_set_values {
   $self->_expand_maybe_list_expr( [
     map {
       my ($k, $set) = @$_;
+      $set = { -bind => $_ } unless defined $set;
       +{ -op => [ '=', { -ident => $k }, $set ] };
     }
     map {
@@ -431,6 +433,7 @@ sub select {
 
 sub _select_fields {
   my ($self, $fields) = @_;
+  return $fields unless ref($fields);
   return $self->_render_expr(
     $self->_expand_maybe_list_expr($fields, undef, '-ident')
   );
@@ -599,6 +602,9 @@ sub _expand_expr_hashpair {
       # top level special ops are illegal in general
       puke "Illegal use of top-level '-$op'"
         if List::Util::first { $op =~ $_->{regex} } @{$self->{special_ops}};
+      if (my $us = List::Util::first { $op =~ $_->{regex} } @{$self->{unary_ops}}) {
+        return { -op => [ $op, $v ] };
+      }
     }
     if ($k eq '-value' and my $m = our $Cur_Col_Meta) {
       return +{ -bind => [ $m, $v ] };
@@ -741,9 +747,16 @@ sub _expand_expr_hashpair {
         ] };
       }
     }
-    if (my $us = List::Util::first { $vk =~ $_->{regex} } @{$self->{user_special_ops}}) {
+    if (my $us = List::Util::first { $vk =~ $_->{regex} } @{$self->{special_ops}}) {
       return { -op => [ $vk, { -ident => $k }, $vv ] };
     }
+    if (my $us = List::Util::first { $vk =~ $_->{regex} } @{$self->{unary_ops}}) {
+      return { -op => [
+        $self->{cmp},
+        { -ident => $k },
+        { -op => [ $vk, $vv ] }
+      ] };
+    }
     if (ref($vv) eq 'ARRAY') {
       my ($logic, @values) = (
         (defined($vv->[0]) and $vv->[0] =~ /^-(and|or)$/i)
@@ -942,11 +955,14 @@ sub _render_op {
   if (my $h = $special{$op}) {
     return $self->$h(\@args);
   }
-  if (my $us = List::Util::first { $op =~ $_->{regex} } @{$self->{user_special_ops}}) {
+  if (my $us = List::Util::first { $op =~ $_->{regex} } @{$self->{special_ops}}) {
     puke "Special op '${op}' requires first value to be identifier"
       unless my ($k) = map $_->{-ident}, grep ref($_) eq 'HASH', $args[0];
     return $self->${\($us->{handler})}($k, $op, $args[1]);
   }
+  if (my $us = List::Util::first { $op =~ $_->{regex} } @{$self->{unary_ops}}) {
+    return $self->${\($us->{handler})}($op, $args[0]);
+  }
   my $final_op = $op =~ /^(?:is|not)_/ ? join(' ', split '_', $op) : $op;
   if (@args == 1 and $op !~ /^(and|or)$/) {
     my ($expr_sql, @bind) = $self->_render_expr($args[0]);
@@ -1029,16 +1045,25 @@ sub _open_outer_paren {
 # ORDER BY
 #======================================================================
 
-sub _order_by {
+sub _expand_order_by {
   my ($self, $arg) = @_;
 
-  return '' unless defined($arg) and not (ref($arg) eq 'ARRAY' and !@$arg);
+  return unless defined($arg) and not (ref($arg) eq 'ARRAY' and !@$arg);
 
   my $expander = sub {
     my ($self, $dir, $expr) = @_;
+    my @to_expand = ref($expr) eq 'ARRAY' ? @$expr : $expr;
+    foreach my $arg (@to_expand) {
+      if (
+        ref($arg) eq 'HASH'
+        and keys %$arg > 1
+        and grep /^-(asc|desc)$/, keys %$arg
+      ) {
+        puke "ordering direction hash passed to order by must have exactly one key (-asc or -desc)";
+      }
+    }
     my @exp = map +(defined($dir) ? { -op => [ $dir => $_ ] } : $_),
-                map $self->_expand_expr($_, undef, -ident),
-                  ref($expr) eq 'ARRAY' ? @$expr : $expr;
+                map $self->_expand_expr($_, undef, -ident), @to_expand;
     return (@exp > 1 ? { -op => [ ',', @exp ] } : $exp[0]);
   };
 
@@ -1047,7 +1072,13 @@ sub _order_by {
     sub { shift->$expander(desc => @_) },
   );
 
-  my $expanded = $self->$expander(undef, $arg);
+  return $self->$expander(undef, $arg);
+}
+
+sub _order_by {
+  my ($self, $arg) = @_;
+
+  return '' unless defined(my $expanded = $self->_expand_order_by($arg));
 
   my ($sql, @bind) = $self->_render_expr($expanded);
 
@@ -1056,6 +1087,21 @@ sub _order_by {
   return wantarray ? ($final_sql, @bind) : $final_sql;
 }
 
+sub _order_by_chunks {
+  my ($self, $arg) = @_;
+
+  return () unless defined(my $expanded = $self->_expand_order_by($arg));
+
+  for ($expanded) {
+    if (ref() eq 'HASH' and my $op = $_->{-op}) {
+      if ($op->[0] eq ',') {
+        return map [ $self->_render_expr($_) ], @{$op}[1..$#$op];
+      }
+    }
+    return [ $self->_render_expr($_) ];
+  }
+}
+
 #======================================================================
 # DATASOURCE (FOR NOW, JUST PLAIN TABLE OR LIST OF TABLES)
 #======================================================================