Promote AS to a binop of sorts

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

diff --git a/lib/SQL/Abstract/Tree.pm b/lib/SQL/Abstract/Tree.pm
index 17454dc..d490a83 100644 (file)
--- a/lib/SQL/Abstract/Tree.pm
+++ b/lib/SQL/Abstract/Tree.pm
@@ -50,10 +50,10 @@ my $placeholder_re = qr/(?: \? | \$\d+ )/x;
 my @expression_start_keywords = (
   'SELECT',
   'UPDATE',
+  'SET',
   'INSERT \s+ INTO',
   'DELETE \s+ FROM',
   'FROM',
-  'SET',
   '(?:
     (?:
         (?: (?: LEFT | RIGHT | FULL ) \s+ )?
@@ -64,7 +64,7 @@ my @expression_start_keywords = (
   'ON',
   'WHERE',
   '(?: DEFAULT \s+ )? VALUES',
-  'EXISTS',
+  '(?: NOT \s+)? EXISTS',
   'GROUP \s+ BY',
   'HAVING',
   'ORDER \s+ BY',
@@ -95,6 +95,7 @@ $expr_start_re = qr/ $op_look_behind (?i: $expr_start_re ) $op_look_ahead /x;
 # * BETWEEN without paranthesis around the ANDed arguments (which
 #   makes it a non-binary op) is detected and accomodated in
 #   _recurse_parse()
+# * AS is not really an operator but is handled here as it's also LHS/RHS
 
 # this will be included in the $binary_op_re, the distinction is interesting during
 # testing as one is tighter than the other, plus mathops have different look
@@ -111,7 +112,7 @@ sub _math_op_re { $math_re }
 
 my $binary_op_re = '(?: NOT \s+)? (?:' . join ('|', qw/IN BETWEEN R?LIKE/) . ')';
 $binary_op_re = join "\n\t|\n",
-  "$op_look_behind (?i: $binary_op_re ) $op_look_ahead",
+  "$op_look_behind (?i: $binary_op_re | AS ) $op_look_ahead",
   $math_re,
   $op_look_behind . 'IS (?:\s+ NOT)?' . "(?= \\s+ NULL \\b | $op_look_ahead )",
 ;
@@ -309,6 +310,10 @@ sub parse {
   $self->_recurse_parse($tokens, PARSE_TOP_LEVEL);
 }
 
+{
+# this is temporary, lists can be parsed *without* recursing, but
+# it requires a massive rewrite of the AST generator
+no warnings qw/recursion/;
 sub _recurse_parse {
   my ($self, $tokens, $state) = @_;
 
@@ -344,14 +349,14 @@ sub _recurse_parse {
     elsif ($token =~ /^ (?: OR | AND | \, ) $/xi )  {
       my $op = ($token eq ',') ? 'LIST' : uc $token;
 
-      my $right = $self->_recurse_parse($tokens, PARSE_IN_EXPR);
+      my $right = $self->_recurse_parse($tokens, PARSE_IN_EXPR) || [];
 
       # Merge chunks if logic matches
-      if (ref $right and $op eq $right->[0]) {
-        $left = [ (shift @$right ), [$left||(), map { @$_ } @$right] ];
+      if (ref $right and @$right and $op eq $right->[0]) {
+        $left = [ (shift @$right ), [$left||[], map { @$_ } @$right] ];
       }
       else {
-        $left = [$op => [ $left||(), $right||() ]];
+        $left = [$op => [ $left||[], $right ]];
       }
     }
     # binary operator keywords
@@ -379,8 +384,8 @@ sub _recurse_parse {
     elsif ( $token =~ /^ NOT $/ix ) {
       my $op = uc $token;
       my $right = $self->_recurse_parse ($tokens, PARSE_RHS);
-      $left = $left ? [ @$left, [$op => [$right] ]]
-                    : [ $op => [$right] ];
+      $left = $left ? [ @$left, [$op => [$right||()] ]]
+                    : [ $op => [$right||()] ];
 
     }
     elsif ( $token =~ $placeholder_re) {
@@ -405,6 +410,7 @@ sub _recurse_parse {
     }
   }
 }
+}
 
 sub format_keyword {
   my ($self, $keyword) = @_;
@@ -461,7 +467,6 @@ sub fill_in_placeholder {
 # FIXME - terrible name for a user facing API
 sub unparse {
   my ($self, $tree, $bindargs) = @_;
-  $self->_parenthesis_unroll($tree);
   $self->_unparse($tree, [@{$bindargs||[]}], 0);
 }
 
@@ -472,6 +477,7 @@ sub _unparse {
     return '';
   }
 
+  $self->_parenthesis_unroll($tree);
   my ($car, $cdr) = @{$tree}[0,1];
 
   if (! defined $car or (! ref $car and ! defined $cdr) ) {
@@ -527,6 +533,7 @@ my @unrollable_ops = (
   'GROUP \s+ BY',
   'HAVING',
   'ORDER \s+ BY',
+  'I?LIKE',
 );
 my $unrollable_ops_re = join ' | ', @unrollable_ops;
 $unrollable_ops_re = qr/$unrollable_ops_re/xi;
@@ -573,11 +580,14 @@ sub _parenthesis_unroll {
       }
 
       # only *ONE* LITERAL or placeholder element
+      # as an AND/OR/NOT argument
       elsif (
         @{$child->[1]} == 1 && (
           $child->[1][0][0] eq 'LITERAL'
             or
           $child->[1][0][0] eq 'PLACEHOLDER'
+        ) && (
+          $ast->[0] eq 'AND' or $ast->[0] eq 'OR' or $ast->[0] eq 'NOT'
         )
       ) {
         push @children, $child->[1][0];