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;
#
#################
-
my @tests = (
{
func => 'select',
},
{
func => 'select',
- args => [[qw/test1 test2/], '*', { 'test1.a' => { 'In', ['boom', 'bang'] } }],
- stmt => 'SELECT * FROM test1, test2 WHERE ( test1.a IN ( ?, ? ) )',
- stmt_q => 'SELECT * FROM `test1`, `test2` WHERE ( `test1`.`a` IN ( ?, ? ) )',
- bind => ['boom', 'bang']
- },
- {
- func => 'select',
- args => ['test', '*', { a => { 'between', ['boom', 'bang'] } }],
- stmt => 'SELECT * FROM test WHERE ( a BETWEEN ? AND ? )',
- stmt_q => 'SELECT * FROM `test` WHERE ( `a` BETWEEN ? AND ? )',
- bind => ['boom', 'bang']
- },
- {
- func => 'select',
args => ['test', '*', { a => { '!=', 'boom' } }],
stmt => 'SELECT * FROM test WHERE ( a != ? )',
stmt_q => 'SELECT * FROM `test` WHERE ( `a` != ? )',
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 )',
},
{
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` != ? )',
bind => ['nwiger']
},
{
+ func => 'select',
+ args => [[\'test1', 'test2'], '*', { 'test1.a' => 'boom' } ],
+ stmt => 'SELECT * FROM test1, test2 WHERE ( test1.a = ? )',
+ stmt_q => 'SELECT * FROM test1, `test2` WHERE ( `test1`.`a` = ? )',
+ bind => ['boom']
+ },
+ {
func => 'insert',
args => ['test', {a => 1, b => 2, c => 3, d => 4, e => 5}],
stmt => 'INSERT INTO test (a, b, c, d, e) VALUES (?, ?, ?, ?, ?)',
},
{
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',
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']],
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']],
},
{
func => 'select',
- args => ['test', '*', { a => { -in => [] }, b => { -not_in => [] }, c => { -in => 42 } }],
- stmt => 'SELECT * FROM test WHERE ( 0=1 AND 1=1 AND c IN ( ? ))',
- stmt_q => 'SELECT * FROM `test` WHERE ( 0=1 AND 1=1 AND `c` IN ( ? ))',
- bind => [ 42 ],
+ args => ['test', '*', { a => { '=' => undef }, b => { -is => undef }, c => { -like => undef } }],
+ stmt => 'SELECT * FROM test WHERE ( a IS NULL AND b IS NULL AND c IS NULL )',
+ stmt_q => 'SELECT * FROM `test` WHERE ( `a` IS NULL AND `b` IS NULL AND `c` IS NULL )',
+ bind => [],
+ warns => qr/\QSupplying an undefined argument to 'LIKE' is deprecated/,
},
{
func => 'select',
- args => ['test', '*', { a => { -in => [] }, b => { -not_in => [] } }],
- stmt => 'SELECT * FROM test WHERE ( 0=1 AND 1=1 )',
- stmt_q => 'SELECT * FROM `test` WHERE ( 0=1 AND 1=1 )',
+ args => ['test', '*', { a => { '!=' => undef }, b => { -is_not => undef }, c => { -not_like => undef } }],
+ stmt => 'SELECT * FROM test WHERE ( a IS NOT NULL AND b IS NOT NULL AND c IS NOT NULL )',
+ stmt_q => 'SELECT * FROM `test` WHERE ( `a` IS NOT NULL AND `b` IS NOT NULL AND `c` IS NOT NULL )',
bind => [],
+ warns => qr/\QSupplying an undefined argument to 'NOT LIKE' is deprecated/,
},
{
- 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,
func => 'select',
- args => ['test', '*', { a => { -in => [42, undef] }, b => { -not_in => [42, undef] } } ],
- stmt => 'SELECT * FROM test WHERE ( ( a IN ( ? ) OR a IS NULL ) AND b NOT IN ( ? ) AND b IS NOT NULL )',
- stmt_q => 'SELECT * FROM `test` WHERE ( ( `a` IN ( ? ) OR `a` IS NULL ) AND `b` NOT IN ( ? ) AND `b` IS NOT NULL )',
- bind => [ 42, 42 ],
- },
- {
- 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,
+ args => ['test', '*', { a => { IS => undef }, b => { LIKE => undef } }],
+ stmt => 'SELECT * FROM test WHERE ( a IS NULL AND b IS NULL )',
+ stmt_q => 'SELECT * FROM `test` WHERE ( `a` IS NULL AND `b` IS NULL )',
+ bind => [],
+ warns => qr/\QSupplying an undefined argument to 'LIKE' is deprecated/,
+ },
+ {
+ func => 'select',
+ args => ['test', '*', { a => { 'IS NOT' => undef }, b => { 'NOT LIKE' => undef } }],
+ stmt => 'SELECT * FROM test WHERE ( a IS NOT NULL AND b IS NOT NULL )',
+ stmt_q => 'SELECT * FROM `test` WHERE ( `a` IS NOT NULL AND `b` IS NOT NULL )',
+ bind => [],
+ warns => qr/\QSupplying an undefined argument to 'NOT LIKE' is deprecated/,
+ },
+ {
func => 'select',
- args => ['test', '*', { a => { -in => [undef] }, b => { -not_in => [undef] } } ],
- stmt => 'SELECT * FROM test WHERE ( a IS NULL AND b IS NOT NULL )',
- stmt_q => 'SELECT * FROM `test` WHERE ( `a` IS NULL AND `b` IS NOT NULL )',
+ 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', '*', { a => { -in => undef } }],
- throws => qr/Argument passed to the 'IN' operator can not be undefined/,
+ 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( is is_not), 'is not' ) {
+for my $op (qw(not is is_not), 'is not') {
(my $sop = uc $op) =~ s/_/ /gi;
- push @tests, {
- func => 'where',
- args => [{ a => { "$_$op" => undef } }],
- stmt => "WHERE a $sop NULL",
- stmt_q => "WHERE `a` $sop NULL",
- bind => [],
- } for ('', '-'); # with and without -
+ $sop = 'IS NOT' if $sop eq 'NOT';
+
+ for my $uc (0, 1) {
+ for my $prefix ('', '-') {
+ push @tests, {
+ func => 'where',
+ args => [{ a => { ($prefix . ($uc ? uc $op : lc $op) ) => undef } }],
+ stmt => "WHERE a $sop NULL",
+ stmt_q => "WHERE `a` $sop NULL",
+ bind => [],
+ };
+ }
+ }
}
# 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',
}
# 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, {
}
# 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, {
} 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_exist(
- sub { $cref->() },
- $t->{warns} || [],
- );
+ 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 });;
}
}
}
projects / scpubgit/Q-Branch.git / blobdiff