SQL::Abstract::Test(3pUser Contributed Perl DocumentatSQL::Abstract::Test(3pm)

NAME
       SQL::Abstract::Test - Helper function for testing SQL::Abstract

SYNOPSIS
         use SQL::Abstract;
         use Test::More;
         use SQL::Abstract::Test import => [qw/
           is_same_sql_bind is_same_sql is_same_bind
           eq_sql_bind eq_sql eq_bind
         /];

         my ($sql, @bind) = SQL::Abstract->new->select(%args);

         is_same_sql_bind($given_sql,    \@given_bind,
                          $expected_sql, \@expected_bind, $test_msg);

         is_same_sql($given_sql, $expected_sql, $test_msg);
         is_same_bind(\@given_bind, \@expected_bind, $test_msg);

         my $is_same = eq_sql_bind($given_sql,    \@given_bind,
                                   $expected_sql, \@expected_bind);

         my $sql_same = eq_sql($given_sql, $expected_sql);
         my $bind_same = eq_bind(\@given_bind, \@expected_bind);

DESCRIPTION
       This module is only intended for authors of tests on SQL::Abstract and
       related modules; it exports functions for comparing two SQL statements
       and their bound values.

       The SQL comparison is performed on abstract syntax, ignoring
       differences in spaces or in levels of parentheses.  Therefore the tests
       will pass as long as the semantics is preserved, even if the surface
       syntax has changed.

       Disclaimer : the semantic equivalence handling is pretty limited.  A
       lot of effort goes into distinguishing significant from non-significant
       parenthesis, including AND/OR operator associativity.  Currently this
       module does not support commutativity and more intelligent
       transformations like De Morgan's laws
        <http://en.wikipedia.org/wiki/De_Morgan's_laws>, etc.

       For a good overview of what this test framework is currently capable of
       refer to "t/10test.t"

FUNCTIONS
   is_same_sql_bind
         is_same_sql_bind(
           $given_sql, \@given_bind,
           $expected_sql, \@expected_bind,
           $test_msg
         );

         is_same_sql_bind(
           \[$given_sql, @given_bind],
           \[$expected_sql, @expected_bind],
           $test_msg
         );

         is_same_sql_bind(
           $dbic_rs->as_query
           $expected_sql, \@expected_bind,
           $test_msg
         );

       Compares given and expected pairs of "($sql, \@bind)" by unpacking @_
       as shown in the examples above and passing the arguments to "eq_sql"
       and "eq_bind". Calls "ok" in Test::Builder with the combined result,
       with $test_msg as message.  If the test fails, a detailed diagnostic is
       printed.

   is_same_sql
         is_same_sql(
           $given_sql,
           $expected_sql,
           $test_msg
         );

       Compares given and expected SQL statements via "eq_sql", and calls "ok"
       in Test::Builder on the result, with $test_msg as message.  If the test
       fails, a detailed diagnostic is printed.

   is_same_bind
         is_same_bind(
           \@given_bind,
           \@expected_bind,
           $test_msg
         );

       Compares given and expected bind values via "eq_bind", and calls "ok"
       in Test::Builder on the result, with $test_msg as message.  If the test
       fails, a detailed diagnostic is printed.

   eq_sql_bind
         my $is_same = eq_sql_bind(
           $given_sql, \@given_bind,
           $expected_sql, \@expected_bind,
         );

         my $is_same = eq_sql_bind(
           \[$given_sql, @given_bind],
           \[$expected_sql, @expected_bind],
         );

         my $is_same = eq_sql_bind(
           $dbic_rs->as_query
           $expected_sql, \@expected_bind,
         );

       Unpacks @_ depending on the given arguments and calls "eq_sql" and
       "eq_bind", returning their combined result.

   eq_sql
         my $is_same = eq_sql($given_sql, $expected_sql);

       Compares the abstract syntax of two SQL statements. Similar to
       "is_same_sql", but it just returns a boolean value and does not print
       diagnostics or talk to Test::Builder. If the result is false, the
       global variable "$sql_differ" will contain the SQL portion where a
       difference was encountered; this is useful for printing diagnostics.

   eq_bind
         my $is_same = eq_sql(\@given_bind, \@expected_bind);

       Compares two lists of bind values, taking into account the fact that
       some of the values may be arrayrefs (see "bindtype" in SQL::Abstract).
       Similar to "is_same_bind", but it just returns a boolean value and does
       not print diagnostics or talk to Test::Builder.

GLOBAL VARIABLES
   $case_sensitive
       If true, SQL comparisons will be case-sensitive. Default is false;

   $parenthesis_significant
       If true, SQL comparison will preserve and report difference in nested
       parenthesis. Useful while testing "IN (( x ))" vs "IN ( x )".  Defaults
       to false;

   $order_by_asc_significant
       If true SQL comparison will consider "ORDER BY foo ASC" and "ORDER BY
       foo" to be different. Default is false;

   $sql_differ
       When "eq_sql" returns false, the global variable $sql_differ contains
       the SQL portion where a difference was encountered.

SEE ALSO
       SQL::Abstract, Test::More, Test::Builder.

AUTHORS
       Laurent Dami <laurent.dami AT etat  geneve  ch>

       Norbert Buchmuller <norbi@nix.hu>

       Peter Rabbitson <ribasushi@cpan.org>

COPYRIGHT AND LICENSE
       Copyright 2008 by Laurent Dami.

       This library is free software; you can redistribute it and/or modify it
       under the same terms as Perl itself.

perl v5.20.1                      2014-09-19          SQL::Abstract::Test(3pm)

Czas wygenerowania: 0.00013 sek.

Created with the man page lookup class by Andrew Collington.
Based on a C man page viewer by Vadim Pavlov
Unicode soft-hyphen fix (as used by RedHat) by Dan Edwards
Some optimisations by Eli Argon
Caching idea and code contribution by James Richardson

Copyright © 2003-2023 Linux.pl
Hosted by Hosting Linux.pl