@@ -20,8 +20,7 @@ __PACKAGE__->attr(

     [qw/data_source dbh password user/],

     cache => 1,

     dbi_option => sub { {} },

-    filter_check  => 1,

-    query_builder => sub {DBIx::Custom::QueryBuilder->new},

+    query_builder => sub { DBIx::Custom::QueryBuilder->new },

     result_class  => 'DBIx::Custom::Result',

     table_class   => 'DBIx::Custom::Table'

 );

@@ -732,8 +731,10 @@ sub _croak {

 }

 # DEPRECATED!

-

-__PACKAGE__->attr(dbi_options => sub { {} });

+__PACKAGE__->attr(

+    dbi_options => sub { {} },

+    filter_check  => 1

+);

 sub default_bind_filter {

     my $self = shift;

@@ -5,7 +5,10 @@ use warnings;

 use base 'Object::Simple';

-__PACKAGE__->attr([qw/columns default_filter filter sql sth/]);

+__PACKAGE__->attr([qw/columns filter sql sth/]);

+

+# DEPRECATED!

+__PACKAGE__->attr('default_filter');

 1;

@@ -26,18 +29,11 @@ DBIx::Custom::Query - Query

 Column names.

-=head2 C<default_filter>

-

-    my $default_filter = $query->default_filter;

-    $query             = $query->default_filter('encode_utf8');

-

-Default filter when parameter binding is executed.

-

 =head2 C<filter>

     my $filter = $query->filter;

-    $query     = $query->filter({author => 'encode_utf8',

-                                 title  => 'encode_utf8'});

+    $query     = $query->filter({author => 'to_something',

+                                 title  => 'to_something'});

 Filters when parameter binding is executed.

 This overwrites C<default_filter>.

@@ -7,7 +7,7 @@ use base 'Object::Simple';

 use Carp 'croak';

 use DBIx::Custom::Query;

-use DBIx::Custom::QueryBuilder::TagProcessors;

+use DBIx::Custom::TagProcessor;

 # Carp trust relationship

 push @DBIx::Custom::CARP_NOT, __PACKAGE__;

@@ -17,17 +17,17 @@ push @DBIx::Custom::Where::CARP_NOT, __PACKAGE__;

 # Attributes

 __PACKAGE__->attr('tag_processors' => sub {

     {

-        '?'     => \&DBIx::Custom::QueryBuilder::TagProcessors::expand_placeholder_tag,

-        '='     => \&DBIx::Custom::QueryBuilder::TagProcessors::expand_equal_tag,

-        '<>'    => \&DBIx::Custom::QueryBuilder::TagProcessors::expand_not_equal_tag,

-        '>'     => \&DBIx::Custom::QueryBuilder::TagProcessors::expand_greater_than_tag,

-        '<'     => \&DBIx::Custom::QueryBuilder::TagProcessors::expand_lower_than_tag,

-        '>='    => \&DBIx::Custom::QueryBuilder::TagProcessors::expand_greater_than_equal_tag,

-        '<='    => \&DBIx::Custom::QueryBuilder::TagProcessors::expand_lower_than_equal_tag,

-        'like'  => \&DBIx::Custom::QueryBuilder::TagProcessors::expand_like_tag,

-        'in'    => \&DBIx::Custom::QueryBuilder::TagProcessors::expand_in_tag,

-        'insert_param' => \&DBIx::Custom::QueryBuilder::TagProcessors::expand_insert_param_tag,

-        'update_param' => \&DBIx::Custom::QueryBuilder::TagProcessors::expand_update_param_tag

+        '?'     => \&DBIx::Custom::TagProcessor::expand_placeholder_tag,

+        '='     => \&DBIx::Custom::TagProcessor::expand_equal_tag,

+        '<>'    => \&DBIx::Custom::TagProcessor::expand_not_equal_tag,

+        '>'     => \&DBIx::Custom::TagProcessor::expand_greater_than_tag,

+        '<'     => \&DBIx::Custom::TagProcessor::expand_lower_than_tag,

+        '>='    => \&DBIx::Custom::TagProcessor::expand_greater_than_equal_tag,

+        '<='    => \&DBIx::Custom::TagProcessor::expand_lower_than_equal_tag,

+        'like'  => \&DBIx::Custom::TagProcessor::expand_like_tag,

+        'in'    => \&DBIx::Custom::TagProcessor::expand_in_tag,

+        'insert_param' => \&DBIx::Custom::TagProcessor::expand_insert_param_tag,

+        'update_param' => \&DBIx::Custom::TagProcessor::expand_update_param_tag

     }

 });

@@ -1,179 +0,0 @@

-package DBIx::Custom::QueryBuilder::TagProcessors;

-

-use strict;

-use warnings;

-

-use Carp 'croak';

-

-# Carp trust relationship

-push @DBIx::Custom::QueryBuilder::CARP_NOT, __PACKAGE__;

-

-sub expand_equal_tag              { _expand_basic_tag('=',    @_) }

-sub expand_greater_than_equal_tag { _expand_basic_tag('>=',   @_) }

-sub expand_greater_than_tag       { _expand_basic_tag('>',    @_) }

-

-sub expand_in_tag {

-    my ($column, $count) = @_;

-    

-    # Check arguments

-    croak qq{Column name and count of values must be specified in tag "{in }"}

-      unless $column && $count && $count =~ /^\d+$/;

-

-    # Part of statement

-    my $s = "$column in (";

-    for (my $i = 0; $i < $count; $i++) {

-        $s .= '?, ';

-    }

-    $s =~ s/, $//;

-    $s .= ')';

-    

-    # Columns

-    my $columns = [];

-    push @$columns, $column for (0 .. $count - 1);

-    

-    return [$s, $columns];

-}

-

-sub expand_insert_param_tag {

-    my @columns = @_;

-    

-    # Insert parameters

-    my $s = '(';

-    $s .= "$_, " for @columns;

-    $s =~ s/, $//;

-    $s .= ') ';

-    $s .= 'values (';

-    $s .= "?, " for @columns;

-    $s =~ s/, $//;

-    $s .= ')';

-    

-    return [$s, \@columns];

-}

-

-sub expand_like_tag               { _expand_basic_tag('like', @_) }

-sub expand_lower_than_equal_tag   { _expand_basic_tag('<=',   @_) }

-sub expand_lower_than_tag         { _expand_basic_tag('<',    @_) }

-sub expand_not_equal_tag          { _expand_basic_tag('<>',   @_) }

-

-sub expand_placeholder_tag {

-    my $column = shift;

-    

-    # Check arguments

-    croak qq{Column name must be specified in tag "{? }"}

-      unless $column;

-    

-    return ['?', [$column]];

-}

-

-sub expand_update_param_tag {

-    my @columns = @_;

-    

-    # Update paramters

-    my $s = 'set ';

-    $s .= "$_ = ?, " for @columns;

-    $s =~ s/, $//;

-    

-    return [$s, \@columns];

-}

-

-sub _expand_basic_tag {

-    my ($name, $column) = @_;

-    

-    # Check arguments

-    croak qq{Column name must be specified in tag "{$name }"}

-      unless $column;

-    

-    return ["$column $name ?", [$column]];

-}

-

-1;

-

-=head1 NAME

-

-DBIx::Custom::QueryBuilder::TagProcessors - Tag processors

-

-=head1 SYNOPSYS

-

-    my $expanded = expand_equal_tag($source);

-    my $expanded = expand_greater_than_equal_tag($source);

-    my $expanded = expand_greater_than_tag($source);

-    my $expanded = expand_like_tag($source);

-    my $expanded = expand_lower_than_equal_tag($source);

-    my $expanded = expand_lower_than_tag($source);

-    my $expanded = expand_in_tag($source);

-    my $expanded = expand_insert_param_tag($source);

-    my $expanded = expand_not_equal_tag($source);

-    my $expanded = expand_placeholder_tag($source);

-    my $expanded = expand_update_param_tag($source);

-

-=head1 TAG PROCESSORS

-

-Tag processor is function,

-which receive arguments and return a part of SQL statment

-and column names.

-The part of SQL statment contains placeholders.

-the count of placeholders must be

-same as the count of column names.

-

-    sub processor_name {

-        my @args = @_;

-        

-        # Part of statment, which constains placeholders

-        my $s;

-        

-        # Column names

-        my $columns = [];

-        

-        # Do something

-        # ...

-        

-        return [$s, $columns];

-    }

-

-=head2 C<expand_equal_tag>

-

-    ('NAME')  ->  ['NAME = ?', ['NAME']]

-

-=head2 C<expand_greater_than_equal_tag>

-

-    ('NAME')  ->  ['NAME >= ?', ['NAME']]

-

-=head2 C<expand_greater_than_tag>

-

-    ('NAME')  ->  ['NAME > ?', ['NAME']]

-

-=head2 C<expand_like_tag>

-

-    ('NAME')  ->  ['NAME like ?', ['NAME']]

-

-=head2 C<expand_lower_than_equal_tag>

-

-    ('NAME')  ->  ['NAME <= ?', ['NAME']]

-

-=head2 C<expand_lower_than_tag>

-

-    ('NAME')  ->  ['NAME < ?', ['NAME']]

-

-=head2 C<expand_in_tag>

-

-    ('NAME', 3)  -> ['NAME in (?, ?, ?)', ['NAME', 'NAME', 'NAME']]

-

-=head2 C<expand_insert_param_tag>

-

-    ('NAME1', 'NAME2')

-      ->  ['(NAME1, NAME2) values (?, ?, ?)', ['NAME1', 'NAME2']]

-

-=head2 C<expand_not_equal_tag>

-

-    ('NAME')  ->  ['NAME <> ?', ['NAME']]

-

-=head2 C<expand_placeholder_tag>

-

-    ('NAME')  ->  ['?', ['NAME']]

-

-=head2 C<expand_update_param_tag>

-

-    ('NAME1', 'NAME2')

-      ->  ['set NAME1 = ?, NAME2 = ?', ['NAME1', 'NAME2']]

-

-=cut

@@ -7,7 +7,7 @@ use base 'Object::Simple';

 use Carp 'croak';

-__PACKAGE__->attr([qw/filter_check filters sth/]);

+__PACKAGE__->attr([qw/filters sth/]);

 sub filter {

     my $self = shift;

@@ -239,6 +239,9 @@ sub default_filter {

     return $self->{default_filter};

 }

+# DEPRECATED!

+__PACKAGE__->attr('filter_check'); 

+

 1;

 =head1 NAME

@@ -311,13 +314,6 @@ This overwrites C<default_filter>.

 Resistered filters.

-=head2 C<filter_check>

-

-    my $filter_check = $result->filter_check;

-    $result          = $result->filter_check;

-

-Enable filter validation.

-

 =head2 C<sth>

     my $sth = $reuslt->sth

@@ -10,7 +10,7 @@ use Carp 'croak';

 # Carp trust relationship

 push @DBIx::Custom::CARP_NOT, __PACKAGE__;

-__PACKAGE__->attr(['dbi', 'name', 'model']);

+__PACKAGE__->attr(['dbi', 'name']);

 our $AUTOLOAD;

@@ -0,0 +1,94 @@

+package DBIx::Custom::TagProcessor;

+

+use strict;

+use warnings;

+

+use Carp 'croak';

+

+# Carp trust relationship

+push @DBIx::Custom::QueryBuilder::CARP_NOT, __PACKAGE__;

+

+sub expand_equal_tag              { _expand_basic_tag('=',    @_) }

+sub expand_greater_than_equal_tag { _expand_basic_tag('>=',   @_) }

+sub expand_greater_than_tag       { _expand_basic_tag('>',    @_) }

+

+sub expand_in_tag {

+    my ($column, $count) = @_;

+    

+    # Check arguments

+    croak qq{Column name and count of values must be specified in tag "{in }"}

+      unless $column && $count && $count =~ /^\d+$/;

+

+    # Part of statement

+    my $s = "$column in (";

+    for (my $i = 0; $i < $count; $i++) {

+        $s .= '?, ';

+    }

+    $s =~ s/, $//;

+    $s .= ')';

+    

+    # Columns

+    my $columns = [];

+    push @$columns, $column for (0 .. $count - 1);

+    

+    return [$s, $columns];

+}

+

+sub expand_insert_param_tag {

+    my @columns = @_;

+    

+    # Insert parameters

+    my $s = '(';

+    $s .= "$_, " for @columns;

+    $s =~ s/, $//;

+    $s .= ') ';

+    $s .= 'values (';

+    $s .= "?, " for @columns;

+    $s =~ s/, $//;

+    $s .= ')';

+    

+    return [$s, \@columns];

+}

+

+sub expand_like_tag               { _expand_basic_tag('like', @_) }

+sub expand_lower_than_equal_tag   { _expand_basic_tag('<=',   @_) }

+sub expand_lower_than_tag         { _expand_basic_tag('<',    @_) }

+sub expand_not_equal_tag          { _expand_basic_tag('<>',   @_) }

+

+sub expand_placeholder_tag {

+    my $column = shift;

+    

+    # Check arguments

+    croak qq{Column name must be specified in tag "{? }"}

+      unless $column;

+    

+    return ['?', [$column]];

+}

+

+sub expand_update_param_tag {

+    my @columns = @_;

+    

+    # Update paramters

+    my $s = 'set ';

+    $s .= "$_ = ?, " for @columns;

+    $s =~ s/, $//;

+    

+    return [$s, \@columns];

+}

+

+sub _expand_basic_tag {

+    my ($name, $column) = @_;

+    

+    # Check arguments

+    croak qq{Column name must be specified in tag "{$name }"}

+      unless $column;

+    

+    return ["$column $name ?", [$column]];

+}

+

+1;

+

+=head1 NAME

+

+DBIx::Custom::TagProcessor - Tag processor

+

@@ -16,10 +16,7 @@ BEGIN {

 }

 # Function for test name

-my $test;

-sub test {

-    $test = shift;

-}

+sub test { "# $_[0]\n" }

 # Constant varialbes for test

 my $CREATE_TABLE = {

@@ -80,22 +77,22 @@ $result = $dbi->execute($query);

 while (my $row = $result->fetch) {

     push @rows, [@$row];

 }

-is_deeply(\@rows, [[1, 2], [3, 4]], "$test : fetch");

+is_deeply(\@rows, [[1, 2], [3, 4]], "fetch");

 $result = $dbi->execute($query);

 @rows = ();

 while (my $row = $result->fetch_hash) {

     push @rows, {%$row};

 }

-is_deeply(\@rows, [{key1 => 1, key2 => 2}, {key1 => 3, key2 => 4}], "$test : fetch_hash");

+is_deeply(\@rows, [{key1 => 1, key2 => 2}, {key1 => 3, key2 => 4}], "fetch_hash");

 $result = $dbi->execute($query);

 $rows = $result->fetch_all;

-is_deeply($rows, [[1, 2], [3, 4]], "$test : fetch_all");

+is_deeply($rows, [[1, 2], [3, 4]], "fetch_all");

 $result = $dbi->execute($query);

 $rows = $result->fetch_hash_all;

-is_deeply($rows, [{key1 => 1, key2 => 2}, {key1 => 3, key2 => 4}], "$test : fetch_hash_all");

+is_deeply($rows, [{key1 => 1, key2 => 2}, {key1 => 3, key2 => 4}], "fetch_hash_all");

 test 'Insert query return value';

 $dbi->execute($DROP_TABLE->{0});

@@ -103,7 +100,7 @@ $dbi->execute($CREATE_TABLE->{0});

 $source = "insert into table1 {insert_param key1 key2}";

 $query = $dbi->create_query($source);

 $ret_val = $dbi->execute($query, param => {key1 => 1, key2 => 2});

-ok($ret_val, $test);

+ok($ret_val);

 test 'Direct query';

@@ -113,7 +110,7 @@ $insert_SOURCE = "insert into table1 {insert_param key1 key2}";

 $dbi->execute($insert_SOURCE, param => {key1 => 1, key2 => 2});

 $result = $dbi->execute($SELECT_SOURCES->{0});

 $rows = $result->fetch_hash_all;

-is_deeply($rows, [{key1 => 1, key2 => 2}], $test);

+is_deeply($rows, [{key1 => 1, key2 => 2}]);

 test 'Filter basic';

 $dbi->execute($DROP_TABLE->{0});

@@ -127,7 +124,7 @@ $insert_query->filter({key1 => 'twice'});

 $dbi->execute($insert_query, param => {key1 => 1, key2 => 2});

 $result = $dbi->execute($SELECT_SOURCES->{0});

 $rows = $result->filter({key2 => 'three_times'})->fetch_hash_all;

-is_deeply($rows, [{key1 => 2, key2 => 6}], "$test : filter fetch_filter");

+is_deeply($rows, [{key1 => 2, key2 => 6}], "filter fetch_filter");

 $dbi->execute($DROP_TABLE->{0});

 test 'Filter in';

@@ -140,7 +137,7 @@ $select_query = $dbi->create_query($select_SOURCE);

 $select_query->filter({'table1.key1' => 'twice'});

 $result = $dbi->execute($select_query, param => {'table1.key1' => [1,5], 'table1.key2' => [2,4]});

 $rows = $result->fetch_hash_all;

-is_deeply($rows, [{key1 => 2, key2 => 4}], "$test : filter");

+is_deeply($rows, [{key1 => 2, key2 => 4}], "filter");

 test 'DBIx::Custom::SQLTemplate basic tag';

 $dbi->execute($DROP_TABLE->{0});

@@ -152,13 +149,13 @@ $source = "select * from table1 where {= key1} and {<> key2} and {< key3} and {>

 $query = $dbi->create_query($source);

 $result = $dbi->execute($query, param => {key1 => 1, key2 => 3, key3 => 4, key4 => 3, key5 => 5});

 $rows = $result->fetch_hash_all;

-is_deeply($rows, [{key1 => 1, key2 => 2, key3 => 3, key4 => 4, key5 => 5}], "$test : basic tag1");

+is_deeply($rows, [{key1 => 1, key2 => 2, key3 => 3, key4 => 4, key5 => 5}], "basic tag1");

 $source = "select * from table1 where {<= key1} and {like key2};";

 $query = $dbi->create_query($source);

 $result = $dbi->execute($query, param => {key1 => 1, key2 => '%2%'});

 $rows = $result->fetch_hash_all;

-is_deeply($rows, [{key1 => 1, key2 => 2, key3 => 3, key4 => 4, key5 => 5}], "$test : basic tag2");

+is_deeply($rows, [{key1 => 1, key2 => 2, key3 => 3, key4 => 4, key5 => 5}], "basic tag2");

 test 'DIB::Custom::SQLTemplate in tag';

 $dbi->execute($DROP_TABLE->{0});

@@ -170,7 +167,7 @@ $source = "select * from table1 where {in key1 2};";

 $query = $dbi->create_query($source);

 $result = $dbi->execute($query, param => {key1 => [9, 1]});

 $rows = $result->fetch_hash_all;

-is_deeply($rows, [{key1 => 1, key2 => 2, key3 => 3, key4 => 4, key5 => 5}], "$test : basic");

+is_deeply($rows, [{key1 => 1, key2 => 2, key3 => 3, key4 => 4, key5 => 5}], "basic");

 test 'DBIx::Custom::SQLTemplate insert tag';

 $dbi->execute("delete from table1");

@@ -179,7 +176,7 @@ $dbi->execute($insert_SOURCE, param => {key1 => 1, key2 => 2, key3 => 3, key4 =>

 $result = $dbi->execute($SELECT_SOURCES->{0});

 $rows = $result->fetch_hash_all;

-is_deeply($rows, [{key1 => 1, key2 => 2, key3 => 3, key4 => 4, key5 => 5}], "$test : basic");

+is_deeply($rows, [{key1 => 1, key2 => 2, key3 => 3, key4 => 4, key5 => 5}], "basic");

 test 'DBIx::Custom::SQLTemplate update tag';

 $dbi->execute("delete from table1");

@@ -193,15 +190,15 @@ $dbi->execute($update_SOURCE, param => {key1 => 1, key2 => 1, key3 => 1, key4 =>

 $result = $dbi->execute($SELECT_SOURCES->{0});

 $rows = $result->fetch_hash_all;

 is_deeply($rows, [{key1 => 1, key2 => 1, key3 => 1, key4 => 1, key5 => 5},

-                  {key1 => 6, key2 => 7, key3 => 8, key4 => 9, key5 => 10}], "$test : basic");

+                  {key1 => 6, key2 => 7, key3 => 8, key4 => 9, key5 => 10}], "basic");

 test 'Error case';

 eval {DBIx::Custom->connect(data_source => 'dbi:SQLit')};

-ok($@, "$test : connect error");

+ok($@, "connect error");

 $dbi = DBIx::Custom->connect($NEW_ARGS->{0});

 eval{$dbi->create_query("{p }")};

-ok($@, "$test : create_query invalid SQL template");

+ok($@, "create_query invalid SQL template");

 test 'insert';

 $dbi = DBIx::Custom->connect($NEW_ARGS->{0});

@@ -210,7 +207,7 @@ $dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});

 $dbi->insert(table => 'table1', param => {key1 => 3, key2 => 4});

 $result = $dbi->execute($SELECT_SOURCES->{0});

 $rows   = $result->fetch_hash_all;

-is_deeply($rows, [{key1 => 1, key2 => 2}, {key1 => 3, key2 => 4}], "$test : basic");

+is_deeply($rows, [{key1 => 1, key2 => 2}, {key1 => 3, key2 => 4}], "basic");

 $dbi->execute('delete from table1');

 $dbi->register_filter(

@@ -221,7 +218,7 @@ $dbi->default_bind_filter('twice');

 $dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2}, filter => {key1 => 'three_times'});

 $result = $dbi->execute($SELECT_SOURCES->{0});

 $rows   = $result->fetch_hash_all;

-is_deeply($rows, [{key1 => 3, key2 => 4}], "$test : filter");

+is_deeply($rows, [{key1 => 3, key2 => 4}], "filter");

 $dbi->default_bind_filter(undef);

 $dbi->execute($DROP_TABLE->{0});

@@ -231,7 +228,7 @@ $rows = $dbi->select(table => 'table1')->fetch_hash_all;

 is_deeply($rows, [{key1 => 1, key2 => 2}], 'insert append');

 eval{$dbi->insert(table => 'table1', noexist => 1)};

-like($@, qr/noexist/, "$test: invalid argument");

+like($@, qr/noexist/, "invalid argument");

 test 'update';

@@ -244,7 +241,7 @@ $result = $dbi->execute($SELECT_SOURCES->{0});

 $rows   = $result->fetch_hash_all;

 is_deeply($rows, [{key1 => 1, key2 => 11, key3 => 3, key4 => 4, key5 => 5},

                   {key1 => 6, key2 => 7,  key3 => 8, key4 => 9, key5 => 10}],

-                  "$test : basic");

+                  "basic");

 $dbi->execute("delete from table1");

 $dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2, key3 => 3, key4 => 4, key5 => 5});

@@ -254,14 +251,14 @@ $result = $dbi->execute($SELECT_SOURCES->{0});

 $rows   = $result->fetch_hash_all;

 is_deeply($rows, [{key1 => 1, key2 => 12, key3 => 3, key4 => 4, key5 => 5},

                   {key1 => 6, key2 => 7,  key3 => 8, key4 => 9, key5 => 10}],

-                  "$test : update key same as search key");

+                  "update key same as search key");

 $dbi->update(table => 'table1', param => {key2 => [12]}, where => {key2 => 2, key3 => 3});

 $result = $dbi->execute($SELECT_SOURCES->{0});

 $rows   = $result->fetch_hash_all;

 is_deeply($rows, [{key1 => 1, key2 => 12, key3 => 3, key4 => 4, key5 => 5},

                   {key1 => 6, key2 => 7,  key3 => 8, key4 => 9, key5 => 10}],

-                  "$test : update key same as search key : param is array ref");

+                  "update key same as search key : param is array ref");

 $dbi->execute("delete from table1");

 $dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2, key3 => 3, key4 => 4, key5 => 5});

@@ -273,15 +270,15 @@ $result = $dbi->execute($SELECT_SOURCES->{0});

 $rows   = $result->fetch_hash_all;

 is_deeply($rows, [{key1 => 1, key2 => 22, key3 => 3, key4 => 4, key5 => 5},

                   {key1 => 6, key2 => 7,  key3 => 8, key4 => 9, key5 => 10}],

-                  "$test : filter");

+                  "filter");

 $result = $dbi->update(table => 'table1', param => {key2 => 11}, where => {key1 => 1}, append => '   ');

 eval{$dbi->update(table => 'table1', noexist => 1)};

-like($@, qr/noexist/, "$test: invalid argument");

+like($@, qr/noexist/, "invalid argument");

 eval{$dbi->update(table => 'table1')};

-like($@, qr/where/, "$test: not contain where");

+like($@, qr/where/, "not contain where");

 test 'update_all';

@@ -295,7 +292,7 @@ $result = $dbi->execute($SELECT_SOURCES->{0});

 $rows   = $result->fetch_hash_all;

 is_deeply($rows, [{key1 => 1, key2 => 20, key3 => 3, key4 => 4, key5 => 5},

                   {key1 => 6, key2 => 20, key3 => 8, key4 => 9, key5 => 10}],

-                  "$test : filter");

+                  "filter");

 test 'delete';

@@ -306,7 +303,7 @@ $dbi->insert(table => 'table1', param => {key1 => 3, key2 => 4});

 $dbi->delete(table => 'table1', where => {key1 => 1});

 $result = $dbi->execute($SELECT_SOURCES->{0});

 $rows   = $result->fetch_hash_all;

-is_deeply($rows, [{key1 => 3, key2 => 4}], "$test : basic");

+is_deeply($rows, [{key1 => 3, key2 => 4}], "basic");

 $dbi->execute("delete from table1;");

 $dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});

@@ -315,7 +312,7 @@ $dbi->register_filter(twice => sub { $_[0] * 2 });

 $dbi->delete(table => 'table1', where => {key2 => 1}, filter => {key2 => 'twice'});

 $result = $dbi->execute($SELECT_SOURCES->{0});

 $rows   = $result->fetch_hash_all;

-is_deeply($rows, [{key1 => 3, key2 => 4}], "$test : filter");

+is_deeply($rows, [{key1 => 3, key2 => 4}], "filter");

 $dbi->delete(table => 'table1', where => {key1 => 1}, append => '   ');

@@ -324,10 +321,10 @@ $dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});

 $dbi->insert(table => 'table1', param => {key1 => 3, key2 => 4});

 $dbi->delete(table => 'table1', where => {key1 => 1, key2 => 2});

 $rows = $dbi->select(table => 'table1')->fetch_hash_all;

-is_deeply($rows, [{key1 => 3, key2 => 4}], "$test : delete multi key");

+is_deeply($rows, [{key1 => 3, key2 => 4}], "delete multi key");

 eval{$dbi->delete(table => 'table1', noexist => 1)};

-like($@, qr/noexist/, "$test: invalid argument");

+like($@, qr/noexist/, "invalid argument");

 test 'delete error';

@@ -335,7 +332,7 @@ $dbi = DBIx::Custom->connect($NEW_ARGS->{0});

 $dbi->execute($CREATE_TABLE->{0});

 eval{$dbi->delete(table => 'table1')};

 like($@, qr/"where" argument must be specified and contains the pairs of column name and value/,

-         "$test : where key-value pairs not specified");

+         "where key-value pairs not specified");

 test 'delete_all';

 $dbi = DBIx::Custom->connect($NEW_ARGS->{0});

@@ -345,7 +342,7 @@ $dbi->insert(table => 'table1', param => {key1 => 3, key2 => 4});

 $dbi->delete_all(table => 'table1');

 $result = $dbi->execute($SELECT_SOURCES->{0});

 $rows   = $result->fetch_hash_all;

-is_deeply($rows, [], "$test : basic");

+is_deeply($rows, [], "basic");

 test 'select';

@@ -355,27 +352,27 @@ $dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});

 $dbi->insert(table => 'table1', param => {key1 => 3, key2 => 4});

 $rows = $dbi->select(table => 'table1')->fetch_hash_all;

 is_deeply($rows, [{key1 => 1, key2 => 2},

-                  {key1 => 3, key2 => 4}], "$test : table");

+                  {key1 => 3, key2 => 4}], "table");

 $rows = $dbi->select(table => 'table1', column => ['key1'])->fetch_hash_all;

-is_deeply($rows, [{key1 => 1}, {key1 => 3}], "$test : table and columns and where key");

+is_deeply($rows, [{key1 => 1}, {key1 => 3}], "table and columns and where key");

 $rows = $dbi->select(table => 'table1', where => {key1 => 1})->fetch_hash_all;

-is_deeply($rows, [{key1 => 1, key2 => 2}], "$test : table and columns and where key");

+is_deeply($rows, [{key1 => 1, key2 => 2}], "table and columns and where key");

 $rows = $dbi->select(table => 'table1', where => ['{= key1} and {= key2}', {key1 => 1, key2 => 2}])->fetch_hash_all;

-is_deeply($rows, [{key1 => 1, key2 => 2}], "$test : table and columns and where string");

+is_deeply($rows, [{key1 => 1, key2 => 2}], "table and columns and where string");

 $rows = $dbi->select(table => 'table1', column => ['key1'], where => {key1 => 3})->fetch_hash_all;

-is_deeply($rows, [{key1 => 3}], "$test : table and columns and where key");

+is_deeply($rows, [{key1 => 3}], "table and columns and where key");

 $rows = $dbi->select(table => 'table1', append => "order by key1 desc limit 1")->fetch_hash_all;

-is_deeply($rows, [{key1 => 3, key2 => 4}], "$test : append statement");

+is_deeply($rows, [{key1 => 3, key2 => 4}], "append statement");

 $dbi->register_filter(decrement => sub { $_[0] - 1 });

 $rows = $dbi->select(table => 'table1', where => {key1 => 2}, filter => {key1 => 'decrement'})

             ->fetch_hash_all;

-is_deeply($rows, [{key1 => 1, key2 => 2}], "$test : filter");

+is_deeply($rows, [{key1 => 1, key2 => 2}], "filter");

 $dbi->execute($CREATE_TABLE->{2});

 $dbi->insert(table => 'table2', param => {key1 => 1, key3 => 5});

@@ -385,17 +382,17 @@ $rows = $dbi->select(

     where   => {'table1.key2' => 2},

     relation  => {'table1.key1' => 'table2.key1'}

 )->fetch_hash_all;

-is_deeply($rows, [{table1_key1 => 1, table2_key1 => 1, key2 => 2, key3 => 5}], "$test : relation : exists where");

+is_deeply($rows, [{table1_key1 => 1, table2_key1 => 1, key2 => 2, key3 => 5}], "relation : exists where");

 $rows = $dbi->select(

     table => [qw/table1 table2/],

     column => ['table1.key1 as table1_key1', 'table2.key1 as table2_key1', 'key2', 'key3'],

     relation  => {'table1.key1' => 'table2.key1'}

 )->fetch_hash_all;

-is_deeply($rows, [{table1_key1 => 1, table2_key1 => 1, key2 => 2, key3 => 5}], "$test : relation : no exists where");

+is_deeply($rows, [{table1_key1 => 1, table2_key1 => 1, key2 => 2, key3 => 5}], "relation : no exists where");

 eval{$dbi->select(table => 'table1', noexist => 1)};

-like($@, qr/noexist/, "$test: invalid argument");

+like($@, qr/noexist/, "invalid argument");

 test 'fetch filter';

@@ -410,16 +407,16 @@ $dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});

 $result = $dbi->select(table => 'table1');

 $result->filter({key1 => 'three_times'});

 $row = $result->fetch_hash_first;

-is_deeply($row, {key1 => 3, key2 => 4}, "$test: default_fetch_filter and filter");

+is_deeply($row, {key1 => 3, key2 => 4}, "default_fetch_filter and filter");

 test 'filters';

 $dbi = DBIx::Custom->new;

 is($dbi->filters->{decode_utf8}->(encode_utf8('あ')),

-   'あ', "$test : decode_utf8");

+   'あ', "decode_utf8");

 is($dbi->filters->{encode_utf8}->('あ'),

-   encode_utf8('あ'), "$test : encode_utf8");

+   encode_utf8('あ'), "encode_utf8");

 test 'transaction';

 $dbi = DBIx::Custom->connect($NEW_ARGS->{0});

@@ -430,7 +427,7 @@ $dbi->insert(table => 'table1', param => {key1 => 2, key2 => 3});

 $dbi->dbh->commit;

 $result = $dbi->select(table => 'table1');

 is_deeply(scalar $result->fetch_hash_all, [{key1 => 1, key2 => 2}, {key1 => 2, key2 => 3}],

-          "$test : commit");

+          "commit");

 $dbi = DBIx::Custom->connect($NEW_ARGS->{0});

 $dbi->execute($CREATE_TABLE->{0});

@@ -439,7 +436,7 @@ $dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});

 $dbi->dbh->rollback;

 $result = $dbi->select(table => 'table1');

-ok(! $result->fetch_first, "$test: rollback");

+ok(! $result->fetch_first, "rollback");

 test 'cache';

 $dbi = DBIx::Custom->connect($NEW_ARGS->{0});

@@ -447,7 +444,7 @@ $dbi->execute($CREATE_TABLE->{0});

 $source = 'select * from table1 where {= key1} and {= key2};';

 $dbi->create_query($source);

 is_deeply($dbi->{_cached}->{$source}, 

-          {sql => "select * from table1 where key1 = ? and key2 = ?;", columns => ['key1', 'key2']}, "$test : cache");

+          {sql => "select * from table1 where key1 = ? and key2 = ?;", columns => ['key1', 'key2']}, "cache");

 $dbi = DBIx::Custom->connect($NEW_ARGS->{0});

 $dbi->execute($CREATE_TABLE->{0});

@@ -462,32 +459,32 @@ $dbi->execute($CREATE_TABLE->{0});

 {

     local $Carp::Verbose = 0;

     eval{$dbi->execute('select * frm table1')};

-    like($@, qr/\Qselect * frm table1;/, "$test : fail prepare");

-    like($@, qr/\.t /, "$test: fail : not verbose");

+    like($@, qr/\Qselect * frm table1;/, "fail prepare");

+    like($@, qr/\.t /, "fail : not verbose");

 }

 {

     local $Carp::Verbose = 1;

     eval{$dbi->execute('select * frm table1')};

-    like($@, qr/Custom.*\.t /s, "$test : fail : verbose");

+    like($@, qr/Custom.*\.t /s, "fail : verbose");

 }

 eval{$dbi->execute('select * from table1', no_exists => 1)};

-like($@, qr/\Q"no_exists" is invalid argument/, "$test : invald SQL");

+like($@, qr/\Q"no_exists" is invalid argument/, "invald SQL");

 $query = $dbi->create_query('select * from table1 where {= key1}');

 $dbi->dbh->disconnect;

 eval{$dbi->execute($query, param => {key1 => {a => 1}})};

-ok($@, "$test: execute fail");

+ok($@, "execute fail");

 {

     local $Carp::Verbose = 0;

     eval{$dbi->create_query('select * from table1 where {0 key1}')};

-    like($@, qr/\Q.t /, "$test : caller spec : not vebose");

+    like($@, qr/\Q.t /, "caller spec : not vebose");

 }

 {

     local $Carp::Verbose = 1;

     eval{$dbi->create_query('select * from table1 where {0 key1}')};

-    like($@, qr/QueryBuilder.*\.t /s, "$test : caller spec : not vebose");

+    like($@, qr/QueryBuilder.*\.t /s, "caller spec : not vebose");

 }

@@ -507,7 +504,7 @@ $dbi->rollback if $@;

 $result = $dbi->select(table => 'table1');

 $rows = $result->fetch_hash_all;

-is_deeply($rows, [], "$test : rollback");

+is_deeply($rows, [], "rollback");

 $dbi->begin_work;

@@ -520,11 +517,11 @@ $dbi->commit unless $@;

 $result = $dbi->select(table => 'table1');

 $rows = $result->fetch_hash_all;

-is_deeply($rows, [{key1 => 1, key2 => 2}, {key1 => 3, key2 => 4}], "$test : commit");

+is_deeply($rows, [{key1 => 1, key2 => 2}, {key1 => 3, key2 => 4}], "commit");

 $dbi->dbh->{AutoCommit} = 0;

 eval{ $dbi->begin_work };

-ok($@, "$test : exception");

+ok($@, "exception");

 $dbi->dbh->{AutoCommit} = 1;

@@ -543,12 +540,12 @@ $dbi->helper({

     }

 });

-is($dbi->one, 1, "$test : first");

-is($dbi->two, 2, "$test : second");

-is($dbi->twice(5), 10 , "$test : second");

+is($dbi->one, 1, "first");

+is($dbi->two, 2, "second");

+is($dbi->twice(5), 10 , "second");

 eval {$dbi->XXXXXX};

-like($@, qr/\QCan't locate object method "XXXXXX" via "DBIx::Custom"/, "$test : not exists");

+like($@, qr/\QCan't locate object method "XXXXXX" via "DBIx::Custom"/, "not exists");

 test 'out filter';

 $dbi = DBIx::Custom->connect($NEW_ARGS->{0});

@@ -561,10 +558,10 @@ $dbi->apply_filter(

 $dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});

 $result = $dbi->execute($SELECT_SOURCES->{0});

 $row   = $result->fetch_hash_first;

-is_deeply($row, {key1 => 2, key2 => 6}, "$test : insert");

+is_deeply($row, {key1 => 2, key2 => 6}, "insert");

 $result = $dbi->select(table => 'table1');

 $row   = $result->fetch_hash_first;

-is_deeply($row, {key1 => 6, key2 => 12}, "$test : insert");

+is_deeply($row, {key1 => 6, key2 => 12}, "insert");

 $dbi = DBIx::Custom->connect($NEW_ARGS->{0});

 $dbi->execute($CREATE_TABLE->{0});

@@ -576,7 +573,7 @@ $dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2}, filter => {key1

 $dbi->update(table => 'table1', param => {key1 => 2}, where => {key2 => 2});

 $result = $dbi->execute($SELECT_SOURCES->{0});

 $row   = $result->fetch_hash_first;

-is_deeply($row, {key1 => 4, key2 => 2}, "$test : update");

+is_deeply($row, {key1 => 4, key2 => 2}, "update");

 $dbi = DBIx::Custom->connect($NEW_ARGS->{0});

 $dbi->execute($CREATE_TABLE->{0});

@@ -588,7 +585,7 @@ $dbi->insert(table => 'table1', param => {key1 => 2, key2 => 2}, filter => {key1

 $dbi->delete(table => 'table1', where => {key1 => 1});

 $result = $dbi->execute($SELECT_SOURCES->{0});

 $rows   = $result->fetch_hash_all;

-is_deeply($rows, [], "$test : delete");

+is_deeply($rows, [], "delete");

 $dbi = DBIx::Custom->connect($NEW_ARGS->{0});

 $dbi->execute($CREATE_TABLE->{0});

@@ -600,7 +597,7 @@ $dbi->insert(table => 'table1', param => {key1 => 2, key2 => 2}, filter => {key1

 $result = $dbi->select(table => 'table1', where => {key1 => 1});

 $result->filter({'key2' => 'twice'});

 $rows   = $result->fetch_hash_all;

-is_deeply($rows, [{key1 => 4, key2 => 4}], "$test : select");

+is_deeply($rows, [{key1 => 4, key2 => 4}], "select");

 $dbi = DBIx::Custom->connect($NEW_ARGS->{0});

 $dbi->execute($CREATE_TABLE->{0});

@@ -613,7 +610,7 @@ $result = $dbi->execute("select * from table1 where {= key1} and {= key2};",

                         param => {key1 => 1, key2 => 2},

                         table => ['table1']);

 $rows   = $result->fetch_hash_all;

-is_deeply($rows, [{key1 => 4, key2 => 2}], "$test : execute");

+is_deeply($rows, [{key1 => 4, key2 => 2}], "execute");

 $dbi = DBIx::Custom->connect($NEW_ARGS->{0});

 $dbi->execute($CREATE_TABLE->{0});

@@ -635,7 +632,7 @@ $result = $dbi->select(

 $result->filter({'key2' => 'twice'});

 $rows   = $result->fetch_hash_all;

-is_deeply($rows, [{key2 => 4, key3 => 18}], "$test : select : join");

+is_deeply($rows, [{key2 => 4, key3 => 18}], "select : join");

 $result = $dbi->select(

      table => ['table1', 'table2'],

@@ -644,7 +641,7 @@ $result = $dbi->select(

 $result->filter({'key2' => 'twice'});

 $rows   = $result->fetch_hash_all;

-is_deeply($rows, [{key2 => 4, key3 => 18}], "$test : select : join : omit");

+is_deeply($rows, [{key2 => 4, key3 => 18}], "select : join : omit");

 test 'each_column';

 $dbi = DBIx::Custom->connect($NEW_ARGS->{0});

@@ -668,7 +665,7 @@ is_deeply($infos,

         ['table2', 'key1', 'key1'],

         ['table2', 'key3', 'key3']

     ]

-    , $test

+    

 );

 test 'table';

@@ -679,25 +676,25 @@ $table->insert(param => {key1 => 1, key2 => 2});

 $table->insert(param => {key1 => 3, key2 => 4});

 $rows = $table->select->fetch_hash_all;

 is_deeply($rows, [{key1 => 1, key2 => 2}, {key1 => 3, key2 => 4}],

-                 "$test: select");

+                 "select");

 $rows = $table->select(where => {key2 => 2}, append => 'order by key1',

                               column => ['key1', 'key2'])->fetch_hash_all;

 is_deeply($rows, [{key1 => 1, key2 => 2}],

-                 "$test: insert insert select");

+                 "insert insert select");

 $table->update(param => {key1 => 3}, where => {key2 => 2});

 $table->update(param => {key1 => 5}, where => {key2 => 4});

 $rows = $table->select(where => {key2 => 2})->fetch_hash_all;

 is_deeply($rows, [{key1 => 3, key2 => 2}],

-                 "$test: update");

+                 "update");

 $table->delete(where => {key2 => 2});

 $rows = $table->select->fetch_hash_all;

-is_deeply($rows, [{key1 => 5, key2 => 4}], "$test: delete");

+is_deeply($rows, [{key1 => 5, key2 => 4}], "delete");

 $table->update_all(param => {key1 => 3});

 $rows = $table->select->fetch_hash_all;

-is_deeply($rows, [{key1 => 3, key2 => 4}], "$test: update_all");

+is_deeply($rows, [{key1 => 3, key2 => 4}], "update_all");

 $table->delete_all;

 $rows = $table->select->fetch_hash_all;

-is_deeply($rows, [], "$test: delete_all");

+is_deeply($rows, [], "delete_all");

 $dbi->dbh->do($CREATE_TABLE->{2});

 $dbi->table('table2', ppp => sub {

@@ -705,14 +702,14 @@ $dbi->table('table2', ppp => sub {

     return $self->name;

 });

-is($dbi->table('table2')->ppp, 'table2', "$test : helper");

+is($dbi->table('table2')->ppp, 'table2', "helper");

 $dbi->table('table2', {qqq => sub {

     my $self = shift;

     return $self->name;

 }});

-is($dbi->table('table2')->qqq, 'table2', "$test : helper");

+is($dbi->table('table2')->qqq, 'table2', "helper");

 test 'limit';

@@ -737,19 +734,19 @@ $rows = $dbi->select(

   where => {key1 => 1},

   append => "order by key2 {limit 1 0}"

 )->fetch_hash_all;

-is_deeply($rows, [{key1 => 1, key2 => 2}], $test);

+is_deeply($rows, [{key1 => 1, key2 => 2}]);

 $rows = $dbi->select(

   table => 'table1',

   where => {key1 => 1},

   append => "order by key2 {limit 2 1}"

 )->fetch_hash_all;

-is_deeply($rows, [{key1 => 1, key2 => 4},{key1 => 1, key2 => 6}], $test);

+is_deeply($rows, [{key1 => 1, key2 => 4},{key1 => 1, key2 => 6}]);

 $rows = $dbi->select(

   table => 'table1',

   where => {key1 => 1},

   append => "order by key2 {limit 1}"

 )->fetch_hash_all;

-is_deeply($rows, [{key1 => 1, key2 => 2}], $test);

+is_deeply($rows, [{key1 => 1, key2 => 2}]);

 test 'connect super';

 {

@@ -772,12 +769,12 @@ test 'connect super';

 $dbi = MyDBI->connect($NEW_ARGS->{0});

 $dbi->execute($CREATE_TABLE->{0});

 $dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});

-is($dbi->select(table => 'table1')->fetch_hash_first->{key1}, 1, $test);

+is($dbi->select(table => 'table1')->fetch_hash_first->{key1}, 1);

 $dbi = MyDBI->new($NEW_ARGS->{0});

 $dbi->execute($CREATE_TABLE->{0});

 $dbi->insert(table => 'table1', param => {key1 => 1, key2 => 2});

-is($dbi->select(table => 'table1')->fetch_hash_first->{key1}, 1, $test);

+is($dbi->select(table => 'table1')->fetch_hash_first->{key1}, 1);

 test 'end_filter';

@@ -7,9 +7,7 @@ use DBIx::Custom::QueryBuilder;

 # Function for test name

 my $test;

-sub test {

-    $test = shift;

-}

+sub test { "# $_[0]\n" }

 # Variables for test

 my $dbi;

@@ -32,7 +30,7 @@ $dbi = DBIx::Custom->new(

 is_deeply($dbi,{user => 'a', password => 'b', data_source => 'c', 

                 filters => {f => 3}, default_bind_filter => 'f',

                 default_fetch_filter => 'g', result_class => 'g',

-                query_builder => $query_builder}, $test);

+                query_builder => $query_builder});

 isa_ok($dbi, 'DBIx::Custom');

@@ -47,7 +45,7 @@ $dbi = DBIx::Custom::T1->new(

         fo => 30,

     },

 );

-is_deeply(scalar $dbi->filters, {fo => 30}, "$test : filters");

+is_deeply(scalar $dbi->filters, {fo => 30}, "filters");

 test 'Sub sub class constructor default';

 {

@@ -74,16 +72,16 @@ $dbi = DBIx::Custom::T1_3->new(

         f => 3,

     },

 );

-is_deeply($dbi->filters, {f => 3}, "$test : filters");

+is_deeply($dbi->filters, {f => 3}, "filters");

 isa_ok($dbi, 'DBIx::Custom');

 test 'register_filters';

 $dbi = DBIx::Custom->new;

 $dbi->register_filter(a => sub {1});

-is($dbi->filters->{a}->(), 1, $test);

+is($dbi->filters->{a}->(), 1);

 $dbi->register_filter({b => sub {2}});

-is($dbi->filters->{b}->(), 2, $test);

+is($dbi->filters->{b}->(), 2);

 test 'expand';

@@ -102,4 +100,4 @@ test 'expand';

 test 'invalid attribute name';

 eval {$dbi = DBIx::Custom->new(a => 1) };

-like ($@, qr/"a" is invalid attribute name/, $test);

+like ($@, qr/"a" is invalid attribute name/);

@@ -10,11 +10,7 @@ plan skip_all => 'private MySQL test' unless $USER;

 plan 'no_plan';

 # Function for test name

-my $test;

-sub test {

-    $test = shift;

-}

-

+sub test { print "# $_[0]\n" }

 # Functions for tests

 sub connect_info {

@@ -47,15 +43,15 @@ test 'connect';

 $dbi = DBIx::Custom::MySQL->new(user => $USER, password => $PASSWORD,

                     database => $DATABASE, host => 'localhost', port => '10000');

 $dbi->connect;

-like($dbi->data_source, qr/dbi:mysql:database=.*;host=localhost;port=10000;/, "$test : created data source");

-is(ref $dbi->dbh, 'DBI::db', $test);

+like($dbi->data_source, qr/dbi:mysql:database=.*;host=localhost;port=10000;/, "created data source");

+is(ref $dbi->dbh, 'DBI::db');

 test 'attributes';

 $dbi = DBIx::Custom::MySQL->new;

 $dbi->host('a');

-is($dbi->host, 'a', "$test: host");

+is($dbi->host, 'a', "host");

 $dbi->port('b');

-is($dbi->port, 'b', "$test: port");

+is($dbi->port, 'b', "port");

 test 'limit';

 $dbi = DBIx::Custom->connect(

@@ -83,17 +79,17 @@ $rows = $dbi->select(

   where => {key1 => 1},

   append => "order by key2 {limit 1 0}"

 )->fetch_hash_all;

-is_deeply($rows, [{key1 => 1, key2 => 2}], $test);

+is_deeply($rows, [{key1 => 1, key2 => 2}]);

 $rows = $dbi->select(

   table => 'table1',

   where => {key1 => 1},

   append => "order by key2 {limit 2 1}"

 )->fetch_hash_all;

-is_deeply($rows, [{key1 => 1, key2 => 4},{key1 => 1, key2 => 6}], $test);

+is_deeply($rows, [{key1 => 1, key2 => 4},{key1 => 1, key2 => 6}]);

 $rows = $dbi->select(

   table => 'table1',

   where => {key1 => 1},

   append => "order by key2 {limit 1}"

 )->fetch_hash_all;

-is_deeply($rows, [{key1 => 1, key2 => 2}], $test);

+is_deeply($rows, [{key1 => 1, key2 => 2}]);

 $dbi->delete_all(table => 'table1');

@@ -5,10 +5,7 @@ use warnings;

 use DBIx::Custom::Query;

 # Function for test name

-my $test;

-sub test{

-    $test = shift;

-}

+sub test{ "# $_[0]\n" }

 # Variables for test

 my $query;

@@ -22,8 +19,8 @@ $query = DBIx::Custom::Query->new(

     fetch_filter     => 'f',

 );

-is($query->sql, 'a', "$test : sql");

-is($query->columns, 'b', "$test : columns ");

-is($query->filter, 'c', "$test : filter");

-is($query->sth, 'e', "$test : sth");

+is($query->sql, 'a', "sql");

+is($query->columns, 'b', "columns ");

+is($query->filter, 'c', "filter");

+is($query->sth, 'e', "sth");

@@ -6,10 +6,7 @@ use Test::More 'no_plan';

 use DBIx::Custom::QueryBuilder;

 # Function for test name

-my $test;

-sub test{

-    $test = shift;

-}

+sub test{ "# $_[0]\n" }

 # Variable for test

 my $datas;

@@ -59,8 +56,8 @@ for (my $i = 0; $i < @$datas; $i++) {

     my $data = $datas->[$i];

     my $builder = DBIx::Custom::QueryBuilder->new;

     my $query = $builder->build_query($data->{source});

-    is($query->{sql}, $data->{sql_expected}, "$test : $data->{name} : sql");

-    is_deeply($query->{columns}, $data->{columns_expected}, "$test : $data->{name} : columns");

+    is($query->{sql}, $data->{sql_expected}, "$data->{name} : sql");

+    is_deeply($query->{columns}, $data->{columns_expected}, "$data->{name} : columns");

 }

@@ -78,8 +75,8 @@ $ret_val = $builder->register_tag_processor(

 );

 $query = $builder->build_query("{p a b}");

-is($query->{sql}, "? a b;", "$test : register_tag_processor sql");

-is_deeply($query->{columns}, [2], "$test : register_tag_processor columns");

+is($query->{sql}, "? a b;", "register_tag_processor sql");

+is_deeply($query->{columns}, [2], "register_tag_processor columns");

 isa_ok($ret_val, 'DBIx::Custom::QueryBuilder');

@@ -87,31 +84,31 @@ test "Tag processor error case";

 $builder = DBIx::Custom::QueryBuilder->new;

 eval{$builder->build_query('{? }')};

-like($@, qr/\QColumn name must be specified in tag "{? }"/, "$test : ? not arguments");

+like($@, qr/\QColumn name must be specified in tag "{? }"/, "? not arguments");

 eval{$builder->build_query("{a }")};

-like($@, qr/\QTag "a" in "{a }" is not registered/, "$test : tag_processor not exist");

+like($@, qr/\QTag "a" in "{a }" is not registered/, "tag_processor not exist");

 $builder->register_tag_processor({

     q => 'string'

 });

 eval{$builder->build_query("{q}", {})};

-like($@, qr/Tag processor "q" must be sub reference/, "$test : tag_processor not code ref");

+like($@, qr/Tag processor "q" must be sub reference/, "tag_processor not code ref");

 $builder->register_tag_processor({

    r => sub {} 

 });

 eval{$builder->build_query("{r}")};

-like($@, qr/\QTag processor "r" must return [STRING, ARRAY_REFERENCE]/, "$test : tag processor return noting");

+like($@, qr/\QTag processor "r" must return [STRING, ARRAY_REFERENCE]/, "tag processor return noting");

 $builder->register_tag_processor({

    s => sub { return ["a", ""]} 

 });

 eval{$builder->build_query("{s}")};

-like($@, qr/\QTag processor "s" must return [STRING, ARRAY_REFERENCE]/, "$test : tag processor return not array columns");

+like($@, qr/\QTag processor "s" must return [STRING, ARRAY_REFERENCE]/, "tag processor return not array columns");

 $builder->register_tag_processor(

     t => sub {return ["a", []]}

@@ -126,47 +123,47 @@ $builder->register_tag_processor(

     }

 );

 eval{$builder->build_query("{a}")};

-like($@, qr/\QPlaceholder count in "? ? ?" must be same as column count 1/, "$test : placeholder count is invalid");

+like($@, qr/\QPlaceholder count in "? ? ?" must be same as column count 1/, "placeholder count is invalid");

 test 'Default tag processor Error case';

 eval{$builder->build_query("{= }")};

-like($@, qr/Column name must be specified in tag "{= }"/, "$test : basic '=' : key not exist");

+like($@, qr/Column name must be specified in tag "{= }"/, "basic '=' : key not exist");

 eval{$builder->build_query("{in }")};

-like($@, qr/Column name and count of values must be specified in tag "{in }"/, "$test : in : key not exist");

+like($@, qr/Column name and count of values must be specified in tag "{in }"/, "in : key not exist");

 eval{$builder->build_query("{in a}")};

 like($@, qr/\QColumn name and count of values must be specified in tag "{in }"/,

-     "$test : in : key not exist");

+     "in : key not exist");

 eval{$builder->build_query("{in a r}")};

 like($@, qr/\QColumn name and count of values must be specified in tag "{in }"/,

-     "$test : in : key not exist");

+     "in : key not exist");

 test 'variouse source';

 $source = "a {= b} c \\{ \\} {= \\{} {= \\}} d;";

 $query = $builder->build_query($source);

-is($query->sql, 'a b = ? c { } { = ? } = ? d;', "$test : basic : 1");

+is($query->sql, 'a b = ? c { } { = ? } = ? d;', "basic : 1");

 $source = "abc;";

 $query = $builder->build_query($source);

-is($query->sql, 'abc;', "$test : basic : 2");

+is($query->sql, 'abc;', "basic : 2");

 $source = "{= a}";

 $query = $builder->build_query($source);

-is($query->sql, 'a = ?;', "$test : only tag");

+is($query->sql, 'a = ?;', "only tag");

 $source = "000;";

 $query = $builder->build_query($source);

-is($query->sql, '000;', "$test : contain 0 value");

+is($query->sql, '000;', "contain 0 value");

 $source = "a {= b} }";

 eval{$builder->build_query($source)};

-like($@, qr/unexpected "}"/, "$test : error : 1");

+like($@, qr/unexpected "}"/, "error : 1");

 $source = "a {= {}";

 eval{$builder->build_query($source)};

-like($@, qr/unexpected "{"/, "$test : error : 2");

+like($@, qr/unexpected "{"/, "error : 2");

@@ -14,10 +14,7 @@ BEGIN {

 }

 # Function for test name

-my $test;

-sub test {

-    $test = shift;

-}

+sub test { "# $_[0]\n" }

 # Constant varialbes for test

 my $CREATE_TABLE = {

@@ -37,25 +34,25 @@ my $id;

 test 'connect_memory';

 $dbi = DBIx::Custom::SQLite->connect_memory;

 $ret_val = $dbi->execute($CREATE_TABLE->{0});

-ok(defined $ret_val, $test);

+ok(defined $ret_val);

 $dbi->insert(table => 'table1', param => {key1 => 'a', key2 => 2});

 $rows = $dbi->select(table => 'table1', where => {key1 => 'a'})->fetch_hash_all;

-is_deeply($rows, [{key1 => 'a', key2 => 2}], "$test : select rows");

+is_deeply($rows, [{key1 => 'a', key2 => 2}], "select rows");

 test 'connect';

 $db_file  = 't/test.db';

 unlink $db_file if -f $db_file;

 $dbi = DBIx::Custom::SQLite->new(database => $db_file);

 $dbi->connect;

-ok(-f $db_file, "$test : database file");

+ok(-f $db_file, "database file");

 $ret_val = $dbi->execute($CREATE_TABLE->{0});

-ok(defined $ret_val, "$test : database");

+ok(defined $ret_val, "database");

 $dbi->dbh->disconnect;

 unlink $db_file if -f $db_file;

 $dbi = DBIx::Custom::SQLite->connect(database => $db_file);

-ok($dbi, "$test : called from class name");

+ok($dbi, "called from class name");

 unlink $db_file if -f $db_file;

 $dbi = DBIx::Custom::SQLite->connect(data_source => "dbi:SQLite:dbname=$db_file");

-ok($dbi, "$test : specified data source");

+ok($dbi, "specified data source");

@@ -8,8 +8,7 @@ plan 'no_plan';

 use DBIx::Custom;

 # Function for test name

-my $test;

-sub test {$test = shift }

+sub test { "# $_[0]\n" }

 # Constant varialbes for test

 my $CREATE_TABLE = {

@@ -36,7 +35,7 @@ $dbi->execute($CREATE_TABLE->{0});

 }

 $result = $dbi->select(table => 'table1');

 is_deeply(scalar $result->fetch_hash_all, [{key1 => 1, key2 => 2}, {key1 => 2, key2 => 3}],

-          "$test : commit");

+          "commit");

 $dbi = DBIx::Custom->connect($NEW_ARGS->{0});

 $dbi->execute($CREATE_TABLE->{0});

@@ -49,5 +48,5 @@ $dbi->execute($CREATE_TABLE->{0});

     }

 }

 $result = $dbi->select(table => 'table1');

-ok(! $result->fetch_first, "$test: rollback");

+ok(! $result->fetch_first, "rollback");

@@ -1,18 +0,0 @@

-use strict;

-use warnings;

-use Test::More;

-

-# Ensure a recent version of Test::Pod::Coverage

-my $min_tpc = 1.08;

-eval "use Test::Pod::Coverage $min_tpc";

-plan skip_all => "Test::Pod::Coverage $min_tpc required for testing POD coverage"

-    if $@;

-

-# Test::Pod::Coverage doesn't require a minimum Pod::Coverage version,

-# but older versions don't recognize some common documentation styles

-my $min_pc = 0.18;

-eval "use Pod::Coverage $min_pc";

-plan skip_all => "Pod::Coverage $min_pc required for testing POD coverage"

-    if $@;

-

-all_pod_coverage_ok({also_private => [qr/default_bind_filter|default_fetch_filter|default_filter/]});