X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FSQL%2FAbstract.pm;h=84a5dbfdfcc2b568c562120da6afe6d1b7a02ccf;hb=3fa064545850cd7329f774e1373c805365f5c7f1;hp=79c630060d70ef2c2527acf6ed3bcd77ff092c64;hpb=a0fdc34f069ca43e0f7204ad29a51468243f5b9c;p=scpubgit%2FQ-Branch.git

diff --git a/lib/SQL/Abstract.pm b/lib/SQL/Abstract.pm
index 79c6300..84a5dbf 100644
--- a/lib/SQL/Abstract.pm
+++ b/lib/SQL/Abstract.pm
@@ -137,6 +137,72 @@ sub is_plain_value ($) {
 # NEW
 #======================================================================
 
+our %Defaults = (
+  expand => {
+    not => '_expand_not',
+    bool => '_expand_bool',
+    and => '_expand_op_andor',
+    or => '_expand_op_andor',
+    nest => '_expand_nest',
+    bind => '_expand_bind',
+    in => '_expand_in',
+    not_in => '_expand_in',
+    row => '_expand_row',
+    between => '_expand_between',
+    not_between => '_expand_between',
+    op => '_expand_op',
+    (map +($_ => '_expand_op_is'), ('is', 'is_not')),
+    ident => '_expand_ident',
+    value => '_expand_value',
+    func => '_expand_func',
+  },
+  expand_op => {
+    'between' => '_expand_between',
+    'not_between' => '_expand_between',
+    'in' => '_expand_in',
+    'not_in' => '_expand_in',
+    'nest' => '_expand_nest',
+    (map +($_ => '_expand_op_andor'), ('and', 'or')),
+    (map +($_ => '_expand_op_is'), ('is', 'is_not')),
+    'ident' => '_expand_ident',
+    'value' => '_expand_value',
+  },
+  render => {
+    (map +($_, "_render_$_"), qw(op func bind ident literal row)),
+  },
+  render_op => {
+    (map +($_ => '_render_op_between'), 'between', 'not_between'),
+    (map +($_ => '_render_op_in'), 'in', 'not_in'),
+    (map +($_ => '_render_unop_postfix'),
+      'is_null', 'is_not_null', 'asc', 'desc',
+    ),
+    (not => '_render_unop_paren'),
+    (map +($_ => '_render_op_andor'), qw(and or)),
+    ',' => '_render_op_multop',
+  },
+  clauses_of => {
+    delete => [ qw(target where returning) ],
+    update => [ qw(target set where returning) ],
+  },
+  expand_clause => {
+    'delete.from' => '_expand_delete_clause_target',
+    'update.update' => '_expand_update_clause_target',
+  },
+  render_clause => {
+    'delete.target' => '_render_delete_clause_target',
+    'update.target' => '_render_update_clause_target',
+  },
+);
+
+foreach my $stmt (keys %{$Defaults{clauses_of}}) {
+  $Defaults{expand}{$stmt} = '_expand_statement';
+  $Defaults{render}{$stmt} = '_render_statement';
+  foreach my $clause (@{$Defaults{clauses_of}{$stmt}}) {
+    $Defaults{expand_clause}{"${stmt}.${clause}"}
+      = "_expand_${stmt}_clause_${clause}";
+  }
+}
+
 sub new {
   my $self = shift;
   my $class = ref($self) || $self;
@@ -193,52 +259,9 @@ sub new {
 
   $opt{expand_unary} = {};
 
-  $opt{expand} = {
-    not => '_expand_not',
-    bool => '_expand_bool',
-    and => '_expand_op_andor',
-    or => '_expand_op_andor',
-    nest => '_expand_nest',
-    bind => '_expand_bind',
-    in => '_expand_in',
-    not_in => '_expand_in',
-    row => '_expand_row',
-    between => '_expand_between',
-    not_between => '_expand_between',
-    op => '_expand_op',
-    (map +($_ => '_expand_op_is'), ('is', 'is_not')),
-    ident => '_expand_ident',
-    value => '_expand_value',
-    func => '_expand_func',
-  };
-
-  $opt{expand_op} = {
-    'between' => '_expand_between',
-    'not_between' => '_expand_between',
-    'in' => '_expand_in',
-    'not_in' => '_expand_in',
-    'nest' => '_expand_nest',
-    (map +($_ => '_expand_op_andor'), ('and', 'or')),
-    (map +($_ => '_expand_op_is'), ('is', 'is_not')),
-    'ident' => '_expand_ident',
-    'value' => '_expand_value',
-  };
-
-  $opt{render} = {
-    (map +($_, "_render_$_"), qw(op func bind ident literal row)),
-    %{$opt{render}||{}}
-  };
-
-  $opt{render_op} = {
-    (map +($_ => '_render_op_between'), 'between', 'not_between'),
-    (map +($_ => '_render_op_in'), 'in', 'not_in'),
-    (map +($_ => '_render_unop_postfix'),
-      'is_null', 'is_not_null', 'asc', 'desc',
-    ),
-    (not => '_render_unop_paren'),
-    (map +($_ => '_render_op_andor'), qw(and or)),
-    ',' => '_render_op_multop',
-  };
+  foreach my $name (sort keys %Defaults) {
+    $opt{$name} = { %{$Defaults{$name}} };
+  }
 
   if ($opt{lazy_join_sql_parts}) {
     my $mod = Module::Runtime::use_module('SQL::Abstract::Parts');
@@ -365,35 +388,28 @@ sub _expand_insert_value {
 # UPDATE methods
 #======================================================================
 
-
 sub update {
-  my $self    = shift;
-  my $table   = $self->_table(shift);
-  my $data    = shift || return;
-  my $where   = shift;
-  my $options = shift;
-
-  # first build the 'SET' part of the sql statement
-  puke "Unsupported data type specified to \$sql->update"
-    unless ref $data eq 'HASH';
-
-  my ($sql, @all_bind) = $self->_update_set_values($data);
-  $sql = $self->_sqlcase('update ') . $table . $self->_sqlcase(' set ')
-          . $sql;
+  my ($self, $table, $set, $where, $options) = @_;
 
-  if ($where) {
-    my($where_sql, @where_bind) = $self->where($where);
-    $sql .= $where_sql;
-    push @all_bind, @where_bind;
-  }
-
-  if ($options->{returning}) {
-    my ($returning_sql, @returning_bind) = $self->_update_returning($options);
-    $sql .= $returning_sql;
-    push @all_bind, @returning_bind;
-  }
+  my $stmt = do {
+    if (ref($table) eq 'HASH') {
+      $table
+    } else {
+      my %clauses;
+      @clauses{qw(target set where)} = ($table, $set, $where);
+      puke "Unsupported data type specified to \$sql->update"
+        unless ref($clauses{set}) eq 'HASH';
+      @clauses{keys %$options} = values %$options;
+      \%clauses;
+    }
+  };
+  my @rendered = $self->render_statement({ -update => $stmt });
+  return wantarray ? @rendered : $rendered[0];
+}
 
-  return wantarray ? ($sql, @all_bind) : $sql;
+sub _render_update_clause_target {
+  my ($self, undef, $target) = @_;
+  $self->join_query_parts(' ', $self->format_keyword('update'), $target);
 }
 
 sub _update_set_values {
@@ -428,6 +444,24 @@ sub _expand_update_set_values {
   ] );
 }
 
+sub _expand_update_clause_target {
+  my ($self, undef, $target) = @_;
+  +(target => $self->_expand_maybe_list_expr($target, -ident));
+}
+
+sub _expand_update_clause_set {
+  return $_[2] if ref($_[2]) eq 'HASH' and ($_[2]->{-op}||[''])->[0] eq ',';
+  +(set => $_[0]->_expand_update_set_values($_[1], $_[2]));
+}
+
+sub _expand_update_clause_where {
+  +(where => $_[0]->expand_expr($_[2]));
+}
+
+sub _expand_update_clause_returning {
+  +(returning => $_[0]->_expand_maybe_list_expr($_[2], -ident));
+}
+
 # So that subclasses can override UPDATE ... RETURNING separately from
 # INSERT and DELETE
 sub _update_returning { shift->_returning(@_) }
@@ -470,30 +504,39 @@ sub _select_fields {
 # DELETE
 #======================================================================
 
-
 sub delete {
-  my $self    = shift;
-  my $table   = $self->_table(shift);
-  my $where   = shift;
-  my $options = shift;
-
-  my($where_sql, @bind) = $self->where($where);
-  my $sql = $self->_sqlcase('delete from ') . $table . $where_sql;
-
-  if ($options->{returning}) {
-    my ($returning_sql, @returning_bind) = $self->_delete_returning($options);
-    $sql .= $returning_sql;
-    push @bind, @returning_bind;
-  }
+  my ($self, $table, $where, $options) = @_;
 
-  return wantarray ? ($sql, @bind) : $sql;
+  my $stmt = do {
+    if (ref($table) eq 'HASH') {
+      $table;
+    } else {
+      my %clauses = (target => $table, where => $where, %{$options||{}});
+      \%clauses;
+    }
+  };
+  my @rendered = $self->render_statement({ -delete => $stmt });
+  return wantarray ? @rendered : $rendered[0];
 }
 
 # So that subclasses can override DELETE ... RETURNING separately from
 # INSERT and UPDATE
 sub _delete_returning { shift->_returning(@_) }
 
+sub _expand_delete_clause_target {
+  +(target => $_[0]->_expand_maybe_list_expr($_[2], -ident));
+}
 
+sub _expand_delete_clause_where { +(where => $_[0]->expand_expr($_[2])); }
+
+sub _expand_delete_clause_returning {
+  +(returning => $_[0]->_expand_maybe_list_expr($_[2], -ident));
+}
+
+sub _render_delete_clause_target {
+   my ($self, undef, $from) = @_;
+   $self->join_query_parts(' ', $self->format_keyword('delete from'), $from);
+}
 
 #======================================================================
 # WHERE: entry point
@@ -532,11 +575,12 @@ sub expand_expr {
 }
 
 sub render_aqt {
-  my ($self, $aqt) = @_;
+  my ($self, $aqt, $top_level) = @_;
   my ($k, $v, @rest) = %$aqt;
   die "No" if @rest;
   die "Not a node type: $k" unless $k =~ s/^-//;
   if (my $meth = $self->{render}{$k}) {
+    local our $Render_Top_Level = $top_level;
     return $self->$meth($k, $v);
   }
   die "notreached: $k";
@@ -549,6 +593,61 @@ sub render_expr {
   ) };
 }
 
+sub render_statement {
+  my ($self, $expr, $default_scalar_to) = @_;
+  @{$self->render_aqt(
+    $self->expand_expr($expr, $default_scalar_to), 1
+  )};
+}
+
+sub _expand_statement {
+  my ($self, $type, $args) = @_;
+  my $ec = $self->{expand_clause};
+  if ($args->{_}) {
+    $args = { %$args };
+    $args->{$type} = delete $args->{_}
+  }
+  return +{ "-${type}" => +{
+    map {
+      my $val = $args->{$_};
+      if (defined($val) and my $exp = $ec->{"${type}.$_"}) {
+        if ((my (@exp) = $self->$exp($_ => $val)) == 1) {
+          ($_ => $exp[0])
+        } else {
+          @exp
+        }
+      } else {
+        ($_ => $self->expand_expr($val))
+      }
+    } sort keys %$args
+  } };
+}
+
+sub _render_statement {
+  my ($self, $type, $args) = @_;
+  my @parts;
+  foreach my $clause (@{$self->{clauses_of}{$type}}) {
+    next unless my $clause_expr = $args->{$clause};
+    my $part = do {
+      if (my $rdr = $self->{render_clause}{"${type}.${clause}"}) {
+        $self->$rdr($clause, $clause_expr);
+      } else {
+        my $r = $self->render_aqt($clause_expr, 1);
+        next unless defined $r->[0] and length $r->[0];
+        $self->join_query_parts(' ',
+          $self->format_keyword($clause),
+          $r
+        );
+      }
+    };
+    push @parts, $part;
+  }
+  my $q = $self->join_query_parts(' ', @parts);
+  return $self->join_query_parts('',
+    (our $Render_Top_Level ? $q : ('(', $q, ')'))
+  );
+}
+
 sub _normalize_op {
   my ($self, $raw) = @_;
   my $op = lc $raw;
@@ -597,7 +696,7 @@ sub _expand_hashpair {
   if ($k =~ /^-./) {
     return $self->_expand_hashpair_op($k, $v);
   } elsif ($k =~ /^[^\w]/i) {
-    my ($lhs, @rhs) = @$v;
+    my ($lhs, @rhs) = ref($v) eq 'ARRAY' ? @$v : $v;
     return $self->_expand_op(
       -op, [ $k, $self->expand_expr($lhs, -ident), @rhs ]
     );
@@ -686,19 +785,6 @@ sub _expand_hashpair_op {
 
   my $op = $self->_normalize_op($k);
 
-  if (my $exp = $self->{expand}{$op}) {
-    return $self->$exp($op, $v);
-  }
-
-  # Ops prefixed with -not_ get converted
-
-  if (my ($rest) = $op =~/^not_(.*)$/) {
-    return +{ -op => [
-      'not',
-      $self->_expand_expr({ "-${rest}", $v })
-    ] };
-  }
-
   { # Old SQLA compat
 
     my $op = join(' ', split '_', $op);
@@ -717,9 +803,27 @@ sub _expand_hashpair_op {
     ) {
       puke "Illegal use of top-level '-$op'"
     }
+  }
+
+  if (my $exp = $self->{expand}{$op}) {
+    return $self->$exp($op, $v);
+  }
+
+  # Ops prefixed with -not_ get converted
+
+  if (my ($rest) = $op =~/^not_(.*)$/) {
+    return +{ -op => [
+      'not',
+      $self->_expand_expr({ "-${rest}", $v })
+    ] };
+  }
+
+  { # Old SQLA compat
 
     # the old unary op system means we should touch nothing and let it work
 
+    my $op = join(' ', split '_', $op);
+
     if (my $us = List::Util::first { $op =~ $_->{regex} } @{$self->{unary_ops}}) {
       return { -op => [ $op, $v ] };
     }