@@ -13,7 +13,6 @@ use DBI::Custom::Query;

 sub user        : ClassObjectAttr { initialize => {clone => 'scalar'} }

 sub password    : ClassObjectAttr { initialize => {clone => 'scalar'} }

 sub data_source : ClassObjectAttr { initialize => {clone => 'scalar'} }

-sub database    : ClassObjectAttr { initialize => {clone => 'scalar'} }

 sub dbi_options : ClassObjectAttr { initialize => {clone => 'hash', 

                                                    default => sub { {} } } }

@@ -67,7 +66,7 @@ sub _auto_commit {

     my $self = shift;

     croak("Cannot change AutoCommit becouse of not connected")

-        unless $self->dbh;

+      unless $self->dbh;

     if (@_) {

         $self->dbh->{AutoCommit} = $_[0];

@@ -109,7 +108,7 @@ sub DESTROY {

 # Is connected?

 sub connected {

     my $self = shift;

-    return exists $self->{dbh} && eval {$self->{dbh}->can('prepare')};

+    return ref $self->{dbh} eq 'DBI::db';

 }

 # Disconnect

@@ -132,41 +131,87 @@ sub reconnect {

 sub run_tranzaction {

     my ($self, $tranzaction) = @_;

+    # Auto commit off

     $self->_auto_commit(0);

-    eval {

-        $tranzaction->();

-        $self->dbh->commit;

-    };

+    # Run tranzaction

+    eval {$tranzaction->()};

-    if ($@) {

-        my $tranzaction_error = $@;

+    # Tranzaction error

+    my $tranzaction_error = $@;

+    

+    # RaiseError on

+    my $old_raise_error = $self->dbh->{RaiseError};

+    $self->dbh->{RaiseError} = 1;

+    

+    # Tranzaction is failed.

+    if ($tranzaction_error) {

+        # Rollback

+        eval{$self->dbh->rollback};

+        

+        # Rollback error

+        my $rollback_error = $@;

-        $self->dbh->rollback or croak("$@ and rollback also failed");

-        croak("$tranzaction_error");

+        # Auto commit on

+        $self->_auto_commit(1);

+        

+        # Restore RaiseError value

+        $self->dbh->{RaiseError} = $old_raise_error;

+        

+        if ($rollback_error) {

+            # Rollback is failed

+            croak("${tranzaction_error}Rollback is failed : $rollback_error");

+        }

+        else {

+            # Rollback is success

+            croak("${tranzaction_error}Rollback is success");

+        }

+    }

+    # Tranzaction is success

+    else {

+        # Commit

+        eval{$self->dbh->commit};

+        my $commit_error = $@;

+        

+        # Auto commit on

+        $self->_auto_commit(1);

+        

+        # Restore RaiseError value

+        $self->dbh->{RaiseError} = $old_raise_error;

+        

+        # Commit is failed

+        croak($commit_error) if $commit_error;

     }

-    $self->_auto_commit(1);

 }

+# Prepare statement handle

 sub prepare {

     my ($self, $sql) = @_;

+    

+    # Connect if not

     eval{$self->connect unless $self->connected};

     croak($@) if $@;

+    # Prepare

     my $sth = eval{$self->dbh->prepare($sql)};

     croak($@) if $@;

     return $sth;

 }

+# Execute SQL directly

 sub do{

     my ($self, $sql, @bind_values) = @_;

+    

+    # Connect if not

     eval{$self->connect unless $self->connected};

     croak($@) if $@;

+    # Do

     eval{$self->dbh->do($sql, @bind_values)};

     croak($@) if $@;

 }

+# Create query

 sub create_query {

     my ($self, $template) = @_;

@@ -178,8 +223,9 @@ sub create_query {

     # Create Query object;

     $query = DBI::Custom::Query->new($query);

-    # connect if not

-    $self->connect unless $self->connected;

+    # Connect if not

+    eval{$self->connect unless $self->connected};

+    croak($@) if $@;

     # Prepare statement handle

     my $sth = eval{$self->dbh->prepare($query->{sql})};

@@ -207,6 +253,7 @@ sub create_query {

     return $query;

 }

+# Execute query

 sub execute {

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

     $params ||= {};

@@ -225,6 +272,8 @@ sub execute {

     # Execute

     my $sth = $query->sth;

     my $ret_val = eval{$sth->execute(@$bind_values)};

+    

+    # Execute error

     if ($@) {

         require Data::Dumper;

         my $sql         = $query->{sql} || '';

@@ -236,7 +285,11 @@ sub execute {

     # Return resultset if select statement is executed

     if ($sth->{NUM_OF_FIELDS}) {

+        

+        # Get result class

         my $result_class = $self->result_class;

+        

+        # Create result

         my $result = $result_class->new({

             sth              => $sth,

             fetch_filter     => $query->fetch_filter,

@@ -247,9 +300,9 @@ sub execute {

     return $ret_val;

 }

+# Build binding values

 sub _build_bind_values {

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

-    

     my $key_infos           = $query->key_infos;

     my $bind_filter         = $query->bind_filter;

     my $no_bind_filters_map = $query->_no_bind_filters_map || {};

@@ -259,58 +312,96 @@ sub _build_bind_values {

     # Create bind values

     foreach my $key_info (@$key_infos) {

-        my $filtering_key = $key_info->{key};

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

-        

+        # 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}       || '';

+        # Key is found?

         my $found;

+        

+        # 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++) {

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

+                # Current key

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

+                # Each access key must be string or array reference

                 croak("'access_keys' each value must be string or array reference")

-                  unless (ref $key eq 'ARRAY' || ($key && !ref $key));

+                  unless (ref $current_key eq 'ARRAY' ||

+                          ($current_key && !ref $current_key));

+                # Last key

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

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

-                        if ($bind_filter && !$no_bind_filters_map->{$original_key}) {

+                    # Key is array reference

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

+                        # Filtering 

+                        if ($bind_filter &&

+                            !$no_bind_filters_map->{$original_key})

+                        {

                             push @bind_values, 

-                                 $bind_filter->($original_key, $root_params->[$key->[0]],

+                                 $bind_filter->($original_key, 

+                                                $root_params->[$current_key->[0]],

                                                 $table, $column);

                         }

+                        # Not filtering

                         else {

-                            push @bind_values, scalar $root_params->[$key->[0]];

+                            push @bind_values,

+                                 scalar $root_params->[$current_key->[0]];

                         }

                     }

+                    # Key is string

                     else {

-                        next ACCESS_KEYS unless exists $root_params->{$key};

-                        if ($bind_filter && !$no_bind_filters_map->{$original_key}) {

+                        # Key is not found

+                        next ACCESS_KEYS

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

+                        

+                        # Filtering

+                        if ($bind_filter &&

+                            !$no_bind_filters_map->{$original_key}) 

+                        {

                             push @bind_values,

-                                 $bind_filter->($original_key, $root_params->{$key}, 

+                                 $bind_filter->($original_key,

+                                                $root_params->{$current_key}, 

                                                 $table, $column);

                         }

+                        # Not filtering

                         else {

-                            push @bind_values, scalar $root_params->{$key};

+                            push @bind_values,

+                                 scalar $root_params->{$current_key};

                         }

                     }

+                    

+                    # Key is found

                     $found = 1;

                 }

-                

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

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

-                }

+                # First or middle key

                 else {

-                    next ACCESS_KEYS unless exists $root_params->{$key};

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

+                    # 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']);

@@ -334,7 +425,14 @@ DBI::Custom - Customizable simple DBI

 Version 0.0101

-=cut

+=head1 CAUTION

+

+This module is now experimental stage.

+

+I want you to try this module

+because I want this module stable, and not to damage your DB data by this module bug.

+

+Please tell me bug if you find

 =head1 SYNOPSIS

@@ -576,8 +674,6 @@ See also L<DBI::Custom::SQL::Template>

 If tranzaction is success, commit is execute. 

 If tranzation is died, rollback is execute.

-

-

 =head1 AUTHOR

 Yuki Kimoto, C<< <kimoto.yuki at gmail.com> >>

@@ -591,7 +687,4 @@ Copyright 2009 Yuki Kimoto, all rights reserved.

 This program is free software; you can redistribute it and/or modify it

 under the same terms as Perl itself.

-

 =cut

-

-1; # End of DBI::Custom

@@ -3,7 +3,6 @@ use strict;

 use warnings;

 use DBI::Custom;

-use Scalar::Util qw/blessed/;

 use DBI::Custom::SQL::Template;

 # Function for test name

@@ -12,15 +11,16 @@ sub test {

     $test = shift;

 }

-# Varialbes for test

+# Variables for test

+our $SQL_TMPL = {

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

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

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

+};

 my $dbi;

-my $sql_tmpl;

-my $sql_tmpl1 = DBI::Custom::SQL::Template->new->tag_start(0);

-my $sql_tmpl2 = DBI::Custom::SQL::Template->new->tag_start(1);

-my $sql_tmpl3 = DBI::Custom::SQL::Template->new->tag_start(2);

-test 'constructor';

+test 'Constructor';

 $dbi = DBI::Custom->new(

     user => 'a',

     password => 'b',

@@ -32,12 +32,12 @@ $dbi = DBI::Custom->new(

     bind_filter => 'f',

     fetch_filter => 'g',

     result_class => 'g',

-    sql_template => $sql_tmpl1,

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

 );

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

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

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

-                sql_template => $sql_tmpl1}, $test);

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

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

@@ -57,7 +57,7 @@ test 'Sub class constructor';

       ->bind_filter('f')

       ->fetch_filter('g')

       ->result_class('DBI::Custom::Result')

-      ->sql_template($sql_tmpl1)

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

     ;

 }

 $dbi = DBI::Custom::T1->new(

@@ -71,7 +71,7 @@ $dbi = DBI::Custom::T1->new(

     bind_filter => 'fo',

     fetch_filter => 'go',

     result_class => 'ho',

-    sql_template => $sql_tmpl1,

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

 );

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

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

@@ -97,12 +97,12 @@ is($dbi->result_class, 'DBI::Custom::Result', "$test : result_class");

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

 isa_ok($dbi, 'DBI::Custom::T1');

+

 test 'Sub sub class constructor default';

 {

     package DBI::Custom::T1_2;

     use base 'DBI::Custom::T1';

 }

-

 $dbi = DBI::Custom::T1_2->new;

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

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

@@ -132,7 +132,7 @@ test 'Customized sub class constructor default';

       ->bind_filter('fo')

       ->fetch_filter('go')

       ->result_class('ho')

-      ->sql_template($sql_tmpl2)

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

     ;

 }

 $dbi = DBI::Custom::T1_3->new;

@@ -160,7 +160,7 @@ $dbi = DBI::Custom::T1_3->new(

     bind_filter => 'f',

     fetch_filter => 'g',

     result_class => 'h',

-    sql_template => $sql_tmpl3,

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

 );

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

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

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

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

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

+

+test 'add_filters';

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

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

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

+

@@ -18,6 +18,8 @@ sub test {

     $test = shift;

 }

+

+

 # Varialbes for test

 our $CREATE_TABLE = {

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

@@ -28,6 +30,10 @@ our $SELECT_TMPL = {

     0 => 'select * from table1;'

 };

+our $DROP_TABLE = {

+    0 => 'drop table table1'

+};

+

 my $dbi;

 my $sth;

 my $tmpl;

@@ -46,13 +52,18 @@ my $update_query;

 my $ret_val;

-

-test 'Disconnect';

+test 'disconnect';

 $dbi = DBI::Custom->new(data_source => 'dbi:SQLite:dbname=:memory:');

 $dbi->connect;

 $dbi->disconnect;

 ok(!$dbi->dbh, $test);

+test 'connected';

+$dbi = DBI::Custom->new(data_source => 'dbi:SQLite:dbname=:memory:');

+ok(!$dbi->connected, "$test : not connected");

+$dbi->connect;

+ok($dbi->connected, "$test : connected");

+

 # Prepare table

 $dbi = DBI::Custom->new(data_source => 'dbi:SQLite:dbname=:memory:');

 $dbi->connect;

@@ -112,7 +123,7 @@ is_deeply(\@rows, [[1, 2], [3, 4]], "$test : fetch_all_hash list context");

 test 'Insert query return value';

-$dbi->reconnect;

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

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

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

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

@@ -121,7 +132,7 @@ ok($ret_val, $test);

 test 'Direct execute';

-$dbi->reconnect;

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

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

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

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

@@ -140,7 +151,7 @@ is_deeply($rows, [{key1 => 1, key2 => 3}], $test);

 test 'Filter basic';

-$dbi->reconnect;

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

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

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

@@ -173,7 +184,7 @@ $result = $dbi->execute($select_query);

 $rows = $result->fetch_all_hash;

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

-$dbi->reconnect;

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

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

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

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

@@ -209,7 +220,7 @@ is_deeply($rows, [{key1 => 2, key2 => 4}], "$test : bind_filter");

 test 'DBI::Custom::SQL::Template basic tag';

-$dbi->reconnect;

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

 $dbi->do($CREATE_TABLE->{1});

 $sth = $dbi->prepare("insert into table1 (key1, key2, key3, key4, key5) values (?, ?, ?, ?, ?);");

 $sth->execute(1, 2, 3, 4, 5);

@@ -253,7 +264,7 @@ is_deeply($rows, [{key1 => 1, key2 => 2, key3 => 3, key4 => 4, key5 => 5}], "$te

 test 'DIB::Custom::SQL::Template in tag';

-$dbi->reconnect;

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

 $dbi->do($CREATE_TABLE->{1});

 $sth = $dbi->prepare("insert into table1 (key1, key2, key3, key4, key5) values (?, ?, ?, ?, ?);");

 $sth->execute(1, 2, 3, 4, 5);

@@ -366,3 +377,34 @@ $rows = $result->fetch_all_hash;

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

                   {key1 => 6, key2 => 7, key3 => 8, key4 => 9, key5 => 10}], "$test : update tag #update with table name dot");

+

+test 'run_tansaction';

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

+$dbi->do($CREATE_TABLE->{0});

+$dbi->run_tranzaction(sub {

+    $insert_tmpl = 'insert into table1 {insert key1 key2}';

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

+    $dbi->execute($insert_tmpl, {key1 => 3, key2 => 4});

+});

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

+$rows   = $result->fetch_all_hash;

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

+

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

+$dbi->do($CREATE_TABLE->{0});

+$dbi->dbh->{RaiseError} = 0;

+eval{

+    $dbi->run_tranzaction(sub {

+        $insert_tmpl = 'insert into table1 {insert key1 key2}';

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

+        die "Fatal Error";

+        $dbi->execute($insert_tmpl, {key1 => 3, key2 => 4});

+    })

+};

+like($@, qr/Fatal Error.*Rollback is success/ms, "$test : Rollback success message");

+ok(!$dbi->dbh->{RaiseError}, "$test : restore RaiseError value");

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

+$rows   = $result->fetch_all_hash;

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

+

+

@@ -3,9 +3,9 @@ use strict;

 use warnings;

 # user password database

-our ($U, $P, $D) = connect_info();

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

-plan skip_all => 'private MySQL test' unless $U;

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

 plan 'no_plan';

@@ -13,9 +13,9 @@ use DBI::Custom;

 use Scalar::Util 'blessed';

 {

     my $dbi = DBI::Custom->new(

-        user => $U,

-        password => $P,

-        data_source => "dbi:mysql:dbname=$D"

+        user => $USER,

+        password => $PASSWORD,

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

     );

     $dbi->connect;