X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=t%2F01generate.t;h=85a667a45d83abc0acd4ae40afa84cb7557f7747;hb=cf5b7ab163f8ac123ebc9bb1156e79646cd5bd2f;hp=273d94d805ef1284f7a9cb215f3237b087d3ad44;hpb=e4327a54f173b813987539dd166d530611e9fcf3;p=scpubgit%2FQ-Branch.git

diff --git a/t/01generate.t b/t/01generate.t
index 273d94d..85a667a 100644
--- a/t/01generate.t
+++ b/t/01generate.t
@@ -4,7 +4,7 @@ use Test::More;
 use Test::Warn;
 use Test::Exception;
 
-use SQL::Abstract::Test import => [qw( is_same_sql_bind diag_where dumper )];
+use SQL::Abstract::Test import => [qw(is_same_sql_bind diag_where dumper)];
 
 use SQL::Abstract;
 
@@ -16,7 +16,6 @@ use SQL::Abstract;
 #
 #################
 
-
 my @tests = (
       {
               func   => 'select',
@@ -75,6 +74,14 @@ my @tests = (
               bind   => ['boom']
       },
       {
+              # this is maybe wrong but a single arg doesn't get quoted
+              func   => 'select',
+              args   => ['test', 'id', { a => { '!=', 'boom' } }],
+              stmt   => 'SELECT id FROM test WHERE ( a != ? )',
+              stmt_q => 'SELECT id FROM `test` WHERE ( `a` != ? )',
+              bind   => ['boom']
+      },
+      {
               func   => 'update',
               args   => ['test', {a => 'boom'}, {a => undef}],
               stmt   => 'UPDATE test SET a = ? WHERE ( a IS NULL )',
@@ -83,6 +90,13 @@ my @tests = (
       },
       {
               func   => 'update',
+              args   => ['test', {a => undef }, {a => 'boom'}],
+              stmt   => 'UPDATE test SET a = ? WHERE ( a = ? )',
+              stmt_q => 'UPDATE `test` SET `a` = ? WHERE ( `a` = ? )',
+              bind   => [undef,'boom']
+      },
+      {
+              func   => 'update',
               args   => ['test', {a => 'boom'}, { a => {'!=', "bang" }} ],
               stmt   => 'UPDATE test SET a = ? WHERE ( a != ? )',
               stmt_q => 'UPDATE `test` SET `a` = ? WHERE ( `a` != ? )',
@@ -128,10 +142,10 @@ my @tests = (
       },
       {
               func   => 'insert',
-              args   => ['test', [qw/1 2 3 4 5/]],
-              stmt   => 'INSERT INTO test VALUES (?, ?, ?, ?, ?)',
-              stmt_q => 'INSERT INTO `test` VALUES (?, ?, ?, ?, ?)',
-              bind   => [qw/1 2 3 4 5/],
+              args   => ['test', [1..30]],
+              stmt   => 'INSERT INTO test VALUES ('.join(', ', ('?')x30).')',
+              stmt_q => 'INSERT INTO `test` VALUES ('.join(', ', ('?')x30).')',
+              bind   => [1..30],
       },
       {
               func   => 'insert',
@@ -440,6 +454,14 @@ my @tests = (
               func   => 'update',
               new    => {bindtype => 'columns'},
               args   => ['test', {a => 1, b => \["to_date(?, 'MM/DD/YY')", [{dummy => 1} => '02/02/02']], c => { -lower => 'foo' }}, {a => {'between', [1,2]}}],
+              stmt   => "UPDATE test SET a = ?, b = to_date(?, 'MM/DD/YY'), c = LOWER(?) WHERE ( a BETWEEN ? AND ? )",
+              stmt_q => "UPDATE `test` SET `a` = ?, `b` = to_date(?, 'MM/DD/YY'), `c` = LOWER(?) WHERE ( `a` BETWEEN ? AND ? )",
+              bind   => [[a => '1'], [{dummy => 1} => '02/02/02'], [c => 'foo'], [a => '1'], [a => '2']],
+      },
+      {
+              func   => 'update',
+              new    => {bindtype => 'columns',restore_old_unop_handling => 1},
+              args   => ['test', {a => 1, b => \["to_date(?, 'MM/DD/YY')", [{dummy => 1} => '02/02/02']], c => { -lower => 'foo' }}, {a => {'between', [1,2]}}],
               stmt   => "UPDATE test SET a = ?, b = to_date(?, 'MM/DD/YY'), c = LOWER ? WHERE ( a BETWEEN ? AND ? )",
               stmt_q => "UPDATE `test` SET `a` = ?, `b` = to_date(?, 'MM/DD/YY'), `c` = LOWER ? WHERE ( `a` BETWEEN ? AND ? )",
               bind   => [[a => '1'], [{dummy => 1} => '02/02/02'], [c => 'foo'], [a => '1'], [a => '2']],
@@ -523,6 +545,14 @@ my @tests = (
               func   => 'select',
               new    => {bindtype => 'columns'},
               args   => ['test', '*', [ Y => { '=' => { -max => { -LENGTH => { -min => 'x' } } } } ] ],
+              stmt   => 'SELECT * FROM test WHERE ( Y = ( MAX( LENGTH( MIN(?) ) ) ) )',
+              stmt_q => 'SELECT * FROM `test` WHERE ( `Y` = ( MAX( LENGTH( MIN(?) ) ) ) )',
+              bind   => [[Y => 'x']],
+      },
+      {
+              func   => 'select',
+              new    => {bindtype => 'columns',restore_old_unop_handling => 1},
+              args   => ['test', '*', [ Y => { '=' => { -max => { -LENGTH => { -min => 'x' } } } } ] ],
               stmt   => 'SELECT * FROM test WHERE ( Y = ( MAX( LENGTH( MIN ? ) ) ) )',
               stmt_q => 'SELECT * FROM `test` WHERE ( `Y` = ( MAX( LENGTH( MIN ? ) ) ) )',
               bind   => [[Y => 'x']],
@@ -559,10 +589,74 @@ my @tests = (
               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 => [],
+      },
+      {
+              func => 'update',
+              args => ['mytable', { foo => 42 }, { baz => 32 }, { returning => 'id' }],
+              stmt => 'UPDATE mytable SET foo = ? WHERE baz = ? RETURNING id',
+              stmt_q => 'UPDATE `mytable` SET `foo` = ? WHERE `baz` = ? RETURNING `id`',
+              bind => [42, 32],
+      },
+      {
+              func => 'update',
+              args => ['mytable', { foo => 42 }, { baz => 32 }, { returning => \'*' }],
+              stmt => 'UPDATE mytable SET foo = ? WHERE baz = ? RETURNING *',
+              stmt_q => 'UPDATE `mytable` SET `foo` = ? WHERE `baz` = ? RETURNING *',
+              bind => [42, 32],
+      },
+      {
+              func => 'update',
+              args => ['mytable', { foo => 42 }, { baz => 32 }, { returning => ['id','created_at'] }],
+              stmt => 'UPDATE mytable SET foo = ? WHERE baz = ? RETURNING id, created_at',
+              stmt_q => 'UPDATE `mytable` SET `foo` = ? WHERE `baz` = ? RETURNING `id`, `created_at`',
+              bind => [42, 32],
+      },
+      {
+              func   => 'delete',
+              args   => ['test', {requestor => undef}, {returning => 'id'}],
+              stmt   => 'DELETE FROM test WHERE ( requestor IS NULL ) RETURNING id',
+              stmt_q => 'DELETE FROM `test` WHERE ( `requestor` IS NULL ) RETURNING `id`',
+              bind   => []
+      },
+      {
+              func   => 'delete',
+              args   => ['test', {requestor => undef}, {returning => \'*'}],
+              stmt   => 'DELETE FROM test WHERE ( requestor IS NULL ) RETURNING *',
+              stmt_q => 'DELETE FROM `test` WHERE ( `requestor` IS NULL ) RETURNING *',
+              bind   => []
+      },
+      {
+              func   => 'delete',
+              args   => ['test', {requestor => undef}, {returning => ['id', 'created_at']}],
+              stmt   => 'DELETE FROM test WHERE ( requestor IS NULL ) RETURNING id, created_at',
+              stmt_q => 'DELETE FROM `test` WHERE ( `requestor` IS NULL ) RETURNING `id`, `created_at`',
+              bind   => []
+      },
+      {
+              func   => 'delete',
+              args   => ['test', \[ undef ] ],
+              stmt   => 'DELETE FROM test',
+              stmt_q => 'DELETE FROM `test`',
+              bind   => []
+      },
 );
 
 # check is( not) => undef
-for my $op ( qw(not is is_not), 'is not' ) {
+for my $op (qw(not is is_not), 'is not') {
   (my $sop = uc $op) =~ s/_/ /gi;
 
   $sop = 'IS NOT' if $sop eq 'NOT';
@@ -581,7 +675,7 @@ for my $op ( qw(not is is_not), 'is not' ) {
 }
 
 # check single-element inequality ops for no warnings
-for my $op ( qw(!= <>) ) {
+for my $op (qw(!= <>)) {
   for my $val (undef, 42) {
     push @tests, {
       func => 'where',
@@ -617,7 +711,7 @@ for my $op (qw(not_like not_rlike), 'not like', 'not rlike', 'is not like','is n
 }
 
 # check all multi-element inequality/not-like ops for warnings
-for my $op ( qw(!= <> not_like not_rlike), 'not like', 'not rlike', 'is not like','is not rlike') {
+for my $op (qw(!= <> not_like not_rlike), 'not like', 'not rlike', 'is not like','is not rlike') {
   (my $sop = uc $op) =~ s/_/ /gi;
 
   push @tests, {
@@ -631,7 +725,7 @@ for my $op ( qw(!= <> not_like not_rlike), 'not like', 'not rlike', 'is not like
 }
 
 # check all like/not-like ops for empty-arrayref warnings
-for my $op ( qw(like rlike not_like not_rlike), 'not like', 'not rlike', 'is like', 'is not like', 'is rlike', 'is not rlike') {
+for my $op (qw(like rlike not_like not_rlike), 'not like', 'not rlike', 'is like', 'is not like', 'is rlike', 'is not rlike') {
   (my $sop = uc $op) =~ s/_/ /gi;
 
   push @tests, {
@@ -644,41 +738,173 @@ for my $op ( qw(like rlike not_like not_rlike), 'not like', 'not rlike', 'is lik
   } 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"] ],
+  ) {
+    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", -or => { $lhs => \"baz" }, bizz => "buzz" },
+    { 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);
 
     my $cref = sub {
       my $op = $t->{func};
-      ($stmt, @bind) = $maker->$op (@ { $t->{args} } );
+      ($stmt, @bind) = $maker->$op(@{ $t->{args} });
     };
 
     if (my $e = $t->{throws}) {
       throws_ok(
         sub { $cref->() },
         $e,
-      ) || diag dumper ({ args => $t->{args}, result => $stmt });
+      ) || diag dumper({ args => $t->{args}, result => $stmt });
     }
     else {
-      warnings_like(
-        sub { $cref->() },
-        $t->{warns} || [],
-      ) || diag dumper ({ args => $t->{args}, result => $stmt });
+      lives_ok(sub {
+        alarm(1); local $SIG{ALRM} = sub {
+          no warnings 'redefine';
+          my $orig = Carp->can('caller_info');
+          local *Carp::caller_info = sub { return if $_[0] > 20; &$orig };
+          print STDERR "ARGH ($SQL::Abstract::Default_Scalar_To): ".Carp::longmess();
+          die "timed out";
+        };
+        warnings_like(
+          sub { $cref->() },
+          $t->{warns} || [],
+        ) || diag dumper({ args => $t->{args}, result => $stmt });
+      }) || diag dumper({ args => $t->{args}, result => $stmt, threw => $@ });
 
       is_same_sql_bind(
         $stmt,
         \@bind,
         $quoted ? $t->{stmt_q}: $t->{stmt},
         $t->{bind}
-      );
+      ) || diag dumper({ args => $t->{args}, result => $stmt });;
     }
   }
 }