From: Dagfinn Ilmari Mannsåker <ilmari@ilmari.org>
Date: Fri, 4 Mar 2016 14:59:17 +0000 (+0000)
Subject: Fix ->insert($table, \@values) with >26 values (RT#112684)
X-Git-Tag: v1.81_01~4
X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?p=dbsrgits%2FSQL-Abstract.git;a=commitdiff_plain;h=19b6ccce01924e9ff476b4723bbbd2051c69412f

Fix ->insert($table, \@values) with >26 values (RT#112684)

This gets rid of the cute hash key ordering hack and instead factors the
body of the loop in ->_insert_values into a separate method that the
arrayref version calls directly in the right order.
---

diff --git a/Changes b/Changes
index 91352c4..0d8df7b 100644
--- a/Changes
+++ b/Changes
@@ -1,6 +1,7 @@
 Revision history for SQL::Abstract
 
     - Fix order clauses with bind parameters in ->where
+    - Fix ->insert($table, \@values) with >26 values (RT#112684)
     - Teach ::Tree that ILIKE (PostgreSQL) and REGEXP (MySQL) are binary ops
     - Support for UPDATE ... RETURNING
 
diff --git a/lib/SQL/Abstract.pm b/lib/SQL/Abstract.pm
index 8474073..4017d64 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);
 }
 
diff --git a/t/01generate.t b/t/01generate.t
index 948317f..020dfa5 100644
--- a/t/01generate.t
+++ b/t/01generate.t
@@ -128,10 +128,10 @@ my @tests = (
       },
       {
               func   => 'insert',
-              args   => ['test', [qw/1 2 3 4 5/]],
-              stmt   => 'INSERT INTO test VALUES (?, ?, ?, ?, ?)',
-              stmt_q => 'INSERT INTO `test` VALUES (?, ?, ?, ?, ?)',
-              bind   => [qw/1 2 3 4 5/],
+              args   => ['test', [1..30]],
+              stmt   => 'INSERT INTO test VALUES ('.join(', ', ('?')x30).')',
+              stmt_q => 'INSERT INTO `test` VALUES ('.join(', ', ('?')x30).')',
+              bind   => [1..30],
       },
       {
               func   => 'insert',