Merge branch 'master' into dq

diff --cc Changes
Simple merge

diff --cc lib/SQL/Abstract.pm
index 46a9e39,0bcc7d5..8f1fe83
--- 1/lib/SQL/Abstract.pm
--- 2/lib/SQL/Abstract.pm
+++ b/lib/SQL/Abstract.pm
@@@ -3,11 -3,15 +3,12 @@@ package SQL::Abstract; # see doc at en
  use Carp ();
  use List::Util ();
  use Scalar::Util ();
 -
 -#======================================================================
 -# GLOBALS
 -#======================================================================
 +use Module::Runtime qw(use_module);
 +use Moo;
 +use namespace::clean;
  
- our $VERSION  = '1.74';
+ our $VERSION  = '1.77';
+ 
  # This would confuse some packagers
  $VERSION = eval $VERSION if $VERSION =~ /_/; # numify for warning-free dev releases
  

diff --cc t/01generate.t
Simple merge

diff --cc t/02where.t
Simple merge

diff --cc t/04modifiers.t
Simple merge

diff --cc t/05in_between.t
index 51d3842,1111998..e491c5c
--- 1/t/05in_between.t
--- 2/t/05in_between.t
+++ b/t/05in_between.t
@@@ -64,6 -62,26 +62,30 @@@ my @in_between_tests = 
      bind => [],
      test => '-between with literal sql with a literal (\"\'this\' AND \'that\'")',
    },
+ 
+   # generate a set of invalid -between tests
+   ( map { {
+     where => { x => { -between => $_ } },
+     test => 'invalid -between args',
 -    throws => qr|Operator 'BETWEEN' requires either an arrayref with two defined values or expressions, or a single literal scalarref/arrayref-ref|,
++    throws => qr{
++      \QOperator 'BETWEEN' requires either an arrayref with two defined values or expressions, or a single literal scalarref/arrayref-ref\E
++        |
++      \QArgument passed to the 'BETWEEN' operator can not be undefined\E
++    }x,,
+   } } (
+     [ 1, 2, 3 ],
+     [ 1, undef, 3 ],
+     [ undef, 2, 3 ],
+     [ 1, 2, undef ],
+     [ 1, undef ],
+     [ undef, 2 ],
+     [ undef, undef ],
+     [ 1 ],
+     [ undef ],
+     [],
+     1,
+     undef,
+   )),
    {
      where => {
        start0 => { -between => [ 1, { -upper => 2 } ] },
@@@ -166,9 -190,10 +194,10 @@@
      bind => [2000],
      test => '-in POD test',
    },
+ 
    {
      where => { x => { -in => [ \['LOWER(?)', 'A' ], \'LOWER(b)', { -lower => 'c' } ] } },
 -    stmt => " WHERE ( x IN ( LOWER(?), LOWER(b), LOWER ? ) )",
 +    stmt => " WHERE ( x IN ( LOWER(?), LOWER(b), LOWER(?) ) )",
      bind => [qw/A c/],
      test => '-in with an array of function array refs with args',
    },
@@@ -184,6 -223,49 +213,35 @@@
      bind => [ 1, 2, 3 ],
      test => '-in with multiple undef elements',
    },
+   {
+     where => { a => { -in => 42 }, b => { -not_in => 42 } },
+     stmt => ' WHERE a IN ( ? ) AND b NOT IN ( ? )',
+     bind => [ 42, 42 ],
+     test => '-in, -not_in with scalar',
+   },
+   {
+     where => { a => { -in => [] }, b => { -not_in => [] } },
+     stmt => ' WHERE ( 0=1 AND 1=1 )',
+     bind => [],
+     test => '-in, -not_in with empty arrays',
+   },
+   {
 -    throws => qr/
 -      \QSQL::Abstract before v1.75 used to generate incorrect SQL \E
 -      \Qwhen the -IN operator was given an undef-containing list: \E
 -      \Q!!!AUDIT YOUR CODE AND DATA!!! (the upcoming Data::Query-based \E
 -      \Qversion of SQL::Abstract will emit the logically correct SQL \E
 -      \Qinstead of raising this exception)\E
 -    /x,
+     where => { a => { -in => [42, undef] }, b => { -not_in => [42, undef] } },
+     stmt => ' WHERE ( ( a IN ( ? ) OR a IS NULL ) AND b NOT IN ( ? ) AND b IS NOT NULL )',
+     bind => [ 42, 42 ],
+     test => '-in, -not_in with undef among elements',
+   },
+   {
 -    throws => qr/
 -      \QSQL::Abstract before v1.75 used to generate incorrect SQL \E
 -      \Qwhen the -IN operator was given an undef-containing list: \E
 -      \Q!!!AUDIT YOUR CODE AND DATA!!! (the upcoming Data::Query-based \E
 -      \Qversion of SQL::Abstract will emit the logically correct SQL \E
 -      \Qinstead of raising this exception)\E
 -    /x,
+     where => { a => { -in => [undef] }, b => { -not_in => [undef] } },
+     stmt => ' WHERE ( a IS NULL AND b IS NOT NULL )',
+     bind => [],
+     test => '-in, -not_in with just undef element',
+   },
+   {
+     where => { a => { -in => undef } },
+     throws => qr/Argument passed to the 'IN' operator can not be undefined/,
+     test => '-in with undef argument',
+   },
  );
  
  for my $case (@in_between_tests) {

diff --cc t/06order_by.t
Simple merge