X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FSQL%2FAbstract.pm;h=3888f657d1dba8161a61b596f19b6b5855c034e4;hb=91778193f84bc4aa93058ac326fcd122011015cd;hp=c0de4d5b6950a2f465f8ef02c4b73a7d0cbe19b4;hpb=f2d5020d799a39cecb1f165a75b15b793a0d3453;p=scpubgit%2FQ-Branch.git diff --git a/lib/SQL/Abstract.pm b/lib/SQL/Abstract.pm index c0de4d5..3888f65 100644 --- a/lib/SQL/Abstract.pm +++ b/lib/SQL/Abstract.pm @@ -15,7 +15,7 @@ use Scalar::Util qw/blessed/; # GLOBALS #====================================================================== -our $VERSION = '1.50'; +our $VERSION = '1.61'; # This would confuse some packagers #$VERSION = eval $VERSION; # numify for warning-free dev releases @@ -25,8 +25,17 @@ our $AUTOLOAD; # special operators (-in, -between). May be extended/overridden by user. # See section WHERE: BUILTIN SPECIAL OPERATORS below for implementation my @BUILTIN_SPECIAL_OPS = ( - {regex => qr/^(not )?between$/i, handler => \&_where_field_BETWEEN}, - {regex => qr/^(not )?in$/i, handler => \&_where_field_IN}, + {regex => qr/^(not )?between$/i, handler => '_where_field_BETWEEN'}, + {regex => qr/^(not )?in$/i, handler => '_where_field_IN'}, +); + +# unaryish operators - key maps to handler +my @BUILTIN_UNARY_OPS = ( + # the digits are backcompat stuff + { regex => qr/^and (?: \s? \d+ )? $/xi, handler => '_where_op_ANDOR' }, + { regex => qr/^or (?: \s? \d+ )? $/xi, handler => '_where_op_ANDOR' }, + { regex => qr/^nest (?: \s? \d+ )? $/xi, handler => '_where_op_NEST' }, + { regex => qr/^ (?: not \s )? bool $/xi, handler => '_where_op_BOOL' }, ); #====================================================================== @@ -63,7 +72,7 @@ sub new { delete $opt{case} if $opt{case} && $opt{case} ne 'lower'; # default logic for interpreting arrayrefs - $opt{logic} = uc $opt{logic} || 'OR'; + $opt{logic} = $opt{logic} ? uc $opt{logic} : 'OR'; # how to return bind vars # LDNOTE: changed nwiger code : why this 'delete' ?? @@ -73,10 +82,18 @@ sub new { # default comparison is "=", but can be overridden $opt{cmp} ||= '='; + # generic SQL comparison operators + my $anchored_cmp_ops = join ('|', map { '^' . $_ . '$' } ( + '(?:is \s+)? (?:not \s+)? like', + 'is', + (map { quotemeta($_) } (qw/ < > != <> = <= >= /) ), + )); + $opt{cmp_ops} = qr/$anchored_cmp_ops/ix; + # try to recognize which are the 'equality' and 'unequality' ops # (temporary quickfix, should go through a more seasoned API) - $opt{equality_op} = qr/^(\Q$opt{cmp}\E|is|(is\s+)?like)$/i; - $opt{inequality_op} = qr/^(!=|<>|(is\s+)?not(\s+like)?)$/i; + $opt{equality_op} = qr/^(\Q$opt{cmp}\E|is|(is\s+)?like)$/i; + $opt{inequality_op} = qr/^(!=|<>|(is\s+)?not(\s+like)?)$/i; # SQL booleans $opt{sqltrue} ||= '1=1'; @@ -86,6 +103,10 @@ sub new { $opt{special_ops} ||= []; push @{$opt{special_ops}}, @BUILTIN_SPECIAL_OPS; + # unary operators + $opt{unary_ops} ||= []; + push @{$opt{unary_ops}}, @BUILTIN_UNARY_OPS; + return bless \%opt, $class; } @@ -96,16 +117,33 @@ sub new { #====================================================================== sub insert { - my $self = shift; - my $table = $self->_table(shift); - my $data = shift || return; + my $self = shift; + my $table = $self->_table(shift); + my $data = shift || return; + my $options = shift; my $method = $self->_METHOD_FOR_refkind("_insert", $data); - my ($sql, @bind) = $self->$method($data); + my ($sql, @bind) = $self->$method($data); $sql = join " ", $self->_sqlcase('insert into'), $table, $sql; + + if (my $ret = $options->{returning}) { + $sql .= $self->_insert_returning ($ret); + } + return wantarray ? ($sql, @bind) : $sql; } +sub _insert_returning { + my ($self, $fields) = @_; + + my $f = $self->_SWITCH_refkind($fields, { + ARRAYREF => sub {join ', ', map { $self->_quote($_) } @$fields;}, + SCALAR => sub {$self->_quote($fields)}, + SCALARREF => sub {$$fields}, + }); + return join (' ', $self->_sqlcase(' returning'), $f); +} + sub _insert_HASHREF { # explicit list of fields and then values my ($self, $data) = @_; @@ -422,16 +460,46 @@ sub _where_HASHREF { my ($self, $where) = @_; my (@sql_clauses, @all_bind); - # LDNOTE : don't really know why we need to sort keys - for my $k (sort keys %$where) { + for my $k (sort keys %$where) { my $v = $where->{$k}; - # ($k => $v) is either a special op or a regular hashpair - my ($sql, @bind) = ($k =~ /^-(.+)/) ? $self->_where_op_in_hash($1, $v) - : do { - my $method = $self->_METHOD_FOR_refkind("_where_hashpair", $v); - $self->$method($k, $v); - }; + # ($k => $v) is either a special unary op or a regular hashpair + my ($sql, @bind) = do { + if ($k =~ /^-./) { + # put the operator in canonical form + my $op = $k; + $op =~ s/^-//; # remove initial dash + $op =~ s/[_\t ]+/ /g; # underscores and whitespace become single spaces + $op =~ s/^\s+|\s+$//g;# remove leading/trailing space + + $self->_debug("Unary OP(-$op) within hashref, recursing..."); + + my $op_entry = first {$op =~ $_->{regex}} @{$self->{unary_ops}}; + if (my $handler = $op_entry->{handler}) { + if (not ref $handler) { + if ($op =~ s/\s?\d+$//) { + belch 'Use of [and|or|nest]_N modifiers is deprecated and will be removed in SQLA v2.0. ' + . "You probably wanted ...-and => [ -$op => COND1, -$op => COND2 ... ]"; + } + $self->$handler ($op, $v); + } + elsif (ref $handler eq 'CODE') { + $handler->($self, $op, $v); + } + else { + puke "Illegal handler for operator $k - expecting a method name or a coderef"; + } + } + else { + $self->debug("Generic unary OP: $k - recursing as function"); + $self->_where_func_generic ($op, $v); + } + } + else { + my $method = $self->_METHOD_FOR_refkind("_where_hashpair", $v); + $self->$method($k, $v); + } + }; push @sql_clauses, $sql; push @all_bind, @bind; @@ -440,45 +508,70 @@ sub _where_HASHREF { return $self->_join_sql_clauses('and', \@sql_clauses, \@all_bind); } +sub _where_func_generic { + my ($self, $op, $rhs) = @_; -sub _where_op_in_hash { - my ($self, $op, $v) = @_; + my ($sql, @bind) = $self->_SWITCH_refkind ($rhs, { + SCALAR => sub { + puke "Illegal use of top-level '$op'" + unless $self->{_nested_func_lhs}; - $op =~ /^(AND|OR|NEST)[_\d]*/i - or puke "unknown operator: -$op"; - $op = uc($1); # uppercase, remove trailing digits - $self->_debug("OP(-$op) within hashref, recursing..."); + return ( + $self->_convert('?'), + $self->_bindtype($self->{_nested_func_lhs}, $rhs) + ); + }, + FALLBACK => sub { + $self->_recurse_where ($rhs) + }, + }); - $self->_SWITCH_refkind($v, { + $sql = sprintf ('%s%s', + $self->_sqlcase($op), + ($op =~ $self->{cmp_ops}) ? " $sql" : "( $sql )", + ); + return ($sql, @bind); +} + +sub _where_op_ANDOR { + my ($self, $op, $v) = @_; + + $self->_SWITCH_refkind($v, { ARRAYREF => sub { - return $self->_where_ARRAYREF($v, $op eq 'NEST' ? '' : $op); + return $self->_where_ARRAYREF($v, $op); }, HASHREF => sub { - if ($op eq 'OR') { - return $self->_where_ARRAYREF([%$v], 'OR'); - } - else { # NEST | AND - return $self->_where_HASHREF($v); - } + return ( $op =~ /^or/i ) + ? $self->_where_ARRAYREF( [ map { $_ => $v->{$_} } ( sort keys %$v ) ], $op ) + : $self->_where_HASHREF($v); + }, + + SCALARREF => sub { + puke "-$op => \\\$scalar not supported, use -nest => ..."; }, - SCALARREF => sub { # literal SQL - $op eq 'NEST' - or puke "-$op => \\\$scalar not supported, use -nest => ..."; - return ($$v); + ARRAYREFREF => sub { + puke "-$op => \\[..] not supported, use -nest => ..."; }, - ARRAYREFREF => sub { # literal SQL - $op eq 'NEST' - or puke "-$op => \\[..] not supported, use -nest => ..."; - return @{${$v}}; + SCALAR => sub { # permissively interpreted as SQL + puke "-$op => 'scalar' not supported, use -nest => \\'scalar'"; + }, + + UNDEF => sub { + puke "-$op => undef not supported"; }, + }); +} + +sub _where_op_NEST { + my ($self, $op, $v) = @_; + + $self->_SWITCH_refkind($v, { SCALAR => sub { # permissively interpreted as SQL - $op eq 'NEST' - or puke "-$op => 'scalar' not supported, use -nest => \\'scalar'"; belch "literal SQL should be -nest => \\'scalar' " . "instead of -nest => 'scalar' "; return ($v); @@ -487,10 +580,45 @@ sub _where_op_in_hash { UNDEF => sub { puke "-$op => undef not supported"; }, + + FALLBACK => sub { + $self->_recurse_where ($v); + }, + }); } +sub _where_op_BOOL { + my ($self, $op, $v) = @_; + + my ( $prefix, $suffix ) = ( $op =~ /\bnot\b/i ) + ? ( '(NOT ', ')' ) + : ( '', '' ); + + my ($sql, @bind) = do { + $self->_SWITCH_refkind($v, { + SCALAR => sub { # interpreted as SQL column + $self->_convert($self->_quote($v)); + }, + + UNDEF => sub { + puke "-$op => undef not supported"; + }, + + FALLBACK => sub { + $self->_recurse_where ($v); + }, + }); + }; + + return ( + join ('', $prefix, $sql, $suffix), + @bind, + ); +} + + sub _where_hashpair_ARRAYREF { my ($self, $k, $v) = @_; @@ -499,11 +627,18 @@ sub _where_hashpair_ARRAYREF { $self->_debug("ARRAY($k) means distribute over elements"); # put apart first element if it is an operator (-and, -or) - my $op = $v[0] =~ /^-/ ? shift @v : undef; - $self->_debug("OP($op) reinjected into the distributed array") if $op; - + my $op = ( + (defined $v[0] && $v[0] =~ /^ - (?: AND|OR ) $/ix) + ? shift @v + : '' + ); my @distributed = map { {$k => $_} } @v; - unshift @distributed, $op if $op; + + if ($op) { + $self->_debug("OP($op) reinjected into the distributed array"); + unshift @distributed, $op; + } + my $logic = $op ? substr($op, 1) : ''; return $self->_recurse_where(\@distributed, $logic); @@ -516,26 +651,44 @@ sub _where_hashpair_ARRAYREF { } sub _where_hashpair_HASHREF { - my ($self, $k, $v) = @_; + my ($self, $k, $v, $logic) = @_; + $logic ||= 'and'; - my (@all_sql, @all_bind); + local $self->{_nested_func_lhs} = $self->{_nested_func_lhs}; + $self->{_nested_func_lhs} ||= $k; - for my $op (sort keys %$v) { - my $val = $v->{$op}; + my ($all_sql, @all_bind); + + for my $orig_op (sort keys %$v) { + my $val = $v->{$orig_op}; # put the operator in canonical form - $op =~ s/^-//; # remove initial dash - $op =~ tr/_/ /; # underscores become spaces - $op =~ s/^\s+//; # no initial space - $op =~ s/\s+$//; # no final space - $op =~ s/\s+/ /; # multiple spaces become one + my $op = $orig_op; + $op =~ s/^-//; # remove initial dash + $op =~ s/[_\t ]+/ /g; # underscores and whitespace become single spaces + $op =~ s/^\s+|\s+$//g;# remove leading/trailing space my ($sql, @bind); + # CASE: col-value logic modifiers + if ( $orig_op =~ /^ \- (and|or) $/xi ) { + ($sql, @bind) = $self->_where_hashpair_HASHREF($k, $val, $1); + } # CASE: special operators like -in or -between - my $special_op = first {$op =~ $_->{regex}} @{$self->{special_ops}}; - if ($special_op) { - ($sql, @bind) = $special_op->{handler}->($self, $k, $op, $val); + elsif ( my $special_op = first {$op =~ $_->{regex}} @{$self->{special_ops}} ) { + my $handler = $special_op->{handler}; + if (! $handler) { + puke "No handler supplied for special operator $orig_op"; + } + elsif (not ref $handler) { + ($sql, @bind) = $self->$handler ($k, $op, $val); + } + elsif (ref $handler eq 'CODE') { + ($sql, @bind) = $handler->($self, $k, $op, $val); + } + else { + puke "Illegal handler for special operator $orig_op - expecting a method name or a coderef"; + } } else { $self->_SWITCH_refkind($val, { @@ -544,12 +697,6 @@ sub _where_hashpair_HASHREF { ($sql, @bind) = $self->_where_field_op_ARRAYREF($k, $op, $val); }, - SCALARREF => sub { # CASE: col => {op => \$scalar} (literal SQL without bind) - $sql = join ' ', $self->_convert($self->_quote($k)), - $self->_sqlcase($op), - $$val; - }, - ARRAYREFREF => sub { # CASE: col => {op => \[$sql, @bind]} (literal SQL with bind) my ($sub_sql, @sub_bind) = @$$val; $self->_assert_bindval_matches_bindtype(@sub_bind); @@ -562,24 +709,21 @@ sub _where_hashpair_HASHREF { UNDEF => sub { # CASE: col => {op => undef} : sql "IS (NOT)? NULL" my $is = ($op =~ $self->{equality_op}) ? 'is' : ($op =~ $self->{inequality_op}) ? 'is not' : - puke "unexpected operator '$op' with undef operand"; + puke "unexpected operator '$orig_op' with undef operand"; $sql = $self->_quote($k) . $self->_sqlcase(" $is null"); }, - - FALLBACK => sub { # CASE: col => {op => $scalar} - $sql = join ' ', $self->_convert($self->_quote($k)), - $self->_sqlcase($op), - $self->_convert('?'); - @bind = $self->_bindtype($k, $val); + + FALLBACK => sub { # CASE: col => {op/func => $stuff} + ($sql, @bind) = $self->_where_func_generic ($op, $val); + $sql = join ' ', $self->_convert($self->_quote($k)), $sql; }, }); } - push @all_sql, $sql; + ($all_sql) = (defined $all_sql and $all_sql) ? $self->_join_sql_clauses($logic, [$all_sql, $sql], []) : $sql; push @all_bind, @bind; } - - return $self->_join_sql_clauses('and', \@all_sql, \@all_bind); + return ($all_sql, @all_bind); } @@ -587,20 +731,33 @@ sub _where_hashpair_HASHREF { sub _where_field_op_ARRAYREF { my ($self, $k, $op, $vals) = @_; - if(@$vals) { - $self->_debug("ARRAY($vals) means multiple elements: [ @$vals ]"); + my @vals = @$vals; #always work on a copy + + if(@vals) { + $self->_debug(sprintf '%s means multiple elements: [ %s ]', + $vals, + join (', ', map { defined $_ ? "'$_'" : 'NULL' } @vals ), + ); + + # see if the first element is an -and/-or op + my $logic; + if (defined $vals[0] && $vals[0] =~ /^ - ( AND|OR ) $/ix) { + $logic = uc $1; + shift @vals; + } + + # distribute $op over each remaining member of @vals, append logic if exists + return $self->_recurse_where([map { {$k => {$op, $_}} } @vals], $logic); # LDNOTE : had planned to change the distribution logic when # $op =~ $self->{inequality_op}, because of Morgan laws : # with {field => {'!=' => [22, 33]}}, it would be ridiculous to generate # WHERE field != 22 OR field != 33 : the user probably means # WHERE field != 22 AND field != 33. - # To do this, replace the line below by : + # To do this, replace the above to roughly : # my $logic = ($op =~ $self->{inequality_op}) ? 'AND' : 'OR'; - # return $self->_recurse_where([map { {$k => {$op, $_}} } @$vals], $logic); + # return $self->_recurse_where([map { {$k => {$op, $_}} } @vals], $logic); - # distribute $op over each member of @$vals - return $self->_recurse_where([map { {$k => {$op, $_}} } @$vals]); } else { # try to DWIM on equality operators @@ -687,16 +844,52 @@ sub _where_UNDEF { sub _where_field_BETWEEN { my ($self, $k, $op, $vals) = @_; - ref $vals eq 'ARRAY' && @$vals == 2 - or puke "special op 'between' requires an arrayref of two values"; - - my ($label) = $self->_convert($self->_quote($k)); - my ($placeholder) = $self->_convert('?'); - my $and = $self->_sqlcase('and'); + my ($label, $and, $placeholder); + $label = $self->_convert($self->_quote($k)); + $and = ' ' . $self->_sqlcase('and') . ' '; + $placeholder = $self->_convert('?'); $op = $self->_sqlcase($op); - my $sql = "( $label $op $placeholder $and $placeholder )"; - my @bind = $self->_bindtype($k, @$vals); + my ($clause, @bind) = $self->_SWITCH_refkind($vals, { + ARRAYREFREF => sub { + return @$$vals; + }, + SCALARREF => sub { + return $$vals; + }, + ARRAYREF => sub { + puke "special op 'between' accepts an arrayref with exactly two values" + if @$vals != 2; + + my (@all_sql, @all_bind); + foreach my $val (@$vals) { + my ($sql, @bind) = $self->_SWITCH_refkind($val, { + SCALAR => sub { + return ($placeholder, ($val)); + }, + SCALARREF => sub { + return ($self->_convert($$val), ()); + }, + ARRAYREFREF => sub { + my ($sql, @bind) = @$$val; + return ($self->_convert($sql), @bind); + }, + }); + push @all_sql, $sql; + push @all_bind, @bind; + } + + return ( + (join $and, @all_sql), + $self->_bindtype($k, @all_bind), + ); + }, + FALLBACK => sub { + puke "special op 'between' accepts an arrayref with two values, or a single literal scalarref/arrayref-ref"; + }, + }); + + my $sql = "( $label $op $clause )"; return ($sql, @bind) } @@ -726,23 +919,33 @@ sub _where_field_IN { } }, + SCALARREF => sub { # literal SQL + my $sql = $self->_open_outer_paren ($$vals); + return ("$label $op ( $sql )"); + }, ARRAYREFREF => sub { # literal SQL with bind my ($sql, @bind) = @$$vals; $self->_assert_bindval_matches_bindtype(@bind); + $sql = $self->_open_outer_paren ($sql); return ("$label $op ( $sql )", @bind); }, FALLBACK => sub { - puke "special op 'in' requires an arrayref (or arrayref-ref)"; + puke "special op 'in' requires an arrayref (or scalarref/arrayref-ref)"; }, }); return ($sql, @bind); } - - - +# Some databases (SQLite) treat col IN (1, 2) different from +# col IN ( (1, 2) ). Use this to strip all outer parens while +# adding them back in the corresponding method +sub _open_outer_paren { + my ($self, $sql) = @_; + $sql = $1 while $sql =~ /^ \s* \( (.*) \) \s* $/xs; + return $sql; +} #====================================================================== @@ -752,49 +955,78 @@ sub _where_field_IN { sub _order_by { my ($self, $arg) = @_; - # construct list of ordering instructions - my @order = $self->_SWITCH_refkind($arg, { + my (@sql, @bind); + for my $c ($self->_order_by_chunks ($arg) ) { + $self->_SWITCH_refkind ($c, { + SCALAR => sub { push @sql, $c }, + ARRAYREF => sub { push @sql, shift @$c; push @bind, @$c }, + }); + } + + my $sql = @sql + ? sprintf ('%s %s', + $self->_sqlcase(' order by'), + join (', ', @sql) + ) + : '' + ; + + return wantarray ? ($sql, @bind) : $sql; +} + +sub _order_by_chunks { + my ($self, $arg) = @_; + + return $self->_SWITCH_refkind($arg, { ARRAYREF => sub { - map {$self->_SWITCH_refkind($_, { - SCALAR => sub {$self->_quote($_)}, - UNDEF => sub {}, - SCALARREF => sub {$$_}, # literal SQL, no quoting - HASHREF => sub {$self->_order_by_hash($_)} - }) } @$arg; + map { $self->_order_by_chunks ($_ ) } @$arg; }, + ARRAYREFREF => sub { [ @$$arg ] }, + SCALAR => sub {$self->_quote($arg)}, - UNDEF => sub {}, + + UNDEF => sub {return () }, + SCALARREF => sub {$$arg}, # literal SQL, no quoting - HASHREF => sub {$self->_order_by_hash($arg)}, - }); + HASHREF => sub { + # get first pair in hash + my ($key, $val) = each %$arg; - # build SQL - my $order = join ', ', @order; - return $order ? $self->_sqlcase(' order by')." $order" : ''; -} + return () unless $key; + + if ( (keys %$arg) > 1 or not $key =~ /^-(desc|asc)/i ) { + puke "hash passed to _order_by must have exactly one key (-desc or -asc)"; + } + my $direction = $1; -sub _order_by_hash { - my ($self, $hash) = @_; + my @ret; + for my $c ($self->_order_by_chunks ($val)) { + my ($sql, @bind); - # get first pair in hash - my ($key, $val) = each %$hash; + $self->_SWITCH_refkind ($c, { + SCALAR => sub { + $sql = $c; + }, + ARRAYREF => sub { + ($sql, @bind) = @$c; + }, + }); - # check if one pair was found and no other pair in hash - $key && !(each %$hash) - or puke "hash passed to _order_by must have exactly one key (-desc or -asc)"; + $sql = $sql . ' ' . $self->_sqlcase($direction); - my ($order) = ($key =~ /^-(desc|asc)/i) - or puke "invalid key in _order_by hash : $key"; + push @ret, [ $sql, @bind]; + } - return $self->_quote($val) ." ". $self->_sqlcase($order); + return @ret; + }, + }); } - #====================================================================== # DATASOURCE (FOR NOW, JUST PLAIN TABLE OR LIST OF TABLES) #====================================================================== @@ -1308,12 +1540,15 @@ the huge section on L at the bottom. =item sqltrue, sqlfalse Expressions for inserting boolean values within SQL statements. -By default these are C<1=1> and C<1=0>. +By default these are C<1=1> and C<1=0>. They are used +by the special operators C<-in> and C<-not_in> for generating +correct SQL even when the argument is an empty array (see below). =item logic This determines the default logical operator for multiple WHERE -statements in arrays. By default it is "or", meaning that a WHERE +statements in arrays or hashes. If absent, the default logic is "or" +for arrays, and "and" for hashes. This means that a WHERE array of the form: @where = ( @@ -1321,7 +1556,7 @@ array of the form: event_date => {'<=', '4/24/03'}, ); -Will generate SQL like this: +will generate SQL like this: WHERE event_date >= '2/13/99' OR event_date <= '4/24/03' @@ -1335,10 +1570,10 @@ Which will change the above C to: WHERE event_date >= '2/13/99' AND event_date <= '4/24/03' The logic can also be changed locally by inserting -an extra first element in the array : +a modifier in front of an arrayref : - @where = (-and => event_date => {'>=', '2/13/99'}, - event_date => {'<=', '4/24/03'} ); + @where = (-and => [event_date => {'>=', '2/13/99'}, + event_date => {'<=', '4/24/03'} ]); See the L section for explanations. @@ -1456,11 +1691,17 @@ Takes a reference to a list of "special operators" to extend the syntax understood by L. See section L for details. +=item unary_ops + +Takes a reference to a list of "unary operators" +to extend the syntax understood by L. +See section L for details. + =back -=head2 insert($table, \@values || \%fieldvals) +=head2 insert($table, \@values || \%fieldvals, \%options) This is the simplest function. You simply give it a table name and either an arrayref of values or hashref of field/value pairs. @@ -1469,6 +1710,23 @@ See the sections on L and L for information on how to insert with those data types. +The optional C<\%options> hash reference may contain additional +options to generate the insert SQL. Currently supported options +are: + +=over 4 + +=item returning + +Takes either a scalar of raw SQL fields, or an array reference of +field names, and adds on an SQL C statement at the end. +This allows you to return data generated by the insert statement +(such as row IDs) without performing another C