X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=lib%2FSQL%2FAbstract.pm;h=c6b2e2461db79d2f5ea7a6e0b8c9737a4de0f1c6;hb=97a920ef62ad5bf8177531935a67e4ce4d02f260;hp=c0de4d5b6950a2f465f8ef02c4b73a7d0cbe19b4;hpb=f2d5020d799a39cecb1f165a75b15b793a0d3453;p=scpubgit%2FQ-Branch.git diff --git a/lib/SQL/Abstract.pm b/lib/SQL/Abstract.pm index c0de4d5..c6b2e24 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.54'; # This would confuse some packagers #$VERSION = eval $VERSION; # numify for warning-free dev releases @@ -25,10 +25,19 @@ 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 = { + 'AND' => '_where_op_ANDOR', + 'OR' => '_where_op_ANDOR', + 'NEST' => '_where_op_NEST', + 'BOOL' => '_where_op_BOOL', + 'NOT_BOOL' => '_where_op_BOOL', +}; + #====================================================================== # DEBUGGING AND ERROR REPORTING #====================================================================== @@ -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' ?? @@ -422,7 +431,6 @@ 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) { my $v = $where->{$k}; @@ -442,43 +450,88 @@ sub _where_HASHREF { sub _where_op_in_hash { - my ($self, $op, $v) = @_; + my ($self, $op_str, $v) = @_; + + $op_str =~ /^ ([A-Z_]+[A-Z]) ( \_? \d* ) $/xi + or puke "unknown or malstructured operator: -$op_str"; + + my $op = uc($1); # uppercase, remove trailing digits + if ($2) { + belch 'Use of [and|or|nest]_N modifiers is deprecated and will be removed in SQLA v2.0. ' + . "You probably wanted ...-and => [ $op_str => COND1, $op_str => COND2 ... ]"; + } - $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..."); + my $handler = $BUILTIN_UNARY_OPS->{$op}; + if (! $handler) { + puke "unknown operator: -$op_str"; + } + elsif (not ref $handler) { + return $self->$handler ($op, $v); + } + elsif (ref $handler eq 'CODE') { + return $handler->($self, $op, $v); + } + else { + puke "Illegal handler for operator $op - expecting a method name or a coderef"; + } +} + +sub _where_op_ANDOR { + my ($self, $op, $v) = @_; + + $self->_SWITCH_refkind($v, { + ARRAYREF => sub { + return $self->_where_ARRAYREF($v, $op); + }, + + HASHREF => sub { + return ( $op eq 'OR' ) + ? $self->_where_ARRAYREF( [ map { $_ => $v->{$_} } ( sort keys %$v ) ], $op ) + : $self->_where_HASHREF($v); + }, + + SCALARREF => sub { + puke "-$op => \\\$scalar not supported, use -nest => ..."; + }, + + ARRAYREFREF => sub { + puke "-$op => \\[..] not supported, use -nest => ..."; + }, + + 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, { ARRAYREF => sub { - return $self->_where_ARRAYREF($v, $op eq 'NEST' ? '' : $op); + return $self->_where_ARRAYREF($v, ''); }, HASHREF => sub { - if ($op eq 'OR') { - return $self->_where_ARRAYREF([%$v], 'OR'); - } - else { # NEST | AND - return $self->_where_HASHREF($v); - } + return $self->_where_HASHREF($v); }, SCALARREF => sub { # literal SQL - $op eq 'NEST' - or puke "-$op => \\\$scalar not supported, use -nest => ..."; return ($$v); }, ARRAYREFREF => sub { # literal SQL - $op eq 'NEST' - or puke "-$op => \\[..] not supported, use -nest => ..."; return @{${$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); @@ -491,6 +544,22 @@ sub _where_op_in_hash { } +sub _where_op_BOOL { + my ($self, $op, $v) = @_; + + my $prefix = $op eq 'BOOL' ? '' : 'NOT '; + $self->_SWITCH_refkind($v, { + SCALARREF => sub { # literal SQL + return ($prefix . $$v); + }, + + SCALAR => sub { # interpreted as SQL column + return ($prefix . $self->_convert($self->_quote($v))); + }, + }); +} + + sub _where_hashpair_ARRAYREF { my ($self, $k, $v) = @_; @@ -499,11 +568,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,9 +592,10 @@ sub _where_hashpair_ARRAYREF { } sub _where_hashpair_HASHREF { - my ($self, $k, $v) = @_; + my ($self, $k, $v, $logic) = @_; + $logic ||= 'and'; - my (@all_sql, @all_bind); + my ($all_sql, @all_bind); for my $op (sort keys %$v) { my $val = $v->{$op}; @@ -535,7 +612,19 @@ sub _where_hashpair_HASHREF { # 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); + my $handler = $special_op->{handler}; + if (! $handler) { + puke "No handler supplied for special operator matching $special_op->{regex}"; + } + 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 matching $special_op->{regex} - expecting a method name or a coderef"; + } } else { $self->_SWITCH_refkind($val, { @@ -559,6 +648,10 @@ sub _where_hashpair_HASHREF { @bind = @sub_bind; }, + HASHREF => sub { + ($sql, @bind) = $self->_where_hashpair_HASHREF($k, $val, $op); + }, + UNDEF => sub { # CASE: col => {op => undef} : sql "IS (NOT)? NULL" my $is = ($op =~ $self->{equality_op}) ? 'is' : ($op =~ $self->{inequality_op}) ? 'is not' : @@ -575,11 +668,10 @@ sub _where_hashpair_HASHREF { }); } - 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); } @@ -590,17 +682,25 @@ sub _where_field_op_ARRAYREF { if(@$vals) { $self->_debug("ARRAY($vals) means multiple elements: [ @$vals ]"); + # see if the first element is an -and/-or op + my $logic; + if ($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); - # distribute $op over each member of @$vals - return $self->_recurse_where([map { {$k => {$op, $_}} } @$vals]); } else { # try to DWIM on equality operators @@ -687,16 +787,39 @@ 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"; + (ref $vals eq 'ARRAY' && @$vals == 2) or + (ref $vals eq 'REF' && (@$$vals == 1 || @$$vals == 2 || @$$vals == 3)) + or puke "special op 'between' requires an arrayref of two values (or a scalarref or arrayrefref for literal SQL)"; - my ($label) = $self->_convert($self->_quote($k)); - my ($placeholder) = $self->_convert('?'); - my $and = $self->_sqlcase('and'); + my ($clause, @bind, $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); + if (ref $vals eq 'REF') { + ($clause, @bind) = @$$vals; + } + else { + 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), ()); + }, + }); + push @all_sql, $sql; + push @all_bind, @bind; + } + + $clause = (join $and, @all_sql); + @bind = $self->_bindtype($k, @all_bind); + } + my $sql = "( $label $op $clause )"; return ($sql, @bind) } @@ -743,8 +866,6 @@ sub _where_field_IN { - - #====================================================================== # ORDER BY #====================================================================== @@ -790,7 +911,8 @@ sub _order_by_hash { my ($order) = ($key =~ /^-(desc|asc)/i) or puke "invalid key in _order_by hash : $key"; - return $self->_quote($val) ." ". $self->_sqlcase($order); + $val = ref $val eq 'ARRAY' ? $val : [$val]; + return join ', ', map { $self->_quote($_) . ' ' . $self->_sqlcase($order) } @$val; } @@ -1308,12 +1430,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 +1446,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 +1460,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. @@ -1623,10 +1748,10 @@ This simple code will create the following: $stmt = "WHERE user = ? AND ( status = ? OR status = ? OR status = ? )"; @bind = ('nwiger', 'assigned', 'in-progress', 'pending'); -An empty arrayref will be considered a logical false and -will generate 0=1. +A field associated to an empty arrayref will be considered a +logical false and will generate 0=1. -=head2 Key-value pairs +=head2 Specific comparison operators If you want to specify a different type of operator for your comparison, you can use a hashref for a given column: @@ -1733,29 +1858,6 @@ Here is a quick list of equivalencies, since there is some overlap: status => [ -or => {'=', 'assigned'}, {'=', 'in-progress'}] status => [ {'=', 'assigned'}, {'=', 'in-progress'} ] -In addition to C<-and> and C<-or>, there is also a special C<-nest> -operator which adds an additional set of parens, to create a subquery. -For example, to get something like this: - - $stmt = "WHERE user = ? AND ( workhrs > ? OR geo = ? )"; - @bind = ('nwiger', '20', 'ASIA'); - -You would do: - - my %where = ( - user => 'nwiger', - -nest => [ workhrs => {'>', 20}, geo => 'ASIA' ], - ); - -If you need several nested subexpressions, you can number -the C<-nest> branches : - - my %where = ( - user => 'nwiger', - -nest1 => ..., - -nest2 => ..., - ... - ); =head2 Special operators : IN, BETWEEN, etc. @@ -1776,6 +1878,12 @@ Which would generate: The reverse operator C<-not_in> generates SQL C and is used in the same way. +If the argument to C<-in> is an empty array, 'sqlfalse' is generated +(by default : C<1=0>). Similarly, C<< -not_in => [] >> generates +'sqltrue' (by default : C<1=1>). + + + Another pair of operators is C<-between> and C<-not_between>, used with an arrayref of two values: @@ -1793,7 +1901,25 @@ Would give you: These are the two builtin "special operators"; but the list can be expanded : see section L below. -=head2 Nested conditions +=head2 Boolean operators + +If you wish to test against boolean columns or functions within your +database you can use the C<-bool> and C<-not_bool> operators. For +example to test the column C being true and the column + being false you would use:- + + my %where = ( + -bool => 'is_user', + -not_bool => 'is_enabled', + ); + +Would give you: + + WHERE is_user AND NOT is_enabledmv + + + +=head2 Nested conditions, -and/-or prefixes So far, we've seen how multiple conditions are joined with a top-level C. We can change this by putting the different conditions we want in @@ -1816,15 +1942,32 @@ This data structure would create the following: OR ( user = ? AND status = ? ) )"; @bind = ('nwiger', 'pending', 'dispatched', 'robot', 'unassigned'); -This can be combined with the C<-nest> operator to properly group -SQL statements: + +There is also a special C<-nest> +operator which adds an additional set of parens, to create a subquery. +For example, to get something like this: + + $stmt = "WHERE user = ? AND ( workhrs > ? OR geo = ? )"; + @bind = ('nwiger', '20', 'ASIA'); + +You would do: + + my %where = ( + user => 'nwiger', + -nest => [ workhrs => {'>', 20}, geo => 'ASIA' ], + ); + + +Finally, clauses in hashrefs or arrayrefs can be +prefixed with an C<-and> or C<-or> to change the logic +inside : my @where = ( -and => [ user => 'nwiger', -nest => [ - ["-and", workhrs => {'>', 20}, geo => 'ASIA' ], - ["-and", workhrs => {'<', 50}, geo => 'EURO' ] + -and => [workhrs => {'>', 20}, geo => 'ASIA' ], + -and => [workhrs => {'<', 50}, geo => 'EURO' ] ], ], ); @@ -1835,6 +1978,37 @@ That would yield: ( ( workhrs > ? AND geo = ? ) OR ( workhrs < ? AND geo = ? ) ) ) + +=head2 Algebraic inconsistency, for historical reasons + +C: when connecting several conditions, the C<-and->|C<-or> +operator goes C of the nested structure; whereas when connecting +several constraints on one column, the C<-and> operator goes +C the arrayref. Here is an example combining both features : + + my @where = ( + -and => [a => 1, b => 2], + -or => [c => 3, d => 4], + e => [-and => {-like => 'foo%'}, {-like => '%bar'} ] + ) + +yielding + + WHERE ( ( ( a = ? AND b = ? ) + OR ( c = ? OR d = ? ) + OR ( e LIKE ? AND e LIKE ? ) ) ) + +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'}]} + # yields : WHERE ( ( col LIKE ? AND col LIKE ? ) ) + + [-and => {col => {-like => 'foo%'}, {col => {-like => '%bar'}}]] + # yields : WHERE ( ( col LIKE ? OR col LIKE ? ) ) + + =head2 Literal SQL Finally, sometimes only literal SQL will do. If you want to include @@ -2012,30 +2186,45 @@ Some functions take an order by clause. This can either be a scalar (just a column name,) a hash of C<< { -desc => 'col' } >> or C<< { -asc => 'col' } >>, or an array of either of the two previous forms. Examples: - Given | Will Generate + Given | Will Generate ---------------------------------------------------------- - \'colA DESC' | ORDER BY colA DESC - 'colA' | ORDER BY colA - [qw/colA colB/] | ORDER BY colA, colB - {-asc => 'colA'} | ORDER BY colA ASC - {-desc => 'colB'} | ORDER BY colB DESC - [ | - {-asc => 'colA'}, | ORDER BY colA ASC, colB DESC - {-desc => 'colB'} | - ] | - [colA => {-asc => 'colB'}] | ORDER BY colA, colB ASC - ========================================================== + | + \'colA DESC' | ORDER BY colA DESC + | + 'colA' | ORDER BY colA + | + [qw/colA colB/] | ORDER BY colA, colB + | + {-asc => 'colA'} | ORDER BY colA ASC + | + {-desc => 'colB'} | ORDER BY colB DESC + | + ['colA', {-asc => 'colB'}] | ORDER BY colA, colB ASC + | + { -asc => [qw/colA colB] } | ORDER BY colA ASC, colB ASC + | + [ | + { -asc => 'colA' }, | ORDER BY colA ASC, colB DESC, + { -desc => [qw/colB/], | colC ASC, colD ASC + { -asc => [qw/colC colD/],| + ] | + =========================================================== =head1 SPECIAL OPERATORS my $sqlmaker = SQL::Abstract->new(special_ops => [ - {regex => qr/.../, + { + regex => qr/.../, handler => sub { my ($self, $field, $op, $arg) = @_; ... - }, + }, + }, + { + regex => qr/.../, + handler => 'method_name', }, ]); @@ -2048,12 +2237,13 @@ For example : WHERE MATCH(field) AGAINST (?, ?) Special operators IN and BETWEEN are fairly standard and therefore -are builtin within C. For other operators, -like the MATCH .. AGAINST example above which is -specific to MySQL, you can write your own operator handlers : -supply a C argument to the C method. -That argument takes an arrayref of operator definitions; -each operator definition is a hashref with two entries +are builtin within C (as the overridable methods +C<_where_field_IN> and C<_where_field_BETWEEN>). For other operators, +like the MATCH .. AGAINST example above which is specific to MySQL, +you can write your own operator handlers - supply a C +argument to the C method. That argument takes an arrayref of +operator definitions; each operator definition is a hashref with two +entries: =over @@ -2063,10 +2253,24 @@ the regular expression to match the operator =item handler -coderef that will be called when meeting that operator -in the input tree. The coderef will be called with -arguments C<< ($self, $field, $op, $arg) >>, and -should return a C<< ($sql, @bind) >> structure. +Either a coderef or a plain scalar method name. In both cases +the expected return is C<< ($sql, @bind) >>. + +When supplied with a method name, it is simply called on the +L object as: + + $self->$method_name ($field, $op, $arg) + + Where: + + $op is the part that matched the handler regex + $field is the LHS of the operator + $arg is the RHS + +When supplied with a coderef, it is called as: + + $coderef->($self, $field, $op, $arg) + =back @@ -2178,10 +2382,6 @@ support for the { operator => \["...", @bind] } construct (to embed literal SQL =item * -added -nest1, -nest2 or -nest_1, -nest_2, ... - -=item * - optional support for L =item * @@ -2191,21 +2391,12 @@ defensive programming : check arguments =item * fixed bug with global logic, which was previously implemented -through global variables yielding side-effects. Prior versons would +through global variables yielding side-effects. Prior versions would interpret C<< [ {cond1, cond2}, [cond3, cond4] ] >> as C<< "(cond1 AND cond2) OR (cond3 AND cond4)" >>. Now this is interpreted as C<< "(cond1 AND cond2) OR (cond3 OR cond4)" >>. -=item * - -C<-and> / C<-or> operators are no longer accepted -in the middle of an arrayref : they are -only admitted if in first position. - -=item * - -changed logic for distributing an op over arrayrefs =item * @@ -2241,6 +2432,7 @@ so I have no idea who they are! But the people I do know are: Guillermo Roditi (patch to cleanup "IN" and "BETWEEN", fix and tests for _order_by) Laurent Dami (internal refactoring, multiple -nest, extensible list of special operators, literal SQL) Norbert Buchmuller (support for literal SQL in hashpair, misc. fixes & tests) + Peter Rabbitson (rewrite of SQLA::Test, misc. fixes & tests) Thanks! @@ -2259,6 +2451,8 @@ While not an official support venue, C makes heavy use of C, and as such list members there are very familiar with how to create queries. +=head1 LICENSE + This module is free software; you may copy this under the terms of the GNU General Public License, or the Artistic License, copies of which should have accompanied your Perl kit.