Hello community, here is the log from the commit of package perl-SQL-Abstract for openSUSE:Factory checked in at 2014-11-13 09:17:57 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:Factory/perl-SQL-Abstract (Old) and /work/SRC/openSUSE:Factory/.perl-SQL-Abstract.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "perl-SQL-Abstract" Changes: -------- --- /work/SRC/openSUSE:Factory/perl-SQL-Abstract/perl-SQL-Abstract.changes 2014-09-17 17:26:23.000000000 +0200 +++ /work/SRC/openSUSE:Factory/.perl-SQL-Abstract.new/perl-SQL-Abstract.changes 2014-11-13 09:18:16.000000000 +0100 @@ -1,0 +2,20 @@ +Wed Nov 12 09:41:09 UTC 2014 - co...@suse.com + +- updated to 1.81 + - Fix overly-enthusiastic parenthesis unroller (RT#99503) + + revision 1.80 2014-10-05 + ---------------------------- + - Fix erroneous behavior of is_literal_value($) wrt { -ident => ... } + - Explicitly croak on top-level special ops (they didn't work anyway) + + revision 1.79 2014-09-25 + ---------------------------- + - New exportable functions: is_literal_value($) and is_plain_value($) + - New attribute 'escape_char' allowing for proper escape of quote_chars + present in an identifier + - Deprecate { "" => \... } constructs + - Treat { -value => undef } as plain undef in all cases + - Explicitly throw on { -ident => undef } + +------------------------------------------------------------------- Old: ---- SQL-Abstract-1.78.tar.gz New: ---- SQL-Abstract-1.81.tar.gz ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ perl-SQL-Abstract.spec ++++++ --- /var/tmp/diff_new_pack.GHCROj/_old 2014-11-13 09:18:17.000000000 +0100 +++ /var/tmp/diff_new_pack.GHCROj/_new 2014-11-13 09:18:17.000000000 +0100 @@ -17,7 +17,7 @@ Name: perl-SQL-Abstract -Version: 1.78 +Version: 1.81 Release: 0 %define cpan_name SQL-Abstract Summary: Generate SQL from Perl data structures @@ -30,13 +30,17 @@ BuildRequires: perl BuildRequires: perl-macros BuildRequires: perl(Hash::Merge) >= 0.12 +BuildRequires: perl(MRO::Compat) >= 0.12 BuildRequires: perl(Moo) >= 1.004002 BuildRequires: perl(Test::Deep) >= 0.101 BuildRequires: perl(Test::Exception) >= 0.31 BuildRequires: perl(Test::More) >= 0.88 BuildRequires: perl(Test::Warn) +BuildRequires: perl(Text::Balanced) >= 2.00 Requires: perl(Hash::Merge) >= 0.12 +Requires: perl(MRO::Compat) >= 0.12 Requires: perl(Moo) >= 1.004002 +Requires: perl(Text::Balanced) >= 2.00 %{perl_requires} %description ++++++ SQL-Abstract-1.78.tar.gz -> SQL-Abstract-1.81.tar.gz ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/SQL-Abstract-1.78/Changes new/SQL-Abstract-1.81/Changes --- old/SQL-Abstract-1.78/Changes 2014-05-28 12:11:40.000000000 +0200 +++ new/SQL-Abstract-1.81/Changes 2014-10-25 13:30:00.000000000 +0200 @@ -1,5 +1,23 @@ Revision history for SQL::Abstract +revision 1.81 2014-10-25 +---------------------------- + - Fix overly-enthusiastic parenthesis unroller (RT#99503) + +revision 1.80 2014-10-05 +---------------------------- + - Fix erroneous behavior of is_literal_value($) wrt { -ident => ... } + - Explicitly croak on top-level special ops (they didn't work anyway) + +revision 1.79 2014-09-25 +---------------------------- + - New exportable functions: is_literal_value($) and is_plain_value($) + - New attribute 'escape_char' allowing for proper escape of quote_chars + present in an identifier + - Deprecate { "" => \... } constructs + - Treat { -value => undef } as plain undef in all cases + - Explicitly throw on { -ident => undef } + revision 1.78 2014-05-28 ---------------------------- - Fix parsing of binary ops to correctly take up only a single LHS diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/SQL-Abstract-1.78/MANIFEST new/SQL-Abstract-1.81/MANIFEST --- old/SQL-Abstract-1.78/MANIFEST 2014-05-28 12:14:07.000000000 +0200 +++ new/SQL-Abstract-1.81/MANIFEST 2014-10-25 13:31:05.000000000 +0200 @@ -41,6 +41,7 @@ t/20injection_guard.t t/21op_ident.t t/22op_value.t +t/23_is_X_value.t t/dbic/bulk-insert.t t/dbic/no-repeats.t t/dbic/show-progress.t diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/SQL-Abstract-1.78/META.yml new/SQL-Abstract-1.81/META.yml --- old/SQL-Abstract-1.78/META.yml 2014-05-28 12:13:59.000000000 +0200 +++ new/SQL-Abstract-1.81/META.yml 2014-10-25 13:30:57.000000000 +0200 @@ -28,13 +28,17 @@ package: - DBIx::Class::Storage::Debug::PrettyPrint requires: + Exporter: 5.57 Hash::Merge: 0.12 List::Util: 0 + MRO::Compat: 0.12 Moo: 1.004002 Scalar::Util: 0 + Text::Balanced: 2.00 perl: 5.6.0 resources: + IRC: irc://irc.perl.org/#dbix-class bugtracker: http://rt.cpan.org/NoAuth/Bugs.html?Dist=SQL-Abstract license: http://dev.perl.org/licenses/ - repository: git://git.shadowcat.co.uk/dbsrgits/SQL-Abstract.git -version: 1.78 + repository: https://github.com/dbsrgits/sql-abstract/ +version: 1.81 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/SQL-Abstract-1.78/Makefile.PL new/SQL-Abstract-1.81/Makefile.PL --- old/SQL-Abstract-1.78/Makefile.PL 2014-05-28 12:10:34.000000000 +0200 +++ new/SQL-Abstract-1.81/Makefile.PL 2014-10-25 12:45:09.000000000 +0200 @@ -8,23 +8,27 @@ name 'SQL-Abstract'; author 'Nathan Wiger <n...@wiger.org>'; resources 'license' => 'http://dev.perl.org/licenses/'; -resources 'repository' => 'git://git.shadowcat.co.uk/dbsrgits/SQL-Abstract.git'; +resources 'repository' => 'https://github.com/dbsrgits/sql-abstract/'; resources 'bugtracker' => 'http://rt.cpan.org/NoAuth/Bugs.html?Dist=SQL-Abstract'; +resources 'IRC' => 'irc://irc.perl.org/#dbix-class'; all_from 'lib/SQL/Abstract.pm'; dynamic_config 0; -requires 'List::Util' => 0; -requires 'Scalar::Util' => 0; -requires 'Moo' => 1.004002; -requires 'Hash::Merge' => 0.12; +requires 'List::Util' => '0'; +requires 'Scalar::Util' => '0'; +requires 'Exporter' => '5.57'; +requires 'MRO::Compat' => '0.12'; +requires 'Moo' => '1.004002'; +requires 'Hash::Merge' => '0.12'; +requires 'Text::Balanced' => '2.00'; -test_requires "Test::More" => 0.88; -test_requires "Test::Exception" => 0.31; -test_requires "Test::Warn" => 0; -test_requires "Test::Deep" => 0.101; -test_requires "Storable" => 0; # for cloning in tests +test_requires "Test::More" => '0.88'; +test_requires "Test::Exception" => '0.31'; +test_requires "Test::Warn" => '0'; +test_requires "Test::Deep" => '0.101'; +test_requires "Storable" => '0'; # for cloning in tests no_index package => 'DBIx::Class::Storage::Debug::PrettyPrint'; no_index directory => 'examples'; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/SQL-Abstract-1.78/lib/SQL/Abstract/Tree.pm new/SQL-Abstract-1.81/lib/SQL/Abstract/Tree.pm --- old/SQL-Abstract-1.78/lib/SQL/Abstract/Tree.pm 2014-05-28 05:48:09.000000000 +0200 +++ new/SQL-Abstract-1.81/lib/SQL/Abstract/Tree.pm 2014-09-24 02:24:45.000000000 +0200 @@ -5,9 +5,19 @@ BEGIN { require warnings; my $initial_fatal_bits = (${^WARNING_BITS}||'') & $warnings::DeadBits{all}; + local $ENV{PERL_STRICTURES_EXTRA} = 0; - require Moo; Moo->import; - require Sub::Quote; Sub::Quote->import('quote_sub'); + # load all of these now, so that lazy-loading does not escape + # the current PERL_STRICTURES_EXTRA setting + require Sub::Quote; + require Sub::Defer; + require Moo; + require Moo::Object; + require Method::Generate::Accessor; + require Method::Generate::Constructor; + + Moo->import; + Sub::Quote->import('quote_sub'); ${^WARNING_BITS} &= ( $initial_fatal_bits | ~ $warnings::DeadBits{all} ); } # END pre-Moo2 import block diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/SQL-Abstract-1.78/lib/SQL/Abstract.pm new/SQL-Abstract-1.81/lib/SQL/Abstract.pm --- old/SQL-Abstract-1.78/lib/SQL/Abstract.pm 2014-05-28 12:12:07.000000000 +0200 +++ new/SQL-Abstract-1.81/lib/SQL/Abstract.pm 2014-10-25 13:29:36.000000000 +0200 @@ -6,11 +6,28 @@ use List::Util (); use Scalar::Util (); +use Exporter 'import'; +our @EXPORT_OK = qw(is_plain_value is_literal_value); + +BEGIN { + if ($] < 5.009_005) { + require MRO::Compat; + } + else { + require mro; + } + + *SQL::Abstract::_ENV_::DETECT_AUTOGENERATED_STRINGIFICATION = $ENV{SQLA_ISVALUE_IGNORE_AUTOGENERATED_STRINGIFICATION} + ? sub () { 0 } + : sub () { 1 } + ; +} + #====================================================================== # GLOBALS #====================================================================== -our $VERSION = '1.78'; +our $VERSION = '1.81'; # This would confuse some packagers $VERSION = eval $VERSION if $VERSION =~ /_/; # numify for warning-free dev releases @@ -58,6 +75,64 @@ Carp::croak "[$func] Fatal: ", @_; } +sub is_literal_value ($) { + ref $_[0] eq 'SCALAR' ? [ ${$_[0]} ] + : ( ref $_[0] eq 'REF' and ref ${$_[0]} eq 'ARRAY' ) ? [ @${ $_[0] } ] + : undef; +} + +# FIXME XSify - this can be done so much more efficiently +sub is_plain_value ($) { + no strict 'refs'; + ! length ref $_[0] ? \($_[0]) + : ( + ref $_[0] eq 'HASH' and keys %{$_[0]} == 1 + and + exists $_[0]->{-value} + ) ? \($_[0]->{-value}) + : ( + # reuse @_ for even moar speedz + defined ( $_[1] = Scalar::Util::blessed $_[0] ) + and + # deliberately not using Devel::OverloadInfo - the checks we are + # intersted in are much more limited than the fullblown thing, and + # this is a very hot piece of code + ( + # simply using ->can('(""') can leave behind stub methods that + # break actually using the overload later (see L<perldiag/Stub + # found while resolving method "%s" overloading "%s" in package + # "%s"> and the source of overload::mycan()) + # + # either has stringification which DBI SHOULD prefer out of the box + grep { *{ (qq[${_}::(""]) }{CODE} } @{ $_[2] = mro::get_linear_isa( $_[1] ) } + or + # has nummification or boolification, AND fallback is *not* disabled + ( + SQL::Abstract::_ENV_::DETECT_AUTOGENERATED_STRINGIFICATION + and + ( + grep { *{"${_}::(0+"}{CODE} } @{$_[2]} + or + grep { *{"${_}::(bool"}{CODE} } @{$_[2]} + ) + and + ( + # no fallback specified at all + ! ( ($_[3]) = grep { *{"${_}::()"}{CODE} } @{$_[2]} ) + or + # fallback explicitly undef + ! defined ${"$_[3]::()"} + or + # explicitly true + !! ${"$_[3]::()"} + ) + ) + ) + ) ? \($_[0]) + : undef; +} + + #====================================================================== # NEW @@ -417,9 +492,15 @@ my ($sql, @bind) = $self->$method($where, $logic); - # DBIx::Class directly calls _recurse_where in scalar context, so - # we must implement it, even if not in the official API - return wantarray ? ($sql, @bind) : $sql; + # DBIx::Class used to call _recurse_where in scalar context + # something else might too... + if (wantarray) { + return ($sql, @bind); + } + else { + belch "Calling _recurse_where in scalar context is deprecated and will go away before 2.0"; + return $sql; + } } @@ -439,7 +520,10 @@ my (@sql_clauses, @all_bind); # need to use while() so can shift() for pairs - while (my $el = shift @clauses) { + while (@clauses) { + my $el = shift @clauses; + + $el = undef if (defined $el and ! length $el); # switch according to kind of $el and get corresponding ($sql, @bind) my ($sql, @bind) = $self->_SWITCH_refkind($el, { @@ -457,10 +541,12 @@ SCALARREF => sub { ($$el); }, - SCALAR => sub {# top-level arrayref with scalars, recurse in pairs - $self->_recurse_where({$el => shift(@clauses)})}, + SCALAR => sub { + # top-level arrayref with scalars, recurse in pairs + $self->_recurse_where({$el => shift(@clauses)}) + }, - UNDEF => sub {puke "not supported : UNDEF in arrayref" }, + UNDEF => sub {puke "Supplying an empty left hand side argument is not supported in array-pairs" }, }); if ($sql) { @@ -514,11 +600,20 @@ $s = "($s)" unless ( List::Util::first {$op =~ $_->{regex}} @{$self->{unary_ops}} or - defined($self->{_nested_func_lhs}) && ($self->{_nested_func_lhs} eq $k) + ( defined $self->{_nested_func_lhs} and $self->{_nested_func_lhs} eq $k ) ); ($s, @b); } else { + if (! length $k) { + if (is_literal_value ($v) ) { + belch 'Hash-pairs consisting of an empty string with a literal are deprecated, and will be removed in 2.0: use -and => [ $literal ] instead'; + } + else { + puke "Supplying an empty left hand side argument is not supported in hash-pairs"; + } + } + my $method = $self->_METHOD_FOR_refkind("_where_hashpair", $v); $self->$method($k, $v); } @@ -534,6 +629,11 @@ sub _where_unary_op { my ($self, $op, $rhs) = @_; + # top level special ops are illegal in general + # this includes the -ident/-value ops (dual purpose unary and special) + puke "Illegal use of top-level '-$op'" + if ! defined $self->{_nested_func_lhs} and List::Util::first {$op =~ $_->{regex}} @{$self->{special_ops}}; + if (my $op_entry = List::Util::first {$op =~ $_->{regex}} @{$self->{unary_ops}}) { my $handler = $op_entry->{handler}; @@ -558,8 +658,8 @@ my ($sql, @bind) = $self->_SWITCH_refkind ($rhs, { SCALAR => sub { - puke "Illegal use of top-level '$op'" - unless $self->{_nested_func_lhs}; + puke "Illegal use of top-level '-$op'" + unless defined $self->{_nested_func_lhs}; return ( $self->_convert('?'), @@ -667,8 +767,8 @@ sub _where_op_IDENT { my $self = shift; my ($op, $rhs) = splice @_, -2; - if (ref $rhs) { - puke "-$op takes a single scalar argument (a quotable identifier)"; + if (! defined $rhs or length ref $rhs) { + puke "-$op requires a single plain scalar argument (a quotable identifier)"; } # in case we are called as a top level special op (no '=') @@ -689,9 +789,17 @@ # in case we are called as a top level special op (no '=') my $lhs = shift; + # special-case NULL + if (! defined $rhs) { + return defined $lhs + ? $self->_convert($self->_quote($lhs)) . ' IS NULL' + : undef + ; + } + my @bind = $self->_bindtype ( - ($lhs || $self->{_nested_func_lhs}), + ( defined $lhs ? $lhs : $self->{_nested_func_lhs} ), $rhs, ) ; @@ -742,7 +850,10 @@ my ($self, $k, $v, $logic) = @_; $logic ||= 'and'; - local $self->{_nested_func_lhs} = $self->{_nested_func_lhs}; + local $self->{_nested_func_lhs} = defined $self->{_nested_func_lhs} + ? $self->{_nested_func_lhs} + : $k + ; my ($all_sql, @all_bind); @@ -765,6 +876,11 @@ # so that -not_foo works correctly $op =~ s/^not_/NOT /i; + # another retarded special case: foo => { $op => { -value => undef } } + if (ref $val eq 'HASH' and keys %$val == 1 and exists $val->{-value} and ! defined $val->{-value} ) { + $val = undef; + } + my ($sql, @bind); # CASE: col-value logic modifiers @@ -816,10 +932,6 @@ }, FALLBACK => sub { # CASE: col => {op/func => $stuff} - - # retain for proper column type bind - $self->{_nested_func_lhs} ||= $k; - ($sql, @bind) = $self->_where_unary_op ($op, $val); $sql = join (' ', @@ -1015,7 +1127,6 @@ my ($func, $arg, @rest) = %$val; puke ("Only simple { -func => arg } functions accepted as sub-arguments to BETWEEN") if (@rest or $func !~ /^ \- (.+)/x); - local $self->{_nested_func_lhs} = $k; $self->_where_unary_op ($1 => $arg); }, FALLBACK => sub { @@ -1073,7 +1184,6 @@ my ($func, $arg, @rest) = %$val; puke ("Only simple { -func => arg } functions accepted as sub-arguments to IN") if (@rest or $func !~ /^ \- (.+)/x); - local $self->{_nested_func_lhs} = $k; $self->_where_unary_op ($1 => $arg); }, UNDEF => sub { @@ -1132,8 +1242,29 @@ # adding them back in the corresponding method sub _open_outer_paren { my ($self, $sql) = @_; - $sql = $1 while $sql =~ /^ \s* \( (.*) \) \s* $/xs; - return $sql; + + while ( my ($inner) = $sql =~ /^ \s* \( (.*) \) \s* $/xs ) { + + # there are closing parens inside, need the heavy duty machinery + # to reevaluate the extraction starting from $sql (full reevaluation) + if ( $inner =~ /\)/ ) { + require Text::Balanced; + + my (undef, $remainder) = do { + # idiotic design - writes to $@ but *DOES NOT* throw exceptions + local $@; + Text::Balanced::extract_bracketed( $sql, '()', qr/\s*/ ); + }; + + # the entire expression needs to be a balanced bracketed thing + # (after an extract no remainder sans trailing space) + last if defined $remainder and $remainder =~ /\S/; + } + + $sql = $inner; + } + + $sql; } @@ -1262,10 +1393,11 @@ else { puke "Unsupported quote_char format: $_[0]->{quote_char}"; } + my $esc = $_[0]->{escape_char} || $r; # parts containing * are naturally unquoted return join( $_[0]->{name_sep}||'', map - { $_ eq '*' ? $_ : $l . $_ . $r } + { $_ eq '*' ? $_ : do { (my $n = $_) =~ s/(\Q$esc\E|\Q$r\E)/$esc$1/g; $l . $n . $r } } ( $_[0]->{name_sep} ? split (/\Q$_[0]->{name_sep}\E/, $_[1] ) : $_[1] ) ); } @@ -1624,7 +1756,7 @@ my %data = ( name => 'Bill', - date_entered => \["to_date(?,'MM/DD/YYYY')", "03/02/2003"], + date_entered => \[ "to_date(?,'MM/DD/YYYY')", "03/02/2003" ], ); The first value in the array is the actual SQL. Any other values are @@ -1676,16 +1808,13 @@ Easy, eh? -=head1 FUNCTIONS +=head1 METHODS -The functions are simple. There's one for each major SQL operation, +The methods are simple. There's one for every major SQL operation, and a constructor you use first. The arguments are specified in a -similar order to each function (table, then fields, then a where +similar order for each method (table, then fields, then a where clause) to try and simplify things. - - - =head2 new(option => 'value') The C<new()> function takes a list of options and values, and returns @@ -1828,7 +1957,7 @@ sub called C<bind_fields()> or something and reuse it repeatedly. You still get a layer of abstraction over manual SQL specification. -Note that if you set L</bindtype> to C<columns>, the C<\[$sql, @bind]> +Note that if you set L</bindtype> to C<columns>, the C<\[ $sql, @bind ]> construct (see L</Literal SQL with placeholders and bind values (subqueries)>) will expect the bind values in this format. @@ -1850,6 +1979,21 @@ Quoting is useful if you have tables or columns names that are reserved words in your database's SQL dialect. +=item escape_char + +This is the character that will be used to escape L</quote_char>s appearing +in an identifier before it has been quoted. + +The parameter default in case of a single L</quote_char> character is the quote +character itself. + +When opening-closing-style quoting is used (L</quote_char> is an arrayref) +this parameter defaults to the B<closing (right)> L</quote_char>. Occurences +of the B<opening (left)> L</quote_char> within the identifier are currently left +untouched. The default for opening-closing-style quotes may change in future +versions, thus you are B<strongly encouraged> to specify the escape character +explicitly. + =item name_sep This is the character that separates a table and column name. It is @@ -2032,6 +2176,86 @@ You get the idea. Strings get their case twiddled, but everything else remains verbatim. +=head1 EXPORTABLE FUNCTIONS + +=head2 is_plain_value + +Determines if the supplied argument is a plain value as understood by this +module: + +=over + +=item * The value is C<undef> + +=item * The value is a non-reference + +=item * The value is an object with stringification overloading + +=item * The value is of the form C<< { -value => $anything } >> + +=back + +On failure returns C<undef>, on sucess returns a B<scalar> reference +to the original supplied argument. + +=over + +=item * Note + +The stringification overloading detection is rather advanced: it takes +into consideration not only the presence of a C<""> overload, but if that +fails also checks for enabled +L<autogenerated versions of C<"">|overload/Magic Autogeneration>, based +on either C<0+> or C<bool>. + +Unfortunately testing in the field indicates that this +detection B<< may tickle a latent bug in perl versions before 5.018 >>, +but only when very large numbers of stringifying objects are involved. +At the time of writing ( Sep 2014 ) there is no clear explanation of +the direct cause, nor is there a manageably small test case that reliably +reproduces the problem. + +If you encounter any of the following exceptions in B<random places within +your application stack> - this module may be to blame: + + Operation "ne": no method found, + left argument in overloaded package <something>, + right argument in overloaded package <something> + +or perhaps even + + Stub found while resolving method "???" overloading """" in package <something> + +If you fall victim to the above - please attempt to reduce the problem +to something that could be sent to the L<SQL::Abstract developers +|DBIx::Class/GETTING HELP/SUPPORT> +(either publicly or privately). As a workaround in the meantime you can +set C<$ENV{SQLA_ISVALUE_IGNORE_AUTOGENERATED_STRINGIFICATION}> to a true +value, which will most likely eliminate your problem (at the expense of +not being able to properly detect exotic forms of stringification). + +This notice and environment variable will be removed in a future version, +as soon as the underlying problem is found and a reliable workaround is +devised. + +=back + +=head2 is_literal_value + +Determines if the supplied argument is a literal value as understood by this +module: + +=over + +=item * C<\$sql_string> + +=item * C<\[ $sql_string, @bind_values ]> + +=back + +On failure returns C<undef>, on sucess returns an B<array> reference +containing the unpacked version of the supplied literal SQL and bind values. + =head1 WHERE CLAUSES =head2 Introduction @@ -2156,7 +2380,7 @@ @bind = ('2', '5', 'nwiger'); If you want to include literal SQL (with or without bind values), just use a -scalar reference or array reference as the value: +scalar reference or reference to an arrayref as the value: my %where = ( date_entered => { '>' => \["to_date(?, 'MM/DD/YYYY')", "11/26/2008"] }, @@ -2165,7 +2389,7 @@ Which would generate: - $stmt = "WHERE date_entered > "to_date(?, 'MM/DD/YYYY') AND date_expires < now()"; + $stmt = "WHERE date_entered > to_date(?, 'MM/DD/YYYY') AND date_expires < now()"; @bind = ('11/26/2008'); @@ -2179,7 +2403,7 @@ Because, in Perl you I<can't> do this: - priority => { '!=', 2, '!=', 1 } + priority => { '!=' => 2, '!=' => 1 } As the second C<!=> key will obliterate the first. The solution is to use the special C<-modifier> form inside an arrayref: @@ -2371,10 +2595,10 @@ That would yield: - WHERE ( user = ? AND ( - ( workhrs > ? AND geo = ? ) - OR ( workhrs < ? OR geo = ? ) - ) ) + $stmt = "WHERE ( user = ? + AND ( ( workhrs > ? AND geo = ? ) + OR ( workhrs < ? OR geo = ? ) ) )"; + @bind = ('nwiger', '20', 'ASIA', '50', 'EURO'); =head3 Algebraic inconsistency, for historical reasons @@ -2495,7 +2719,7 @@ in Postgres you can use something like this: my %where = ( - date_column => \[q/= date '2008-09-30' - ?::integer/, 10/] + date_column => \[ "= date '2008-09-30' - ?::integer", 10 ] ) This would create: @@ -2504,15 +2728,16 @@ @bind = ('10'); Note that you must pass the bind values in the same format as they are returned -by L</where>. That 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 (including references and blessed references), -L<SQL::Abstract> will simply pass it through intact. So if C<bindtype> is set -to C<columns> the above example will look like: +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 +(including references and blessed references), L<SQL::Abstract> will simply +pass it through intact. So if C<bindtype> is set to C<columns> the above +example will look like: my %where = ( - date_column => \[q/= date '2008-09-30' - ?::integer/, [ dummy => 10 ]/] + date_column => \[ "= date '2008-09-30' - ?::integer", [ {} => 10 ] ] ) Literal SQL is especially useful for nesting parenthesized clauses in the @@ -2719,14 +2944,14 @@ the expected return is C<< ($sql, @bind) >>. When supplied with a method name, it is simply called on the -L<SQL::Abstract/> object as: +L<SQL::Abstract> 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 + $op is the part that matched the handler regex $arg is the RHS When supplied with a coderef, it is called as: @@ -2795,7 +3020,7 @@ the expected return is C<< $sql >>. When supplied with a method name, it is simply called on the -L<SQL::Abstract/> object as: +L<SQL::Abstract> object as: $self->$method_name ($op, $arg) @@ -2876,13 +3101,27 @@ use these three modules together to write complex database query apps in under 50 lines. -=head1 REPO +=head1 HOW TO CONTRIBUTE + +Contributions are always welcome, in all usable forms (we especially +welcome documentation improvements). The delivery methods include git- +or unified-diff formatted patches, GitHub pull requests, or plain bug +reports either via RT or the Mailing list. Contributors are generally +granted full access to the official repository after their first several +patches pass successful review. + +This project is maintained in a git repository. The code and related tools are +accessible at the following locations: =over -=item * gitweb: L<http://git.shadowcat.co.uk/gitweb/gitweb.cgi?p=dbsrgits/SQL-Abstract.git> +=item * Official repo: L<git://git.shadowcat.co.uk/dbsrgits/SQL-Abstract.git> + +=item * Official gitweb: L<http://git.shadowcat.co.uk/gitweb/gitweb.cgi?p=dbsrgits/SQL-Abstract.git> + +=item * GitHub mirror: L<https://github.com/dbsrgits/sql-abstract> -=item * git: L<git://git.shadowcat.co.uk/dbsrgits/SQL-Abstract.git> +=item * Authorized committers: L<ssh://dbsrg...@git.shadowcat.co.uk/SQL-Abstract.git> =back @@ -2903,7 +3142,7 @@ =item * -support for literal SQL through the C<< \ [$sql, bind] >> syntax. +support for literal SQL through the C<< \ [ $sql, @bind ] >> syntax. =item * diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/SQL-Abstract-1.78/t/01generate.t new/SQL-Abstract-1.81/t/01generate.t --- old/SQL-Abstract-1.78/t/01generate.t 2014-04-12 10:58:04.000000000 +0200 +++ new/SQL-Abstract-1.81/t/01generate.t 2014-09-25 13:43:08.000000000 +0200 @@ -559,6 +559,21 @@ bind => [], warns => qr/\QSupplying an undefined argument to 'NOT LIKE' is deprecated/, }, + { + func => 'select', + args => ['`test``table`', ['`test``column`']], + stmt => 'SELECT `test``column` FROM `test``table`', + stmt_q => 'SELECT ```test````column``` FROM ```test````table```', + bind => [], + }, + { + func => 'select', + args => ['`test\\`table`', ['`test`\\column`']], + stmt => 'SELECT `test`\column` FROM `test\`table`', + stmt_q => 'SELECT `\`test\`\\\\column\`` FROM `\`test\\\\\`table\``', + esc => '\\', + bind => [], + }, ); # check is( not) => undef @@ -644,14 +659,139 @@ } for ('', '-'); # with and without - } +# check emtpty-lhs in a hashpair and arraypair +for my $lhs (undef, '') { + no warnings 'uninitialized'; + +## +## hard exceptions - never worked + for my $where_arg ( + ( map { $_, { @$_ } } + [ $lhs => "foo" ], + [ $lhs => { "=" => "bozz" } ], + [ $lhs => { "=" => \"bozz" } ], + [ $lhs => { -max => \"bizz" } ], + ), + [ -and => { $lhs => "baz" }, bizz => "buzz" ], + [ foo => "bar", { $lhs => "baz" }, bizz => "buzz" ], + { foo => "bar", -or => { $lhs => "baz" } }, + + # the hashref forms of these work sadly - check for warnings below + { foo => "bar", -and => [ $lhs => \"baz" ], bizz => "buzz" }, + { foo => "bar", -or => [ $lhs => \"baz" ], bizz => "buzz" }, + [ foo => "bar", [ $lhs => \"baz" ], bizz => "buzz" ], + [ foo => "bar", $lhs => \"baz", bizz => "buzz" ], + [ foo => "bar", $lhs => \["baz"], bizz => "buzz" ], + [ $lhs => \"baz" ], + [ $lhs => \["baz"] ], + + # except for this one, that is automagically arrayified + { foo => "bar", -or => { $lhs => \"baz" }, bizz => "buzz" }, + ) { + push @tests, { + func => 'where', + args => [ $where_arg ], + throws => qr/\QSupplying an empty left hand side argument is not supported/, + }; + } + +## +## deprecations - sorta worked, likely abused by folks + for my $where_arg ( + # the arrayref forms of this never worked and throw above + { foo => "bar", -and => { $lhs => \"baz" }, bizz => "buzz" }, + { foo => "bar", $lhs => \"baz", bizz => "buzz" }, + { foo => "bar", $lhs => \["baz"], bizz => "buzz" }, + ) { + push @tests, { + func => 'where', + args => [ $where_arg ], + stmt => 'WHERE baz AND bizz = ? AND foo = ?', + stmt_q => 'WHERE baz AND `bizz` = ? AND `foo` = ?', + bind => [qw( buzz bar )], + warns => qr/\QHash-pairs consisting of an empty string with a literal are deprecated/, + }; + } + + for my $where_arg ( + { $lhs => \"baz" }, + { $lhs => \["baz"] }, + ) { + push @tests, { + func => 'where', + args => [ $where_arg ], + stmt => 'WHERE baz', + stmt_q => 'WHERE baz', + bind => [], + warns => qr/\QHash-pairs consisting of an empty string with a literal are deprecated/, + } + } +} + +# check false lhs, silly but possible +{ + for my $where_arg ( + [ { 0 => "baz" }, bizz => "buzz", foo => "bar" ], + [ -or => { foo => "bar", -or => { 0 => "baz" }, bizz => "buzz" } ], + ) { + push @tests, { + func => 'where', + args => [ $where_arg ], + stmt => 'WHERE 0 = ? OR bizz = ? OR foo = ?', + stmt_q => 'WHERE `0` = ? OR `bizz` = ? OR `foo` = ?', + bind => [qw( baz buzz bar )], + }; + } + + for my $where_arg ( + { foo => "bar", -and => [ 0 => \"= baz" ], bizz => "buzz" }, + { foo => "bar", -or => [ 0 => \"= baz" ], bizz => "buzz" }, + + { foo => "bar", -and => { 0 => \"= baz" }, bizz => "buzz" }, + { foo => "bar", -or => { 0 => \"= baz" }, bizz => "buzz" }, + + { foo => "bar", 0 => \"= baz", bizz => "buzz" }, + { foo => "bar", 0 => \["= baz"], bizz => "buzz" }, + ) { + push @tests, { + func => 'where', + args => [ $where_arg ], + stmt => 'WHERE 0 = baz AND bizz = ? AND foo = ?', + stmt_q => 'WHERE `0` = baz AND `bizz` = ? AND `foo` = ?', + bind => [qw( buzz bar )], + }; + } + + for my $where_arg ( + [ -and => [ 0 => \"= baz" ], bizz => "buzz", foo => "bar" ], + [ -or => [ 0 => \"= baz" ], bizz => "buzz", foo => "bar" ], + [ 0 => \"= baz", bizz => "buzz", foo => "bar" ], + [ 0 => \["= baz"], bizz => "buzz", foo => "bar" ], + ) { + push @tests, { + func => 'where', + args => [ $where_arg ], + stmt => 'WHERE 0 = baz OR bizz = ? OR foo = ?', + stmt_q => 'WHERE `0` = baz OR `bizz` = ? OR `foo` = ?', + bind => [qw( buzz bar )], + }; + } +} + for my $t (@tests) { my $new = $t->{new} || {}; for my $quoted (0, 1) { - my $maker = SQL::Abstract->new(%$new, $quoted - ? (quote_char => '`', name_sep => '.') - : () + my $maker = SQL::Abstract->new( + %$new, + ($quoted ? ( + quote_char => '`', + name_sep => '.', + ( $t->{esc} ? ( + escape_char => $t->{esc}, + ) : ()) + ) : ()) ); my($stmt, @bind); diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/SQL-Abstract-1.78/t/04modifiers.t new/SQL-Abstract-1.81/t/04modifiers.t --- old/SQL-Abstract-1.78/t/04modifiers.t 2014-04-12 10:58:04.000000000 +0200 +++ new/SQL-Abstract-1.81/t/04modifiers.t 2014-07-17 13:21:26.000000000 +0200 @@ -21,10 +21,10 @@ * Modifiers are respected in both hashrefs and arrayrefs (with the obvious limitation of one modifier type per hahsref) - * When in condition context i.e. where => { -or { a = 1 } }, each modifier + * When in condition context i.e. where => { -or => { a = 1 } }, each modifier affects only the immediate element following it. * When in column multi-condition context i.e. - where => { x => { '!=', [-and, [qw/1 2 3/]] } }, a modifier affects the + where => { x => { '!=', [-and => [qw/1 2 3/]] } }, a modifier affects the OUTER ARRAYREF if and only if it is the first element of said ARRAYREF =cut diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/SQL-Abstract-1.78/t/05in_between.t new/SQL-Abstract-1.81/t/05in_between.t --- old/SQL-Abstract-1.78/t/05in_between.t 2014-04-12 10:58:04.000000000 +0200 +++ new/SQL-Abstract-1.81/t/05in_between.t 2014-10-25 12:43:32.000000000 +0200 @@ -174,6 +174,17 @@ bind => [], test => '-in multi-line subquery test', }, + + # check that the outer paren opener is not too agressive + # note: this syntax *is not legal* on SQLite (maybe others) + # see end of https://rt.cpan.org/Ticket/Display.html?id=99503 + { + where => { foo => { -in => \ '(SELECT 1) UNION (SELECT 2)' } }, + stmt => 'WHERE foo IN ( (SELECT 1) UNION (SELECT 2) )', + bind => [], + test => '-in paren-opening works on balanced pairs only', + }, + { where => { customer => { -in => \[ @@ -266,6 +277,17 @@ throws => qr/Argument passed to the 'IN' operator can not be undefined/, test => '-in with undef argument', }, + + { + where => { -in => [42] }, + throws => qr/Illegal use of top-level '-in'/, + test => 'Top level -in', + }, + { + where => { -between => [42, 69] }, + throws => qr/Illegal use of top-level '-between'/, + test => 'Top level -between', + }, ); for my $case (@in_between_tests) { diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/SQL-Abstract-1.78/t/21op_ident.t new/SQL-Abstract-1.81/t/21op_ident.t --- old/SQL-Abstract-1.78/t/21op_ident.t 2013-12-26 11:14:22.000000000 +0100 +++ new/SQL-Abstract-1.81/t/21op_ident.t 2014-09-21 01:06:49.000000000 +0200 @@ -2,6 +2,7 @@ use warnings; use Test::More; +use Test::Exception; use SQL::Abstract; use SQL::Abstract::Test import => [qw/is_same_sql_bind/]; @@ -12,6 +13,10 @@ name_sep => $q ? '.' : '', ); + throws_ok { + $sql_maker->where({ foo => { -ident => undef } }) + } qr/-ident requires a single plain scalar argument/; + my ($sql, @bind) = $sql_maker->select ('artist', '*', { 'artist.name' => { -ident => 'artist.pseudonym' } } ); is_same_sql_bind ( $sql, diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/SQL-Abstract-1.78/t/22op_value.t new/SQL-Abstract-1.81/t/22op_value.t --- old/SQL-Abstract-1.78/t/22op_value.t 2013-12-26 11:14:22.000000000 +0100 +++ new/SQL-Abstract-1.81/t/22op_value.t 2014-07-17 13:39:45.000000000 +0200 @@ -40,6 +40,38 @@ ) ], ); + + { + local $SIG{__WARN__} = sub { warn @_ unless $_[0] =~ /Supplying an undefined argument to '(?:NOT )?LIKE'/ }; + + ($sql, @bind) = $sql_maker->where ({ + c1 => undef, + c2 => { -value => undef }, + c3 => { '=' => { -value => undef } }, + c4 => { '!=' => { -value => undef } }, + c5 => { '<>' => { -value => undef } }, + c6 => { '-like' => { -value => undef } }, + c7 => { '-not_like' => { -value => undef } }, + c8 => { 'is' => { -value => undef } }, + c9 => { 'is not' => { -value => undef } }, + }); + + is_same_sql_bind ( + $sql, + \@bind, + "WHERE ${q}c1${q} IS NULL + AND ${q}c2${q} IS NULL + AND ${q}c3${q} IS NULL + AND ${q}c4${q} IS NOT NULL + AND ${q}c5${q} IS NOT NULL + AND ${q}c6${q} IS NULL + AND ${q}c7${q} IS NOT NULL + AND ${q}c8${q} IS NULL + AND ${q}c9${q} IS NOT NULL + ", + [], + ); + } }} done_testing; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/SQL-Abstract-1.78/t/23_is_X_value.t new/SQL-Abstract-1.81/t/23_is_X_value.t --- old/SQL-Abstract-1.78/t/23_is_X_value.t 1970-01-01 01:00:00.000000000 +0100 +++ new/SQL-Abstract-1.81/t/23_is_X_value.t 2014-09-26 03:58:42.000000000 +0200 @@ -0,0 +1,252 @@ +use warnings; +use strict; + +use Test::More; +use Test::Exception; +use Scalar::Util 'refaddr'; +use Storable 'nfreeze'; + +BEGIN { $ENV{SQLA_ISVALUE_IGNORE_AUTOGENERATED_STRINGIFICATION} = 0 } + +use SQL::Abstract qw(is_plain_value is_literal_value); + +# fallback setting is inheriting starting p5 50853fa9 (run up to 5.17.0) +use constant OVERLOAD_FALLBACK_INHERITS => ( ($] < 5.017) ? 0 : 1 ); +use constant STRINGIFIER_CAN_RETURN_IVS => ( ($] < 5.008) ? 0 : 1 ); + +{ + package # hideee + SQLATest::SillyBool; + + use overload + # *DELIBERATELY* unspecified + #fallback => 1, + bool => sub { ${$_[0]} }, + ; + + package # hideee + SQLATest::SillyBool::Subclass; + + our @ISA = 'SQLATest::SillyBool'; +} + +{ + package # hideee + SQLATest::SillyInt; + + use overload + # *DELIBERATELY* unspecified + #fallback => 1, + '0+' => sub { ${$_[0]} }, + ; + + package # hideee + SQLATest::SillyInt::Subclass; + + our @ISA = 'SQLATest::SillyInt'; +} + +{ + package # hideee + SQLATest::SillierInt; + + use overload + fallback => 0, + ; + + package # hideee + SQLATest::SillierInt::Subclass; + + use overload + '0+' => sub { ${$_[0]} }, + '+' => sub { ${$_[0]} + $_[1] }, + ; + + our @ISA = 'SQLATest::SillierInt'; +} + +{ + package # hideee + SQLATest::AnalInt; + + use overload + fallback => 0, + '0+' => sub { ${$_[0]} }, + ; + + package # hideee + SQLATest::AnalInt::Subclass; + + use overload + '0+' => sub { ${$_[0]} }, + ; + + our @ISA = 'SQLATest::AnalInt'; +} + +{ + package # hidee + SQLATest::ReasonableInt; + + # make it match JSON::PP::Boolean + use overload + '0+' => sub { ${$_[0]} }, + '++' => sub { $_[0] = ${$_[0]} + 1 }, + '--' => sub { $_[0] = ${$_[0]} - 1 }, + fallback => 1, + ; + + package # hideee + SQLATest::ReasonableInt::Subclass; + + our @ISA = 'SQLATest::ReasonableInt'; +} + +{ + package # hidee + SQLATest::ReasonableString; + + # somewhat like DateTime + use overload + 'fallback' => 1, + '""' => sub { "${$_[0]}" }, + '-' => sub { ${$_[0]} - $_[1] }, + '+' => sub { ${$_[0]} + $_[1] }, + ; + + package # hideee + SQLATest::ReasonableString::Subclass; + + our @ISA = 'SQLATest::ReasonableString'; +} + +for my $case ( + { class => 'SQLATest::SillyBool', can_math => 0, should_str => 1 }, + { class => 'SQLATest::SillyBool::Subclass', can_math => 0, should_str => 1 }, + { class => 'SQLATest::SillyInt', can_math => 0, should_str => 1 }, + { class => 'SQLATest::SillyInt::Subclass', can_math => 0, should_str => 1 }, + { class => 'SQLATest::SillierInt', can_math => 0, should_str => 0 }, + { class => 'SQLATest::SillierInt::Subclass',can_math => 1, should_str => (OVERLOAD_FALLBACK_INHERITS ? 0 : 1) }, + { class => 'SQLATest::AnalInt', can_math => 0, should_str => 0 }, + { class => 'SQLATest::AnalInt::Subclass', can_math => 0, should_str => (OVERLOAD_FALLBACK_INHERITS ? 0 : 1) }, + { class => 'SQLATest::ReasonableInt', can_math => 1, should_str => 1 }, + { class => 'SQLATest::ReasonableInt::Subclass', can_math => 1, should_str => 1 }, + { class => 'SQLATest::ReasonableString', can_math => 1, should_str => 1 }, + { class => 'SQLATest::ReasonableString::Subclass',can_math => 1, should_str => 1 }, +) { + + my $num = bless( \do { my $foo = 42 }, $case->{class} ); + + my $can_str = eval { "$num" eq 42 } || 0; + + ok ( + !($can_str xor $case->{should_str}), + "should_str setting for $case->{class} matches perl behavior", + ) || diag explain { %$case, can_str => $can_str }; + + my $can_math = eval { ($num + 1) == 43 } ? 1 : 0; + + ok ( + !($can_math xor $case->{can_math}), + "can_math setting for $case->{class} matches perl behavior", + ) || diag explain { %$case, actual_can_math => $can_math }; + + my $can_cmp = eval { my $dum = ($num eq "nope"); 1 } || 0; + + for (1,2) { + + if ($can_str) { + + ok $num, 'bool ctx works'; + + if (STRINGIFIER_CAN_RETURN_IVS and $can_cmp) { + is_deeply( + is_plain_value $num, + \$num, + "stringification detected on $case->{class}", + ) || diag explain $case; + } + else { + # is_deeply does not do nummify/stringify cmps properly + # but we can always compare the ice + ok( + ( nfreeze( is_plain_value $num ) eq nfreeze( \$num ) ), + "stringification without cmp capability detected on $case->{class}" + ) || diag explain $case; + } + + is ( + refaddr( ${is_plain_value($num)} ), + refaddr $num, + "Same reference (blessed object) returned", + ); + } + else { + is( is_plain_value($num), undef, "non-stringifiable $case->{class} object detected" ) + || diag explain $case; + } + + if ($case->{can_math}) { + is ($num+1, 43); + } + } +} + +lives_ok { + my $num = bless( \do { my $foo = 23 }, 'SQLATest::ReasonableInt' ); + cmp_ok(++$num, '==', 24, 'test overloaded object compares correctly'); + cmp_ok(--$num, 'eq', 23, 'test overloaded object compares correctly'); + is_deeply( + is_plain_value $num, + \23, + 'fallback stringification detected' + ); + cmp_ok(--$num, 'eq', 22, 'test overloaded object compares correctly'); + cmp_ok(++$num, '==', 23, 'test overloaded object compares correctly'); +} 'overload testing lives'; + + +is_deeply + is_plain_value { -value => [] }, + \[], + '-value recognized' +; + +for ([], {}, \'') { + is + is_plain_value $_, + undef, + 'nonvalues correctly recognized' + ; +} + +for (undef, { -value => undef }) { + is_deeply + is_plain_value $_, + \undef, + 'NULL -value recognized' + ; +} + +is_deeply + is_literal_value \'sql', + [ 'sql' ], + 'literal correctly recognized and unpacked' +; + +is_deeply + is_literal_value \[ 'sql', 'bind1', [ {} => 'bind2' ] ], + [ 'sql', 'bind1', [ {} => 'bind2' ] ], + 'literal with binds correctly recognized and unpacked' +; + + +for ([], {}, \'', undef) { + is + is_literal_value { -ident => $_ }, + undef, + 'illegal -ident does not trip up detection' + ; +} + +done_testing; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/SQL-Abstract-1.78/t/dbic/bulk-insert.t new/SQL-Abstract-1.81/t/dbic/bulk-insert.t --- old/SQL-Abstract-1.78/t/dbic/bulk-insert.t 2012-03-09 02:04:01.000000000 +0100 +++ new/SQL-Abstract-1.81/t/dbic/bulk-insert.t 2014-10-05 23:02:25.000000000 +0200 @@ -4,9 +4,12 @@ use Test::More; BEGIN { - # ask for a recent DBIC version to skip the 5.6.2 tests as well + # ask for a recent DBIC version to skip the 5.6 testing as well plan skip_all => 'Test temporarily requires DBIx::Class' unless eval { require DBIx::Class::Storage::Statistics; DBIx::Class->VERSION('0.08124') }; + + plan skip_all => 'Test does not properly work with the pre-0.082800 DBIC trials' + if DBIx::Class->VERSION =~ /^0.082700\d\d/; } use DBIx::Class::Storage::Debug::PrettyPrint; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/SQL-Abstract-1.78/t/dbic/no-repeats.t new/SQL-Abstract-1.81/t/dbic/no-repeats.t --- old/SQL-Abstract-1.78/t/dbic/no-repeats.t 2012-03-09 02:04:01.000000000 +0100 +++ new/SQL-Abstract-1.81/t/dbic/no-repeats.t 2014-10-05 23:02:34.000000000 +0200 @@ -4,9 +4,12 @@ use Test::More; BEGIN { - # ask for a recent DBIC version to skip the 5.6.2 tests as well + # ask for a recent DBIC version to skip the 5.6 tests as well plan skip_all => 'Test temporarily requires DBIx::Class' unless eval { require DBIx::Class::Storage::Statistics; DBIx::Class->VERSION('0.08124') }; + + plan skip_all => 'Test does not properly work with the pre-0.082800 DBIC trials' + if DBIx::Class->VERSION =~ /^0.082700\d\d/; } use DBIx::Class::Storage::Debug::PrettyPrint; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/SQL-Abstract-1.78/t/dbic/show-progress.t new/SQL-Abstract-1.81/t/dbic/show-progress.t --- old/SQL-Abstract-1.78/t/dbic/show-progress.t 2012-03-09 02:04:01.000000000 +0100 +++ new/SQL-Abstract-1.81/t/dbic/show-progress.t 2014-10-05 23:02:42.000000000 +0200 @@ -4,9 +4,12 @@ use Test::More; BEGIN { - # ask for a recent DBIC version to skip the 5.6.2 tests as well + # ask for a recent DBIC version to skip the 5.6 tests as well plan skip_all => 'Test temporarily requires DBIx::Class' unless eval { require DBIx::Class::Storage::Statistics; DBIx::Class->VERSION('0.08124') }; + + plan skip_all => 'Test does not properly work with the pre-0.082800 DBIC trials' + if DBIx::Class->VERSION =~ /^0.082700\d\d/; } use DBIx::Class::Storage::Debug::PrettyPrint; -- To unsubscribe, e-mail: opensuse-commit+unsubscr...@opensuse.org For additional commands, e-mail: opensuse-commit+h...@opensuse.org