@@ -179,7 +179,7 @@ sub create_query {

     my $table = '';

     if (ref $template eq 'ARRAY') {

-        $table    = $template->[0];

+        $table    = $template->[0] if $template->[0];

         $template = $template->[1];

     }

@@ -198,10 +198,11 @@ sub create_query {

         );

     }

     else {

-        $query = eval{$sql_tmpl->create_query([$table , $template])};

+        $sql_tmpl->table($table);

+        $query = eval{$sql_tmpl->create_query($template)};

         croak($@) if $@;

-        $class->_add_query_cache($template, $query);

+        $class->_add_query_cache("$table$template", $query);

     }

     # Connect if not

@@ -229,14 +230,21 @@ sub create_query {

 }

 sub query{

-    my ($self, $query, $params)  = @_;

+    my ($self, $query, $params, $query_edit_cb)  = @_;

     $params ||= {};

     # First argument is SQL template

-    if (!ref $query) {

-        my $template = $query;

-        $query = $self->create_query($template);

-        my $query_edit_cb = $_[3];

+    unless (ref $query eq 'DBIx::Custom::Query') {

+        my $table;

+        my $template;

+        

+        if (ref $query eq 'ARRAY') {

+            $table    = $query->[0];

+            $template = $query->[1];

+        }

+        else { $template = $query }

+        

+        $query = $self->create_query([$table, $template]);

         $query_edit_cb->($query) if ref $query_edit_cb eq 'CODE';

     }

@@ -279,112 +287,32 @@ sub query{

 sub _build_bind_values {

     my ($self, $query, $params) = @_;

-    my $key_infos           = $query->key_infos;

-    my $bind_filter         = $query->bind_filter;

-    my $no_bind_filters     = $query->_no_bind_filters || {};

+    my $key_infos  = $query->key_infos;

+    my $filter     = $query->bind_filter;

     # binding values

     my @bind_values;

-    # Create bind values

-    KEY_INFOS :

+    # Build bind values

     foreach my $key_info (@$key_infos) {

-        # Set variable

-        my $access_keys  = $key_info->{access_keys};

-        my $original_key = $key_info->{original_key} || '';

-        my $table        = $key_info->{table}        || '';

-        my $column       = $key_info->{column}       || '';

+        my $table        = $key_info->table;

+        my $column       = $key_info->column;

+        my $id           = $key_info->id;

+        my $pos          = $key_info->pos;

-        # Key is found?

-        my $found;

+        # Value

+        my $value = $id && $pos ? $params->{$id}->{$column}->[$pos]

+                  : $id         ? $params->{$id}->{$column}

+                  : $pos        ? $params->{$column}->[$pos]

+                  : $params->{$column};

-        # Build bind values

-        ACCESS_KEYS :

-        foreach my $access_key (@$access_keys) {

-            # Root parameter

-            my $root_params = $params;

-            

-            # Search corresponding value

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

-                # Current key

-                my $current_key = $access_key->[$i];

-                

-                # Last key

-                if ($i == @$access_key - 1) {

-                    # Key is array reference

-                    if (ref $current_key eq 'ARRAY') {

-                        push @bind_values, 

-                             $self->_filter($root_params->[$current_key->[0]], 

-                                            $key_info, $query);

-                    }

-                    # Key is string

-                    else {

-                        # Key is not found

-                        next ACCESS_KEYS

-                          unless exists $root_params->{$current_key};

-                        

-                        push @bind_values,

-                             $self->_filter($root_params->{$current_key},

-                                            $key_info, $query);

-                    }

-                    

-                    # Key is found

-                    $found = 1;

-                    next KEY_INFOS;

-                }

-                # First or middle key

-                else {

-                    # Key is array reference

-                    if (ref $current_key eq 'ARRAY') {

-                        # Go next key

-                        $root_params = $root_params->[$current_key->[0]];

-                    }

-                    # Key is string

-                    else {

-                        # Not found

-                        next ACCESS_KEYS

-                          unless exists $root_params->{$current_key};

-                        

-                        # Go next key

-                        $root_params = $root_params->{$current_key};

-                    }

-                }

-            }

-        }

-        

-        # Key is not found

-        unless ($found) {

-            require Data::Dumper;

-            my $key_info_dump  = Data::Dumper->Dump([$key_info], ['*key_info']);

-            my $params_dump    = Data::Dumper->Dump([$params], ['*params']);

-            croak("Corresponding key is not found in your parameters\n" . 

-                  "<Key information>\n$key_info_dump\n\n" .

-                  "<Your parameters>\n$params_dump\n");

-        }

-    }

-    return \@bind_values;

-}

-

-sub _filter {

-    my ($self, $value, $key_info, $query) = @_;

-    

-    my $bind_filter     = $query->bind_filter;

-    my $no_bind_filters = $query->_no_bind_filters || {};

-    

-    my $original_key = $key_info->{original_key} || '';

-    my $table        = $key_info->{table}        || '';

-    my $column       = $key_info->{column}       || '';

-    

-    # Filtering 

-    if ($bind_filter &&

-        !$no_bind_filters->{$original_key})

-    {

-        return $bind_filter->($value, $original_key, $self,

-                              {table => $table, column => $column});

+        # Filter

+        push @bind_values, 

+             $filter ? $filter->($value, $table, $column, $self->filters)

+                     : $value;

     }

-    # Not filtering

-    return $value;

+    return \@bind_values;

 }

 sub transaction { DBIx::Custom::Transaction->new(dbi => shift) }

@@ -436,7 +364,7 @@ sub insert {

     my $template = "insert into $table {insert " . join(' ', @insert_keys) . '}';

     $template .= " $append_statement" if $append_statement;

     # Create query

-    my $query = $self->create_query($template);

+    my $query = $self->create_query([$table, $template]);

     # Query edit callback must be code reference

     croak("Query edit callback must be code reference")

@@ -492,7 +420,7 @@ sub update {

     $template .= " $append_statement" if $append_statement;

     # Create query

-    my $query = $self->create_query($template);

+    my $query = $self->create_query([$table, $template]);

     # Query edit callback must be code reference

     croak("Query edit callback must be code reference")

@@ -553,7 +481,7 @@ sub delete {

     $template .= " $append_statement" if $append_statement;

     # Create query

-    my $query = $self->create_query($template);

+    my $query = $self->create_query([$table, $template]);

     # Query edit callback must be code reference

     croak("Query edit callback must be code reference")

@@ -657,7 +585,7 @@ sub select {

     }

     # Create query

-    my $query = $self->create_query($template);

+    my $query = $self->create_query([$tables->[0], $template]);

     # Query edit

     $query_edit_cb->($query) if $query_edit_cb;

@@ -4,11 +4,12 @@ use warnings;

 use strict;

 use base 'DBIx::Custom';

+

 use Encode qw/decode encode/;

 __PACKAGE__->add_filter(

-    encode_utf8 => sub { encode('UTF-8', shift) },

-    decode_utf8 => sub { decode('UTF-8', shift) }

+    encode_utf8 => sub { encode('UTF-8', $_[0]) },

+    decode_utf8 => sub { decode('UTF-8', $_[0]) }

 );

 __PACKAGE__->add_format(

@@ -20,16 +21,6 @@ __PACKAGE__->add_format(

     'ISO-8601_time'     => '%H:%M:%S',

 );

-sub utf8_filter_on {

-    my $self = shift;

-    

-    # Set utf8 filters

-    $self->bind_filter($self->filters->{encode_utf8});

-    $self->fetch_filter($self->filters->{decode_utf8});

-    

-    return $self;

-}

-

 1;

 =head1 NAME

@@ -50,17 +41,6 @@ DBIx::Custom::Basic - DBIx::Custom basic implementation

 This class is L<DBIx::Custom> subclass.

 You can use all methods of L<DBIx::Custom>

-=head2 utf8_filter_on

-

-Encode and decode utf8 filter on

-

-    $dbi->utf8_filter_on;

-

-This equel to

-

-    $dbi->bind_filter($dbi->filters->{encode_utf8});

-    $dbi->fetch_filter($dbi->filters->{decode_utf8});

-

 =head1 FILTERS

 =head2 encode_utf8

@@ -83,7 +63,7 @@ This filter is generally used as fetch filter

     $dbi->fetch_filter($dbi->filters->{decode_utf8});

-=head1 DATE FORMATS

+=head1 FORMATS

 strptime formats is available

@@ -0,0 +1,82 @@

+package DBIx::Custom::KeyInfo;

+

+use strict;

+use warnings;

+

+use base 'Object::Simple';

+

+__PACKAGE__->attr([qw/column id table pos/]);

+

+sub new {

+    my $self = shift;

+    

+    if (@_ == 1) {

+        $self = $self->SUPER::new;

+        $self->parse($_[0]);

+        return $self;

+    }

+    

+    return $self->SUPER::new(@_);

+}

+

+sub parse {

+    my ($self, $key) = @_;

+    

+    # Parse

+    ($key || '') =~ /^(?:(.+?)\.)?(.+?)(?:@(.+))?$/;

+    $self->table($1);

+    $self->column($2);

+    $self->id($3);

+    

+    return $self;

+}

+

+1;

+

+=head1 NAME

+

+DBIx::Custom::KeyInfo - DBIx::Custom column

+

+=head1 SYNOPSIS

+    

+    # New

+    my $key_info = DBIx::Custom::KeyInfo->new;

+    

+    # Parse

+    $key_info->parse('books.author@IDxxx');

+    

+    # Attributes

+    my $name  = $key_info->name;

+    my $table = $key_info->table;

+    my $id    = $key_info->id;

+

+=head1 ATTRIBUTES

+

+=head2 id

+

+    $key_info = $key_info->id($id);

+    $id     = $key_info->id

+

+=head2 name

+

+    $key_info = $key_info->name($name);

+    $name   = $key_info->name

+

+=head2 table

+

+    $key_info = $key_info->table($table);

+    $table  = $key_info->table

+

+=head1 METHODS

+

+=head2 new

+

+    $key_info = DBIx::Custom::KeyInfo->new(\%args);

+    $key_info = DBIx::Custom::KeyInfo->new(%args);

+    $key_info = DBIx::Custom::KeyInfo->new('books.author@where');

+

+=head2 parse

+

+    $key_info->parse('books.author@IDxxx');

+

+=cut

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

 use Carp 'croak';

 use DBIx::Custom::Query;

+__PACKAGE__->attr('table');

 __PACKAGE__->dual_attr('tag_processors', default => sub { {} },

                                          inherit => 'hash_copy');

@@ -176,7 +177,7 @@ sub _build_query {

             # Expand tag using tag processor

             my ($expand, $key_infos)

-              = $tag_processor->($tag_name, $tag_args);

+              = $tag_processor->($tag_name, $tag_args, $self->table);

             # Check tag processor return value

             croak("Tag processor '$tag_name' must return (\$expand, \$key_infos)")

@@ -224,61 +225,37 @@ use strict;

 use warnings;

 use Carp 'croak';

-use DBIx::Custom::Column;

+use DBIx::Custom::KeyInfo;

 sub expand_basic_tag {

-    my ($tag_name, $tag_args) = @_;

-    my $original_key = $tag_args->[0];

+    my ($tag_name, $tag_args, $table) = @_;

+    

+    # Key

+    my $key = $tag_args->[0];

     # Key is not exist

     croak("You must be pass key as argument to tag '{$tag_name }'")

-      if !$original_key;

+      unless $key;

     # Expanded tag

     my $expand = $tag_name eq '?'

                ? '?'

-               : "$original_key $tag_name ?";

-    

-    # Get table and clumn name

-    my $c = DBIx::Custom::Column->new;

-    $c->parse($original_key);

-    my $table  = $c->table;

-    my $column = $c->column;

-    

-    # Parameter key infomation

-    my $key_info = {};

-    

-    # Original key

-    $key_info->{original_key} = $original_key;

+               : "$key $tag_name ?";

-    # Table

-    $key_info->{table}  = $table;

-    

-    # Column name

-    $key_info->{column} = $column;

-    

-    # Access keys

-    my $access_keys = [];

-    push @$access_keys, [$original_key];

-    push @$access_keys, [$table, $column] if $table && $column;

-    $key_info->{access_keys} = $access_keys;

-    

-    # Add parameter key information

-    my $key_infos = [];

-    push @$key_infos, $key_info;

+    my $key_info = DBIx::Custom::KeyInfo->new($key);

+    $key_info->table($table) unless $key_info->table;

-    return ($expand, $key_infos);

+    return ($expand, [$key_info]);

 }

 sub expand_in_tag {

-    my ($tag_name, $tag_args) = @_;

-    my ($original_key, $placeholder_count) = @$tag_args;

+    my ($tag_name, $tag_args, $table) = @_;

+    my ($key, $placeholder_count) = @$tag_args;

     # Key must be specified

     croak("You must be pass key as first argument of tag '{$tag_name }'\n" . 

           "Usage: {$tag_name \$key \$placeholder_count}")

-      unless $original_key;

-      

+      unless $key;

     # Place holder count must be specified

     croak("You must be pass placeholder count as second argument of tag '{$tag_name }'\n" . 

@@ -286,7 +263,7 @@ sub expand_in_tag {

       if !$placeholder_count || $placeholder_count =~ /\D/;

     # Expand tag

-    my $expand = "$original_key $tag_name (";

+    my $expand = "$key $tag_name (";

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

         $expand .= '?, ';

     }

@@ -294,34 +271,14 @@ sub expand_in_tag {

     $expand =~ s/, $//;

     $expand .= ')';

-    # Get table and clumn name

-    my $c = DBIx::Custom::Column->new;

-    $c->parse($original_key);

-    my $table  = $c->table;

-    my $column = $c->column;

-    

     # Create parameter key infomations

     my $key_infos = [];

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

-        # Parameter key infomation

-        my $key_info = {};

-        

-        # Original key

-        $key_info->{original_key} = $original_key;

-        

-        # Table

-        $key_info->{table}   = $table;

-        

-        # Column name

-        $key_info->{column}  = $column;

-        

-        # Access keys

-        my $access_keys = [];

-        push @$access_keys, [$original_key, [$i]];

-        push @$access_keys, [$table, $column, [$i]] if $table && $column;

-        $key_info->{access_keys} = $access_keys;

         # Add parameter key infos

+        my $key_info = DBIx::Custom::KeyInfo->new($key);

+        $key_info->table($table) unless $key_info->table;

+        $key_info->pos($i);

         push @$key_infos, $key_info;

     }

@@ -329,8 +286,8 @@ sub expand_in_tag {

 }

 sub expand_insert_tag {

-    my ($tag_name, $tag_args) = @_;

-    my $original_keys = $tag_args;

+    my ($tag_name, $tag_args, $table) = @_;

+    my $keys = $tag_args;

     # Insert key (k1, k2, k3, ..)

     my $insert_keys = '(';

@@ -338,12 +295,10 @@ sub expand_insert_tag {

     # placeholder (?, ?, ?, ..)

     my $place_holders = '(';

-    foreach my $original_key (@$original_keys) {

+    foreach my $key (@$keys) {

         # Get table and clumn name

-        my $c = DBIx::Custom::Column->new;

-        $c->parse($original_key);

-        my $table  = $c->table;

-        my $column = $c->column;

+        my $key_info = DBIx::Custom::KeyInfo->new($key);

+        my $column   = $key_info->column;

         # Join insert column

         $insert_keys   .= "$column, ";

@@ -365,32 +320,9 @@ sub expand_insert_tag {

     # Create parameter key infomations

     my $key_infos = [];

-    foreach my $original_key (@$original_keys) {

-        # Get table and clumn name

-        my $c = DBIx::Custom::Column->new;

-        $c->parse($original_key);

-        my $table  = $c->table;

-        my $column = $c->column;

-        

-        # Parameter key infomation

-        my $key_info = {};

-        

-        # Original key

-        $key_info->{original_key} = $original_key;

-        

-        # Table

-        $key_info->{table}   = $table;

-        

-        # Column name

-        $key_info->{column}  = $column;

-        

-        # Access keys

-        my $access_keys = [];

-        push @$access_keys, [$original_key];

-        push @$access_keys, [$table, $column] if $table && $column;

-        $key_info->{access_keys} = $access_keys;

-        

-        # Add parameter key infos

+    foreach my $key (@$keys) {

+        my $key_info = DBIx::Custom::KeyInfo->new($key);

+        $key_info->table($table) unless $key_info->table;

         push @$key_infos, $key_info;

     }

@@ -398,19 +330,16 @@ sub expand_insert_tag {

 }

 sub expand_update_tag {

-    my ($tag_name, $tag_args) = @_;

-    my $original_keys = $tag_args;

+    my ($tag_name, $tag_args, $table) = @_;

+    my $keys = $tag_args;

     # Expanded tag

     my $expand = 'set ';

-    # 

-    foreach my $original_key (@$original_keys) {

+    foreach my $key (@$keys) {

         # Get table and clumn name

-        my $c = DBIx::Custom::Column->new;

-        $c->parse($original_key);

-        my $table  = $c->table;

-        my $column = $c->column;

+        my $key_info = DBIx::Custom::KeyInfo->new($key);

+        my $column = $key_info->column;

         # Join key and placeholder

         $expand .= "$column = ?, ";

@@ -419,34 +348,10 @@ sub expand_update_tag {

     # Delete last ', '

     $expand =~ s/, $//;

-    # Create parameter key infomations

     my $key_infos = [];

-    foreach my $original_key (@$original_keys) {

-        # Get table and clumn name

-        my $c = DBIx::Custom::Column->new;

-        $c->parse($original_key);

-        my $table  = $c->table;

-        my $column = $c->column;

-        

-        # Parameter key infomation

-        my $key_info = {};

-        

-        # Original key

-        $key_info->{original_key} = $original_key;

-        

-        # Table

-        $key_info->{table}  = $table;

-        

-        # Column name

-        $key_info->{column} = $column;

-        

-        # Access keys

-        my $access_keys = [];

-        push @$access_keys, [$original_key];

-        push @$access_keys, [$table, $column] if $table && $column;

-        $key_info->{access_keys} = $access_keys;

-        

-        # Add parameter key infos

+    foreach my $key (@$keys) {

+        my $key_info = DBIx::Custom::KeyInfo->new($key);

+        $key_info->table($table) unless $key_info->table;

         push @$key_infos, $key_info;

     }

@@ -619,3 +524,4 @@ The following is update SQL sample

     $query->sql : "update table set key1 = ?, key2 = ? where key3 = ?;"

 =cut

+

@@ -180,17 +180,18 @@ $insert_tmpl = "insert into table1 {insert key1 key2}";

 $dbi->query($insert_tmpl, {key1 => 1, key2 => 2}, sub {

     my $query = shift;

     $query->bind_filter(sub {

-        my ($value, $key) = @_;

-        if ($key eq 'key2') {

+        my ($value, $table, $column) = @_;

+        if ($column eq 'key2') {

             return $value + 1;

         }

         return $value;

     });

 });

-$result = $dbi->query($SELECT_TMPL->{0});

+$result = $dbi->query(['table1', $SELECT_TMPL->{0}]);

 $rows = $result->fetch_hash_all;

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

+__END__

 test 'Filter basic';

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

@@ -199,11 +200,9 @@ $dbi->do($CREATE_TABLE->{0});

 $insert_tmpl  = "insert into table1 {insert key1 key2};";

 $insert_query = $dbi->create_query($insert_tmpl);

 $insert_query->bind_filter(sub {

-    my ($value, $key, $dbi, $infos) = @_;

-    my ($table, $column) = @{$infos}{qw/table column/};

+    my ($value, $table, $column) = @_;

-    if ($key eq 'key1' && $table eq '' && $column eq 'key1'

-        && $dbi->isa('DBIx::Custom'))

+    if ($table eq '' && $column eq 'key1')

     {

         return $value * 2;

     }

@@ -0,0 +1,69 @@

+use Test::More;

+use strict;

+use warnings;

+use utf8;

+use Encode qw/decode encode/;

+

+BEGIN {

+    eval { require DBD::SQLite; 1 }

+        or plan skip_all => 'DBD::SQLite required';

+    eval { DBD::SQLite->VERSION >= 1 }

+        or plan skip_all => 'DBD::SQLite >= 1.00 required';

+

+    plan 'no_plan';

+    use_ok('DBIx::Custom');

+}

+

+# Function for test name

+my $test;

+sub test {

+    $test = shift;

+}

+

+# Constant varialbes for test

+my $CREATE_TABLE = {

+    0 => 'create table table1 (key1 char(255), key2 char(255));',

+    1 => 'create table table1 (key1 char(255), key2 char(255), key3 char(255), key4 char(255), key5 char(255));',

+    2 => 'create table table2 (key1 char(255), key3 char(255));'

+};

+

+my $SELECT_TMPL = {

+    0 => 'select * from table1;'

+};

+

+my $DROP_TABLE = {

+    0 => 'drop table table1'

+};

+

+my $NEW_ARGS = {

+    0 => {data_source => 'dbi:SQLite:dbname=:memory:'}

+};

+

+# Variables for test

+my $dbi;

+my $decoded_str;

+my $encoded_str;

+my $array;

+my $ret_val;

+

+use DBIx::Custom::Basic;

+

+test 'Filter';

+$dbi = DBIx::Custom::Basic->new($NEW_ARGS->{0});

+ok($dbi->filters->{encode_utf8}, "$test : exists default_bind_filter");

+ok($dbi->filters->{decode_utf8}, "$test : exists default_fetch_filter");

+

+$ret_val = $dbi->utf8_filter_on;

+is($dbi->bind_filter, $dbi->filters->{encode_utf8}, 'default bind filter');

+is($dbi->fetch_filter, $dbi->filters->{decode_utf8}, 'default fetch filter');

+is(ref $ret_val, 'DBIx::Custom::Basic', "$test : retern value");

+

+$decoded_str = 'あ';

+$encoded_str = $dbi->bind_filter->($decoded_str);

+is($encoded_str, encode('UTF-8', $decoded_str), "$test : encode utf8");

+is($decoded_str, $dbi->fetch_filter->($encoded_str), "$test : fetch_filter");

+

+$decoded_str = 'a';

+$encoded_str = $dbi->bind_filter->($decoded_str);

+is($encoded_str, encode('UTF-8', $decoded_str), "$test : upgrade and encode utf8");

+is($decoded_str, $dbi->fetch_filter->($encoded_str), "$test : fetch_filter");

@@ -0,0 +1,67 @@

+use Test::More;

+use strict;

+use warnings;

+

+BEGIN {

+    eval { require Time::Piece; 1 }

+        or plan skip_all => 'Time::Piece required';

+    

+    eval { Time::Piece->VERSION >= 1.15 }

+        or plan skip_all => 'Time::Piece >= 1.15 requred';

+        

+    plan 'no_plan';

+    use_ok('DBIx::Custom');

+}

+

+# Function for test name

+my $test;

+sub test {

+    $test = shift;

+}

+

+# Varialbe for tests

+

+my $format;

+my $data;

+my $timepiece;

+my $dbi;

+

+use DBIx::Custom::Basic;

+

+

+test 'SQL99 format';

+$dbi = DBIx::Custom::Basic->new;

+$data   = '2009-01-02 03:04:05';

+$format = $dbi->formats->{'SQL99_datetime'};

+$timepiece = Time::Piece->strptime($data, $format);

+is($timepiece->strftime('%Y-%m-%d'), '2009-01-02', "$test : datetime date");

+is($timepiece->strftime('%H:%M:%S'), '03:04:05',  "$test : datetime time");

+

+$data   = '2009-01-02';

+$format = $dbi->formats->{'SQL99_date'};

+$timepiece = Time::Piece->strptime($data, $format);

+is($timepiece->strftime('%Y-%m-%d'), '2009-01-02', "$test : date");

+

+$data   = '03:04:05';

+$format = $dbi->formats->{'SQL99_time'};

+$timepiece = Time::Piece->strptime($data, $format);

+is($timepiece->strftime('%H:%M:%S'), '03:04:05',  "$test : time");

+

+

+test 'ISO-8601 format';

+$data   = '2009-01-02T03:04:05';

+$format = $dbi->formats->{'ISO-8601_datetime'};

+$timepiece = Time::Piece->strptime($data, $format);

+is($timepiece->strftime('%Y-%m-%d'), '2009-01-02', "$test : datetime date");

+is($timepiece->strftime('%H:%M:%S'), '03:04:05',  "$test : datetime time");

+

+$data   = '2009-01-02';

+$format = $dbi->formats->{'ISO-8601_date'};

+$timepiece = Time::Piece->strptime($data, $format);

+is($timepiece->strftime('%Y-%m-%d'), '2009-01-02', "$test : date");

+

+$data   = '03:04:05';

+$format = $dbi->formats->{'ISO-8601_time'};

+$timepiece = Time::Piece->strptime($data, $format);

+is($timepiece->strftime('%H:%M:%S'), '03:04:05',  "$test : time");

+

@@ -0,0 +1,36 @@

+use Test::More;

+use strict;

+use warnings;

+

+# user password database

+our ($USER, $PASSWORD, $DATABASE) = connect_info();

+

+plan skip_all => 'private MySQL test' unless $USER;

+

+plan 'no_plan';

+

+use DBIx::Custom;

+use Scalar::Util 'blessed';

+{

+    my $dbi = DBIx::Custom->new(

+        user => $USER,

+        password => $PASSWORD,

+        data_source => "dbi:mysql:dbname=$DATABASE"

+    );

+    $dbi->connect;

+    

+    ok(blessed $dbi->dbh);

+    can_ok($dbi->dbh, qw/prepare/);

+}

+

+sub connect_info {

+    my $file = 'password.tmp';

+    open my $fh, '<', $file

+      or return;

+    

+    my ($user, $password, $database) = split(/\s/, (<$fh>)[0]);

+    

+    close $fh;

+    

+    return ($user, $password, $database);

+}

@@ -0,0 +1,223 @@

+use Test::More 'no_plan';

+use strict;

+use warnings;

+

+use DBIx::Custom;

+use DBIx::Custom::SQL::Template;

+

+# Function for test name

+my $test;

+sub test {

+    $test = shift;

+}

+

+# Variables for test

+our $SQL_TMPL = {

+    0 => DBIx::Custom::SQL::Template->new->tag_start(0),

+    1 => DBIx::Custom::SQL::Template->new->tag_start(1),

+    2 => DBIx::Custom::SQL::Template->new->tag_start(2)

+};

+my $dbi;

+

+

+test 'Constructor';

+$dbi = DBIx::Custom->new(

+    user => 'a',

+    database => 'a',

+    password => 'b',

+    data_source => 'c',

+    options => {d => 1, e => 2},

+    filters => {

+        f => 3,

+    },

+    bind_filter => 'f',

+    fetch_filter => 'g',

+    result_class => 'g',

+    sql_tmpl => $SQL_TMPL->{0},

+);

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

+                options => {d => 1, e => 2}, filters => {f => 3}, bind_filter => 'f',

+                fetch_filter => 'g', result_class => 'g',

+                sql_tmpl => $SQL_TMPL->{0}}, $test);

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

+

+

+test 'Sub class constructor';

+{

+    package DBIx::Custom::T1;

+    use base 'DBIx::Custom';

+    

+    __PACKAGE__

+      ->user('a')

+      ->database('a')

+      ->password('b')

+      ->data_source('c')

+      ->options({d => 1, e => 2})

+      ->filters({f => 3})

+      ->formats({f => 3})

+      ->bind_filter('f')

+      ->fetch_filter('g')

+      ->result_class('DBIx::Custom::Result')

+      ->sql_tmpl($SQL_TMPL->{0})

+    ;

+}

+$dbi = DBIx::Custom::T1->new(

+    user => 'ao',

+    database => 'ao',

+    password => 'bo',

+    data_source => 'co',

+    options => {do => 10, eo => 20},

+    filters => {

+        fo => 30,

+    },

+    formats => {

+        fo => 30,

+    },

+    bind_filter => 'fo',

+    fetch_filter => 'go',

+    result_class => 'ho',

+    sql_tmpl => $SQL_TMPL->{0},

+);

+is($dbi->user, 'ao', "$test : user");

+is($dbi->database, 'ao', "$test : database");

+is($dbi->password, 'bo', "$test : passowr");

+is($dbi->data_source, 'co', "$test : data_source");

+is_deeply($dbi->options, {do => 10, eo => 20}, "$test : options");

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

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

+is($dbi->bind_filter, 'fo', "$test : bind_filter");

+is($dbi->fetch_filter, 'go', "$test : fetch_filter");

+is($dbi->result_class, 'ho', "$test : result_class");

+is($dbi->sql_tmpl->tag_start, 0, "$test : sql_tmpl");

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

+

+test 'Sub class constructor default';

+$dbi = DBIx::Custom::T1->new;

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

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

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

+is($dbi->data_source, 'c', "$test : data_source");

+is_deeply($dbi->options, {d => 1, e => 2}, "$test : options");

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

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

+is($dbi->bind_filter, 'f', "$test : bind_filter");

+is($dbi->fetch_filter, 'g', "$test : fetch_filter");

+is($dbi->result_class, 'DBIx::Custom::Result', "$test : result_class");

+is($dbi->sql_tmpl->tag_start, 0, "$test : sql_tmpl");

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

+

+

+test 'Sub sub class constructor default';

+{

+    package DBIx::Custom::T1_2;

+    use base 'DBIx::Custom::T1';

+}

+$dbi = DBIx::Custom::T1_2->new;

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

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

+is($dbi->password, 'b', "$test : passowrd");

+is($dbi->data_source, 'c', "$test : data_source");

+is_deeply($dbi->options, {d => 1, e => 2}, "$test : options");

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

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

+is($dbi->bind_filter, 'f', "$test : bind_filter");

+is($dbi->fetch_filter, 'g', "$test : fetch_filter");

+is($dbi->result_class, 'DBIx::Custom::Result', "$test : result_class");

+is($dbi->sql_tmpl->tag_start, 0, "$test sql_tmpl");

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

+

+

+test 'Customized sub class constructor default';

+{

+    package DBIx::Custom::T1_3;

+    use base 'DBIx::Custom::T1';

+    

+    __PACKAGE__

+      ->user('ao')

+      ->database('ao')

+      ->password('bo')

+      ->data_source('co')

+      ->options({do => 10, eo => 20})

+      ->filters({fo => 30})

+      ->formats({fo => 30})

+      ->bind_filter('fo')

+      ->fetch_filter('go')

+      ->result_class('ho')

+      ->sql_tmpl($SQL_TMPL->{1})

+    ;

+}

+$dbi = DBIx::Custom::T1_3->new;

+is($dbi->user, 'ao', "$test : user");

+is($dbi->database, 'ao', "$test : database");

+is($dbi->password, 'bo', "$test : password");

+is($dbi->data_source, 'co', "$test : data_source");

+is_deeply($dbi->options, {do => 10, eo => 20}, "$test : options");

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

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

+is($dbi->bind_filter, 'fo', "$test : bind_filter");

+is($dbi->fetch_filter, 'go', "$test : fetch_filter");

+is($dbi->result_class, 'ho', "$test : result_class");

+is($dbi->sql_tmpl->tag_start, 1, "$test : sql_tmpl");

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

+

+

+test 'Customized sub class constructor';

+$dbi = DBIx::Custom::T1_3->new(

+    user => 'a',

+    database => 'a',

+    password => 'b',

+    data_source => 'c',

+    options => {d => 1, e => 2},

+    filters => {

+        f => 3,

+    },

+    formats => {

+        f => 3,

+    },

+    bind_filter => 'f',

+    fetch_filter => 'g',

+    result_class => 'h',

+    sql_tmpl => $SQL_TMPL->{2},

+);

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

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

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

+is($dbi->data_source, 'c', "$test : data_source");

+is_deeply($dbi->options, {d => 1, e => 2}, "$test : options");

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

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

+is($dbi->bind_filter, 'f', "$test : bind_filter");

+is($dbi->fetch_filter, 'g', "$test : fetch_filter");

+is($dbi->result_class, 'h', "$test : result_class");

+is($dbi->sql_tmpl->tag_start, 2, "$test : sql_tmpl");

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

+

+

+test 'add_filters';

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

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

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

+

+test 'add_formats';

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

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

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

+

+test 'filter_off';

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

+$dbi->bind_filter('a');

+$dbi->fetch_filter('b');

+$dbi->filter_off;

+ok(!$dbi->bind_filter,  "$test : bind_filter  off");

+ok(!$dbi->fetch_filter, "$test : fetch_filter off");

+

+test 'Accessor';

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

+$dbi->options({opt1 => 1, opt2 => 2});

+is_deeply(scalar $dbi->options, {opt1 => 1, opt2 => 2}, "$test : options");

+

+$dbi->no_bind_filters(['a', 'b']);

+is_deeply(scalar $dbi->no_bind_filters, ['a', 'b'], "$test: no_bind_filters");

+

+$dbi->no_fetch_filters(['a', 'b']);

+is_deeply(scalar $dbi->no_fetch_filters, ['a', 'b'], "$test: no_fetch_filters");

@@ -0,0 +1,47 @@

+use Test::More;

+use strict;

+use warnings;

+

+# user password database

+our ($USER, $PASSWORD, $DATABASE) = connect_info();

+

+plan skip_all => 'private MySQL test' unless $USER;

+

+plan 'no_plan';

+

+# Function for test name

+my $test;

+sub test {

+    $test = shift;

+}

+

+

+# Functions for tests

+sub connect_info {

+    my $file = 'password.tmp';

+    open my $fh, '<', $file

+      or return;

+    

+    my ($user, $password, $database) = split(/\s/, (<$fh>)[0]);

+    

+    close $fh;

+    

+    return ($user, $password, $database);

+}

+

+

+# Constat variables for tests

+my $CLASS = 'DBIx::Custom::MySQL';

+

+# Varialbes for tests

+my $dbi;

+

+use DBIx::Custom::MySQL;

+

+test 'connect';

+$dbi = $CLASS->new(user => $USER, password => $PASSWORD,

+                    database => $DATABASE);

+$dbi->connect;

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

+

+

@@ -0,0 +1,85 @@

+use Test::More;

+use strict;

+use warnings;

+

+BEGIN {

+    eval { require Time::Piece; 1 }

+        or plan skip_all => 'Time::Piece required';

+    

+    eval { Time::Piece->VERSION >= 1.15 }

+        or plan skip_all => 'Time::Piece >= 1.15 requred';

+        

+    plan 'no_plan';

+    use_ok('DBIx::Custom');

+}

+

+# Function for test name

+my $test;

+sub test {

+    $test = shift;

+}

+

+# Varialbe for tests

+

+my $format;

+my $data;

+my $timepiece;

+my $dbi;

+

+use DBIx::Custom::MySQL;

+

+

+test 'SQL99 format';

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

+$data   = '2009-01-02 03:04:05';

+$format = $dbi->formats->{'SQL99_datetime'};

+$timepiece = Time::Piece->strptime($data, $format);

+is($timepiece->strftime('%Y-%m-%d'), '2009-01-02', "$test : datetime date");

+is($timepiece->strftime('%H:%M:%S'), '03:04:05',  "$test : datetime time");

+

+$data   = '2009-01-02';

+$format = $dbi->formats->{'SQL99_date'};

+$timepiece = Time::Piece->strptime($data, $format);

+is($timepiece->strftime('%Y-%m-%d'), '2009-01-02', "$test : date");

+

+$data   = '03:04:05';

+$format = $dbi->formats->{'SQL99_time'};

+$timepiece = Time::Piece->strptime($data, $format);

+is($timepiece->strftime('%H:%M:%S'), '03:04:05',  "$test : time");

+

+

+test 'ISO-8601 format';

+$data   = '2009-01-02T03:04:05';

+$format = $dbi->formats->{'ISO-8601_datetime'};

+$timepiece = Time::Piece->strptime($data, $format);

+is($timepiece->strftime('%Y-%m-%d'), '2009-01-02', "$test : datetime date");

+is($timepiece->strftime('%H:%M:%S'), '03:04:05',  "$test : datetime time");

+

+$data   = '2009-01-02';

+$format = $dbi->formats->{'ISO-8601_date'};

+$timepiece = Time::Piece->strptime($data, $format);

+is($timepiece->strftime('%Y-%m-%d'), '2009-01-02', "$test : date");

+

+$data   = '03:04:05';

+$format = $dbi->formats->{'ISO-8601_time'};

+$timepiece = Time::Piece->strptime($data, $format);

+is($timepiece->strftime('%H:%M:%S'), '03:04:05',  "$test : time");

+

+

+test 'default format';

+$data   = '2009-01-02 03:04:05';

+$format = $dbi->formats->{'datetime'};

+$timepiece = Time::Piece->strptime($data, $format);

+is($timepiece->strftime('%Y-%m-%d'), '2009-01-02', "$test : datetime date");

+is($timepiece->strftime('%H:%M:%S'), '03:04:05',  "$test : datetime time");

+

+$data   = '2009-01-02';

+$format = $dbi->formats->{'date'};

+$timepiece = Time::Piece->strptime($data, $format);

+is($timepiece->strftime('%Y-%m-%d'), '2009-01-02', "$test : date");

+

+$data   = '03:04:05';

+$format = $dbi->formats->{'time'};

+$timepiece = Time::Piece->strptime($data, $format);

+is($timepiece->strftime('%H:%M:%S'), '03:04:05',  "$test : time");

+

@@ -0,0 +1,37 @@

+use Test::More 'no_plan';

+

+use strict;

+use warnings;

+use DBIx::Custom::Query;

+

+# Function for test name

+my $test;

+sub test{

+    $test = shift;

+}

+

+# Variables for test

+my $query;

+

+test 'Accessors';

+$query = DBIx::Custom::Query->new(

+    sql              => 'a',

+    key_infos        => 'b',

+    bind_filter      => 'c',

+    no_bind_filters  => [qw/d e/],

+    sth              => 'e',

+    fetch_filter     => 'f',

+    no_fetch_filters => [qw/g h/],

+);

+

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

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

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

+is_deeply($query->no_bind_filters, [qw/d e/], "$test : no_bind_filters");

+is_deeply($query->_no_bind_filters, {d => 1, e => 1}, "$test : _no_bind_filters");

+is_deeply($query->no_fetch_filters, [qw/g h/], "$test : no_fetch_filters");

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

+

+$query->no_bind_filters(undef);

+is_deeply(scalar $query->_no_bind_filters, {}, "$test _no_bind_filters undef value");

+

@@ -0,0 +1,259 @@

+use Test::More;

+use strict;

+use warnings;

+use DBI;

+

+BEGIN {

+    eval { require DBD::SQLite; 1 }

+        or plan skip_all => 'DBD::SQLite required';

+    eval { DBD::SQLite->VERSION >= 1 }

+        or plan skip_all => 'DBD::SQLite >= 1.00 required';

+

+    plan 'no_plan';

+    use_ok('DBIx::Custom::Result');

+}

+

+my $test;

+sub test {

+    $test = shift;

+}

+

+sub query {

+    my ($dbh, $sql) = @_;

+    my $sth = $dbh->prepare($sql);

+    $sth->execute;

+    return DBIx::Custom::Result->new(sth => $sth);

+}

+

+my $dbh;

+my $sql;

+my $sth;

+my @row;

+my $row;

+my @rows;

+my $rows;

+my $result;

+my $fetch_filter;

+my @error;

+my $error;

+

+$dbh = DBI->connect('dbi:SQLite:dbname=:memory:', undef, undef, {PrintError => 0, RaiseError => 1});

+$dbh->do("create table table1 (key1 char(255), key2 char(255));");

+$dbh->do("insert into table1 (key1, key2) values ('1', '2');");

+$dbh->do("insert into table1 (key1, key2) values ('3', '4');");

+

+$sql = "select key1, key2 from table1";

+

+test 'fetch scalar context';

+$result = query($dbh, $sql);

+@rows = ();

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

+    push @rows, [@$row];

+}

+is_deeply(\@rows, [[1, 2], [3, 4]], $test);

+

+

+test 'fetch list context';

+$result = query($dbh, $sql);

+@rows = ();

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

+    push @rows, [@row];

+}

+is_deeply(\@rows, [[1, 2], [3, 4]], $test);

+

+test 'fetch_hash scalar context';

+$result = query($dbh, $sql);

+@rows = ();

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

+    push @rows, {%$row};

+}

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

+

+

+test 'fetch hash list context';

+$result = query($dbh, $sql);

+@rows = ();

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

+    push @rows, {%row};

+}

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

+

+

+test 'fetch_single';

+$result = query($dbh, $sql);

+$row = $result->fetch_single;

+is_deeply($row, [1, 2], "$test : row");

+$row = $result->fetch;

+ok(!$row, "$test : finished");

+

+

+test 'fetch_single list context';

+$result = query($dbh, $sql);

+@row = $result->fetch_single;

+is_deeply([@row], [1, 2], "$test : row");

+@row = $result->fetch;

+ok(!@row, "$test : finished");

+

+

+test 'fetch_hash_single';

+$result = query($dbh, $sql);

+$row = $result->fetch_hash_single;

+is_deeply($row, {key1 => 1, key2 => 2}, "$test : row");

+$row = $result->fetch_hash;

+ok(!$row, "$test : finished");

+

+

+test 'fetch_hash_single list context';

+$result = query($dbh, $sql);

+@row = $result->fetch_hash_single;

+is_deeply({@row}, {key1 => 1, key2 => 2}, "$test : row");

+@row = $result->fetch_hash;

+ok(!@row, "$test : finished");

+

+

+test 'fetch_rows';

+$dbh->do("insert into table1 (key1, key2) values ('5', '6');");

+$dbh->do("insert into table1 (key1, key2) values ('7', '8');");

+$dbh->do("insert into table1 (key1, key2) values ('9', '10');");

+$result = query($dbh, $sql);

+$rows = $result->fetch_rows(2);

+is_deeply($rows, [[1, 2],

+                  [3, 4]], "$test : fetch_rows first");

+$rows = $result->fetch_rows(2);

+is_deeply($rows, [[5, 6],

+                  [7, 8]], "$test : fetch_rows secound");

+$rows = $result->fetch_rows(2);

+is_deeply($rows, [[9, 10]], "$test : fetch_rows third");

+$rows = $result->fetch_rows(2);

+ok(!$rows);

+

+

+test 'fetch_rows list context';

+$result = query($dbh, $sql);

+@rows = $result->fetch_rows(2);

+is_deeply([@rows], [[1, 2],

+                  [3, 4]], "$test : fetch_rows first");

+@rows = $result->fetch_rows(2);

+is_deeply([@rows], [[5, 6],

+                  [7, 8]], "$test : fetch_rows secound");

+@rows = $result->fetch_rows(2);

+is_deeply([@rows], [[9, 10]], "$test : fetch_rows third");

+@rows = $result->fetch_rows(2);

+ok(!@rows);

+

+

+test 'fetch_rows error';

+$result = query($dbh, $sql);

+eval {$result->fetch_rows};

+like($@, qr/Row count must be specified/, "$test : Not specified row count");

+

+

+test 'fetch_hash_rows';

+$result = query($dbh, $sql);

+$rows = $result->fetch_hash_rows(2);

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

+                  {key1 => 3, key2 => 4}], "$test : fetch_rows first");

+$rows = $result->fetch_hash_rows(2);

+is_deeply($rows, [{key1 => 5, key2 => 6},

+                  {key1 => 7, key2 => 8}], "$test : fetch_rows secound");

+$rows = $result->fetch_hash_rows(2);

+is_deeply($rows, [{key1 => 9, key2 => 10}], "$test : fetch_rows third");

+$rows = $result->fetch_hash_rows(2);

+ok(!$rows);

+

+

+test 'fetch_rows list context';

+$result = query($dbh, $sql);

+@rows = $result->fetch_hash_rows(2);

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

+                    {key1 => 3, key2 => 4}], "$test : fetch_rows first");

+@rows = $result->fetch_hash_rows(2);

+is_deeply([@rows], [{key1 => 5, key2 => 6},

+                    {key1 => 7, key2 => 8}], "$test : fetch_rows secound");

+@rows = $result->fetch_hash_rows(2);

+is_deeply([@rows], [{key1 => 9, key2 => 10}], "$test : fetch_rows third");

+@rows = $result->fetch_hash_rows(2);

+ok(!@rows);

+$dbh->do("delete from table1 where key1 = 5 or key1 = 7 or key1 = 9");

+

+

+test 'fetch_rows error';

+$result = query($dbh, $sql);

+eval {$result->fetch_hash_rows};

+like($@, qr/Row count must be specified/, "$test : Not specified row count");

+

+

+test 'fetch_all';

+$result = query($dbh, $sql);

+$rows = $result->fetch_all;

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

+

+test 'fetch_all list context';

+$result = query($dbh, $sql);

+@rows = $result->fetch_all;

+is_deeply(\@rows, [[1, 2], [3, 4]], $test);

+

+

+test 'fetch_hash_all';

+$result = query($dbh, $sql);

+@rows = $result->fetch_hash_all;

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

+

+

+test 'fetch_hash_all list context';

+$result = query($dbh, $sql);

+@rows = $result->fetch_all;

+is_deeply(\@rows, [[1, 2], [3, 4]], $test);

+

+

+test 'fetch filter';

+$fetch_filter = sub {

+    my ($value, $key, $dbi, $infos) = @_;

+    my ($type, $sth, $i) = @{$infos}{qw/type sth index/};

+    

+    if ($key eq 'key1' && $value == 1 && $type =~ /char/i && $i == 0 && $sth->{TYPE}->[$i] eq $type) {

+        return $value * 3;

+    }

+    return $value;

+};

+

+$result = query($dbh, $sql);

+$result->fetch_filter($fetch_filter);

+$rows = $result->fetch_all;

+is_deeply($rows, [[3, 2], [3, 4]], "$test array");

+

+$result = query($dbh, $sql);

+$result->fetch_filter($fetch_filter);

+$rows = $result->fetch_hash_all;

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

+

+$result = query($dbh, $sql);

+$result->no_fetch_filters(['key1']);

+$rows = $result->fetch_all;

+is_deeply($rows, [[1, 2], [3, 4]], "$test array no filter keys");

+

+$result = query($dbh, $sql);

+$result->no_fetch_filters(['key1']);

+$rows = $result->fetch_hash_all;

+is_deeply($rows, [{key1 => 1, key2 => 2}, {key1 => 3, key2 => 4}], "$test hash no filter keys");

+

+

+test 'finish';

+$result = query($dbh, $sql);

+$result->fetch;

+$result->finish;

+ok(!$result->fetch, $test);

+

+test 'error'; # Cannot real test

+$result = query($dbh, $sql);

+$sth = $result->sth;

+

+@error = $result->error;

+is(scalar @error, 3, "$test list context count");

+is($error[0], $sth->errstr, "$test list context errstr");

+is($error[1], $sth->err, "$test list context err");