---
name: "SQL::Abstract::Test"
section: "3pm"
platform: "linux"
package: "libsql-abstract-perl"
version: "2.000001-2"
release: "Debian 13 (Trixie)"
platforms: ["linux"]
url: "https://new.carta.tech/SQL::Abstract::Test"
---

# SQL::Abstract::Test(3pm)

Helper function for testing SQL::Abstract

## 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.