X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FSQL%2FAbstract.pm;h=9741efb0876ab55689066794e8232fd23ea00cda;hb=d7c862e016d9b7ff1179d00d260f84a0a8ce6ef5;hp=a662631b0461a353c5645bd845270c2b3c394e17;hpb=85783f3cb864fd3a3a13d2054e1c6608e21f0675;p=dbsrgits%2FSQL-Abstract.git

diff --git a/lib/SQL/Abstract.pm b/lib/SQL/Abstract.pm
index a662631..9741efb 100644
--- a/lib/SQL/Abstract.pm
+++ b/lib/SQL/Abstract.pm
@@ -264,13 +264,14 @@ sub _insert_ARRAYREF { # just generate values(?,?) part (no list of fields)
   $self->{bindtype} ne 'columns'
     or belch "can't do 'columns' bindtype when called with arrayref";
 
-  # fold the list of values into a hash of column name - value pairs
-  # (where the column names are artificially generated, and their
-  # lexicographical ordering keep the ordering of the original list)
-  my $i = "a";  # incremented values will be in lexicographical order
-  my $data_in_hash = { map { ($i++ => $_) } @$data };
-
-  return $self->_insert_values($data_in_hash);
+  my (@values, @all_bind);
+  foreach my $value (@$data) {
+    my ($values, @bind) = $self->_insert_value(undef, $value);
+    push @values, $values;
+    push @all_bind, @bind;
+  }
+  my $sql = $self->_sqlcase('values')." ( ".join(", ", @values)." )";
+  return ($sql, @all_bind);
 }
 
 sub _insert_ARRAYREFREF { # literal SQL with bind
@@ -294,52 +295,60 @@ sub _insert_values {
 
   my (@values, @all_bind);
   foreach my $column (sort keys %$data) {
-    my $v = $data->{$column};
+    my ($values, @bind) = $self->_insert_value($column, $data->{$column});
+    push @values, $values;
+    push @all_bind, @bind;
+  }
+  my $sql = $self->_sqlcase('values')." ( ".join(", ", @values)." )";
+  return ($sql, @all_bind);
+}
 
-    $self->_SWITCH_refkind($v, {
+sub _insert_value {
+  my ($self, $column, $v) = @_;
 
-      ARRAYREF => sub {
-        if ($self->{array_datatypes}) { # if array datatype are activated
-          push @values, '?';
-          push @all_bind, $self->_bindtype($column, $v);
-        }
-        else {                          # else literal SQL with bind
-          my ($sql, @bind) = @$v;
-          $self->_assert_bindval_matches_bindtype(@bind);
-          push @values, $sql;
-          push @all_bind, @bind;
-        }
-      },
+  my (@values, @all_bind);
+  $self->_SWITCH_refkind($v, {
 
-      ARRAYREFREF => sub { # literal SQL with bind
-        my ($sql, @bind) = @${$v};
+    ARRAYREF => sub {
+      if ($self->{array_datatypes}) { # if array datatype are activated
+        push @values, '?';
+        push @all_bind, $self->_bindtype($column, $v);
+      }
+      else {                  # else literal SQL with bind
+        my ($sql, @bind) = @$v;
         $self->_assert_bindval_matches_bindtype(@bind);
         push @values, $sql;
         push @all_bind, @bind;
-      },
+      }
+    },
 
-      # THINK : anything useful to do with a HASHREF ?
-      HASHREF => sub {  # (nothing, but old SQLA passed it through)
-        #TODO in SQLA >= 2.0 it will die instead
-        belch "HASH ref as bind value in insert is not supported";
-        push @values, '?';
-        push @all_bind, $self->_bindtype($column, $v);
-      },
+    ARRAYREFREF => sub {        # literal SQL with bind
+      my ($sql, @bind) = @${$v};
+      $self->_assert_bindval_matches_bindtype(@bind);
+      push @values, $sql;
+      push @all_bind, @bind;
+    },
 
-      SCALARREF => sub {  # literal SQL without bind
-        push @values, $$v;
-      },
+    # THINK : anything useful to do with a HASHREF ?
+    HASHREF => sub {       # (nothing, but old SQLA passed it through)
+      #TODO in SQLA >= 2.0 it will die instead
+      belch "HASH ref as bind value in insert is not supported";
+      push @values, '?';
+      push @all_bind, $self->_bindtype($column, $v);
+    },
 
-      SCALAR_or_UNDEF => sub {
-        push @values, '?';
-        push @all_bind, $self->_bindtype($column, $v);
-      },
+    SCALARREF => sub {          # literal SQL without bind
+      push @values, $$v;
+    },
 
-     });
+    SCALAR_or_UNDEF => sub {
+      push @values, '?';
+      push @all_bind, $self->_bindtype($column, $v);
+    },
 
-  }
+  });
 
-  my $sql = $self->_sqlcase('values')." ( ".join(", ", @values)." )";
+  my $sql = join(", ", @values);
   return ($sql, @all_bind);
 }
 
@@ -1390,34 +1399,27 @@ sub _quote {
   return '' unless defined $_[1];
   return ${$_[1]} if ref($_[1]) eq 'SCALAR';
 
-  unless ($_[0]->{quote_char}) {
-    $_[0]->_assert_pass_injection_guard($_[1]);
-    return $_[1];
-  }
+  $_[0]->{quote_char} or
+    ($_[0]->_assert_pass_injection_guard($_[1]), return $_[1]);
 
   my $qref = ref $_[0]->{quote_char};
-  my ($l, $r);
-  if (!$qref) {
-    ($l, $r) = ( $_[0]->{quote_char}, $_[0]->{quote_char} );
-  }
-  elsif ($qref eq 'ARRAY') {
-    ($l, $r) = @{$_[0]->{quote_char}};
-  }
-  else {
-    puke "Unsupported quote_char format: $_[0]->{quote_char}";
-  }
+  my ($l, $r) =
+      !$qref             ? ($_[0]->{quote_char}, $_[0]->{quote_char})
+    : ($qref eq 'ARRAY') ? @{$_[0]->{quote_char}}
+    : puke "Unsupported quote_char format: $_[0]->{quote_char}";
+
   my $esc = $_[0]->{escape_char} || $r;
 
   # parts containing * are naturally unquoted
   return join( $_[0]->{name_sep}||'', map
-    { $_ eq '*' ? $_ : do { (my $n = $_) =~ s/(\Q$esc\E|\Q$r\E)/$esc$1/g; $l . $n . $r } }
+    +( $_ eq '*' ? $_ : do { (my $n = $_) =~ s/(\Q$esc\E|\Q$r\E)/$esc$1/g; $l . $n . $r } ),
     ( $_[0]->{name_sep} ? split (/\Q$_[0]->{name_sep}\E/, $_[1] ) : $_[1] )
   );
 }
 
 
 # Conversion, if applicable
-sub _convert ($) {
+sub _convert {
   #my ($self, $arg) = @_;
   if ($_[0]->{convert}) {
     return $_[0]->_sqlcase($_[0]->{convert}) .'(' . $_[1] . ')';
@@ -1426,7 +1428,7 @@ sub _convert ($) {
 }
 
 # And bindtype
-sub _bindtype (@) {
+sub _bindtype {
   #my ($self, $col, @vals) = @_;
   # called often - tighten code
   return $_[0]->{bindtype} eq 'columns'