From: Dagfinn Ilmari Mannsåker 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?a=commitdiff_plain;h=19b6ccce01924e9ff476b4723bbbd2051c69412f;p=dbsrgits%2FSQL-Abstract.git 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',