Fix ORDER BY clause type in synopsis and where() header

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

diff --git a/lib/SQL/Abstract.pm b/lib/SQL/Abstract.pm
index fa64bd1..a662631 100644 (file)
--- a/lib/SQL/Abstract.pm
+++ b/lib/SQL/Abstract.pm
@@ -219,7 +219,7 @@ sub insert {
   $sql = join " ", $self->_sqlcase('insert into'), $table, $sql;
 
   if ($options->{returning}) {
-    my ($s, @b) = $self->_returning ($options);
+    my ($s, @b) = $self->_insert_returning ($options);
     $sql .= $s;
     push @bind, @b;
   }
@@ -419,7 +419,7 @@ sub update {
   }
 
   if ($options->{returning}) {
-    my ($returning_sql, @returning_bind) = $self->_returning ($options);
+    my ($returning_sql, @returning_bind) = $self->_update_returning ($options);
     $sql .= $returning_sql;
     push @all_bind, @returning_bind;
   }
@@ -427,6 +427,7 @@ sub update {
   return wantarray ? ($sql, @all_bind) : $sql;
 }
 
+sub _update_returning { shift->_returning(@_) }
 
 
 
@@ -487,7 +488,9 @@ sub where {
 
   # order by?
   if ($order) {
-    $sql .= $self->_order_by($order);
+    my ($order_sql, @order_bind) = $self->_order_by($order);
+    $sql .= $order_sql;
+    push @bind, @order_bind;
   }
 
   return wantarray ? ($sql, @bind) : $sql;
@@ -1672,7 +1675,7 @@ SQL::Abstract - Generate SQL from Perl data structures
 
     my $sql = SQL::Abstract->new;
 
-    my($stmt, @bind) = $sql->select($source, \@fields, \%where, \@order);
+    my($stmt, @bind) = $sql->select($source, \@fields, \%where, $order);
 
     my($stmt, @bind) = $sql->insert($table, \%fieldvals || \@values);
 
@@ -1685,7 +1688,7 @@ SQL::Abstract - Generate SQL from Perl data structures
     $sth->execute(@bind);
 
     # Just generate the WHERE clause
-    my($stmt, @bind) = $sql->where(\%where, \@order);
+    my($stmt, @bind) = $sql->where(\%where, $order);
 
     # Return values in the same order, for hashed queries
     # See PERFORMANCE section for more details
@@ -2150,7 +2153,7 @@ for details.
 This takes a table name and optional hashref L<WHERE clause|/WHERE CLAUSES>.
 It returns an SQL DELETE statement and list of bind values.
 
-=head2 where(\%where, \@order)
+=head2 where(\%where, $order)
 
 This is used to generate just the WHERE clause. For example,
 if you have an arbitrary data structure and know what the
@@ -2646,10 +2649,16 @@ This difference in syntax is unfortunate but must be preserved for
 historical reasons. So be careful : the two examples below would
 seem algebraically equivalent, but they are not
 
-  {col => [-and => {-like => 'foo%'}, {-like => '%bar'}]}
+  { col => [ -and =>
+    { -like => 'foo%' },
+    { -like => '%bar' },
+  ] }
   # yields : WHERE ( ( col LIKE ? AND col LIKE ? ) )
 
-  [-and => {col => {-like => 'foo%'}, {col => {-like => '%bar'}}]]
+  [ -and =>
+    { col => { -like => 'foo%' } },
+    { col => { -like => '%bar' } },
+  ]
   # yields : WHERE ( ( col LIKE ? OR col LIKE ? ) )
 
 
@@ -2751,7 +2760,7 @@ This would create:
     @bind = ('10');
 
 Note that you must pass the bind values in the same format as they are returned
-by L<where|/where(\%where, \@order)>. This means that if you set L</bindtype>
+by L<where|/where(\%where, $order)>. This means that if you set L</bindtype>
 to C<columns>, you must provide the bind values in the
 C<< [ column_meta => value ] >> format, where C<column_meta> is an opaque
 scalar value; most commonly the column name, but you can use any scalar value