@@ -1,3 +1,7 @@

+0.1402

+  remove finish(), error()

+  can receive code ref to filter()

+  renamed resist to register

 0.1401

   renamed fetch_rows to fetch_multi

   renamed fetch_hash_rows to fetch_hash_multi

@@ -29,7 +29,7 @@ __PACKAGE__->dual_attr([qw/ filters formats/],

 __PACKAGE__->attr(result_class => 'DBIx::Custom::Result');

 __PACKAGE__->attr(sql_tmpl => sub { DBIx::Custom::SQLTemplate->new });

-sub resist_filter {

+sub register_filter {

     my $invocant = shift;

     # Add filter

@@ -39,7 +39,7 @@ sub resist_filter {

     return $invocant;

 }

-sub resist_format{

+sub register_format{

     my $invocant = shift;

     # Add format

@@ -631,11 +631,12 @@ DBIx::Custom - DBI with hash bind and filtering system

 =head1 VERSION

-Version 0.1401

+Version 0.1402

 =cut

-our $VERSION = '0.1401';

+our $VERSION = '0.1402';

+$VERSION = eval $VERSION;

 =head1 STATE

@@ -654,6 +655,8 @@ This module is not stable. Method name and functionality will be change.

     $dbi->execute("select id from books where {= author} && {like title}",

                 {author => 'ken', title => '%Perl%'});

+    

+    

     # Insert 

     $dbi->insert('books', {title => 'perl', author => 'Ken'});

@@ -759,7 +762,7 @@ This method is generally used to get a filter.

     $filter = $dbi->filters->{encode_utf8};

-If you add filter, use resist_filter method.

+If you add filter, use register_filter method.

 =head2 formats

@@ -772,7 +775,7 @@ This method is generally used to get a format.

     $filter = $dbi->formats->{datetime};

-If you add format, use resist_format method.

+If you add format, use register_format method.

 =head2 default_query_filter

@@ -783,7 +786,7 @@ Binding filter

 The following is bind filter example

-    $dbi->resist_filter(encode_utf8 => sub {

+    $dbi->register_filter(encode_utf8 => sub {

         my $value = shift;

         require Encode 'encode_utf8';

@@ -809,7 +812,7 @@ Fetching filter

 The following is fetch filter example

-    $dbi->resist_filter(decode_utf8 => sub {

+    $dbi->register_filter(decode_utf8 => sub {

         my $value = shift;

         require Encode 'decode_utf8';

@@ -882,15 +885,15 @@ Check if database is connected.

     $is_connected = $dbi->connected;

-=head2 resist_filter

+=head2 register_filter

 Resist filter

-    $dbi->resist_filter($fname1 => $filter1, $fname => $filter2);

+    $dbi->register_filter($fname1 => $filter1, $fname => $filter2);

-The following is resist_filter example

+The following is register_filter example

-    $dbi->resist_filter(

+    $dbi->register_filter(

         encode_utf8 => sub {

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

             utf8::upgrade($value) unless Encode::is_utf8($value);

@@ -902,15 +905,15 @@ The following is resist_filter example

         }

     );

-=head2 resist_format

+=head2 register_format

 Add format

-    $dbi->resist_format($fname1 => $format, $fname2 => $format2);

+    $dbi->register_format($fname1 => $format, $fname2 => $format2);

-The following is resist_format example.

+The following is register_format example.

-    $dbi->resist_format(date => '%Y:%m:%d', datetime => '%Y-%m-%d %H:%M:%S');

+    $dbi->register_format(date => '%Y:%m:%d', datetime => '%Y-%m-%d %H:%M:%S');

 =head2 create_query

@@ -7,13 +7,13 @@ use base 'DBIx::Custom';

 use Encode qw/decode encode/;

-__PACKAGE__->resist_filter(

+__PACKAGE__->register_filter(

     none        => sub { $_[0] },

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

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

 );

-__PACKAGE__->resist_format(

+__PACKAGE__->register_format(

     'SQL99_date'        => '%Y-%m-%d',

     'SQL99_datetime'    => '%Y-%m-%d %H:%M:%S',

     'SQL99_time'        => '%H:%M:%S',

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

 use base 'DBIx::Custom::Basic';

 use Carp 'croak';

-__PACKAGE__->resist_format(

+__PACKAGE__->register_format(

     datetime => __PACKAGE__->formats->{SQL99_datetime},

     date     => __PACKAGE__->formats->{SQL99_date},

     time     => __PACKAGE__->formats->{SQL99_time},

@@ -12,10 +12,9 @@ __PACKAGE__->attr([qw/sth filters default_filter filter/]);

 sub fetch {

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

-    my $sth            = $self->sth;

-    my $filters        = $self->filters || {};

-    my $default_filter = $self->default_filter || '';

-    my $filter         = $self->filter || {};

+    my $sth     = $self->{sth};

+    my $filters = $self->{filters} || {};

+    my $filter  = $self->{filter} || {};

     # Fetch

     my $row = $sth->fetchrow_arrayref;

@@ -28,9 +27,22 @@ sub fetch {

     # Filter

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

-        my $fname  = $filter->{$columns->[$i]} || $filters->{$default_filter} || '';

-        my $filter = $filters->{$fname};

-        $row->[$i] = $filter->($row->[$i]) if $filter;

+        my $fname  = $filter->{$columns->[$i]} || $self->{default_filter} || '';

+        

+        if ($fname) {

+            my $filter;

+            

+            if (ref $fname) {

+                $filter = $fname;

+            }

+            else {

+                croak "Filter \"$fname\" is not registered."

+                  unless exists $filters->{$fname};

+                  

+                $filter = $filters->{$fname};

+            }

+            $row->[$i] = $filter->($row->[$i]);

+        }

     }

     return wantarray ? @$row : $row;

@@ -39,10 +51,9 @@ sub fetch {

 sub fetch_hash {

     my $self = shift;

-    my $sth            = $self->sth;

-    my $filters        = $self->filters || {};

-    my $default_filter = $self->default_filter || '';

-    my $filter         = $self->filter || {};

+    my $sth            = $self->{sth};

+    my $filters        = $self->{filters} || {};

+    my $filter         = $self->{filter} || {};

     # Fetch

     my $row = $sth->fetchrow_arrayref;

@@ -56,11 +67,25 @@ sub fetch_hash {

     # Filter

     my $row_hash = {};

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

-        my $fname  = $filter->{$columns->[$i]} || $default_filter || '';

-        my $filter = $filters->{$fname};

-        $row_hash->{$columns->[$i]} = $filter

-                                    ? $filter->($row->[$i])

-                                    : $row->[$i];

+        my $fname  = $filter->{$columns->[$i]} || $self->{default_filter} || '';

+        

+        if ($fname) {

+            my $filter;

+            

+            if (ref $fname) {

+                $filter = $fname;

+            }

+            else {

+                croak "Filter \"$fname\" is not registered."

+                  unless exists $filters->{$fname};

+                  

+                $filter = $filters->{$fname};

+            }

+            $row_hash->{$columns->[$i]} = $filter->($row->[$i]);

+        }

+        else {

+            $row_hash->{$columns->[$i]} = $row->[$i];

+        }

     }

     return wantarray ? %$row_hash : $row_hash;

@@ -76,7 +101,7 @@ sub fetch_single {

     return unless $row;

     # Finish statement handle

-    $self->finish;

+    $self->sth->finish;

     return wantarray ? @$row : $row;

 }

@@ -91,7 +116,7 @@ sub fetch_hash_single {

     return unless $row;

     # Finish statement handle

-    $self->finish;

+    $self->sth->finish;

     return wantarray ? %$row : $row;

 }

@@ -160,17 +185,6 @@ sub fetch_hash_all {

     return wantarray ? @$rows : $rows;

 }

-sub finish { shift->sth->finish }

-

-sub error { 

-    my $self = shift;

-    

-    # Statement handle

-    my $sth  = $self->sth;

-    

-    return wantarray ? ($sth->errstr, $sth->err, $sth->state) : $sth->errstr;

-}

-

 1;

 =head1 NAME

@@ -17,7 +17,7 @@ __PACKAGE__->dual_attr('tag_end',   default => '}', inherit => 'scalar_copy');

 __PACKAGE__->dual_attr('tag_syntax', inherit => 'scalar_copy');

-__PACKAGE__->resist_tag_processor(

+__PACKAGE__->register_tag_processor(

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

     '='      => \&DBIx::Custom::SQLTemplate::TagProcessors::expand_basic_tag,

     '<>'     => \&DBIx::Custom::SQLTemplate::TagProcessors::expand_basic_tag,

@@ -50,7 +50,7 @@ __PACKAGE__->tag_syntax(<< 'EOS');

 EOS

-sub resist_tag_processor {

+sub register_tag_processor {

     my $invocant = shift;

     my $tag_processors = ref $_[0] eq 'HASH' ? $_[0] : {@_};

     $invocant->tag_processors({%{$invocant->tag_processors}, %{$tag_processors}});

@@ -293,15 +293,15 @@ query has two infomation

     1. sql       : SQL

     2. key_infos : Parameter access key information

-=head2 resist_tag_processor

+=head2 register_tag_processor

 Add tag processor

-    $sql_tmpl = $sql_tmpl->resist_tag_processor($tag_processor);

+    $sql_tmpl = $sql_tmpl->register_tag_processor($tag_processor);

-The following is resist_tag_processor sample

+The following is register_tag_processor sample

-    $sql_tmpl->resist_tag_processor(

+    $sql_tmpl->register_tag_processor(

         '?' => sub {

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

@@ -7,7 +7,7 @@ use base 'DBIx::Custom::Basic';

 use Carp 'croak';

 # Add format

-__PACKAGE__->resist_format(

+__PACKAGE__->register_format(

     datetime => __PACKAGE__->formats->{SQL99_datetime},

     date     => __PACKAGE__->formats->{SQL99_date},

     time     => __PACKAGE__->formats->{SQL99_time},

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

 test 'Filter basic';

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

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

-$dbi->resist_filter(twice       => sub { $_[0] * 2}, 

+$dbi->register_filter(twice       => sub { $_[0] * 2}, 

                     three_times => sub { $_[0] * 3});

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

@@ -311,7 +311,7 @@ $rows   = $result->fetch_hash_all;

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

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

-$dbi->resist_filter(

+$dbi->register_filter(

     twice       => sub { $_[0] * 2 },

     three_times => sub { $_[0] * 3 }

 );

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

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

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

 $dbi->insert('table1', {key1 => 6, key2 => 7, key3 => 8, key4 => 9, key5 => 10});

-$dbi->resist_filter(twice => sub { $_[0] * 2 });

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

 $dbi->update('table1', {key2 => 11}, {where => {key1 => 1},

               filter => {key2 => 'twice'}});

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

@@ -386,7 +386,7 @@ $dbi = DBIx::Custom->new($NEW_ARGS->{0});

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

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

 $dbi->insert('table1', {key1 => 6, key2 => 7, key3 => 8, key4 => 9, key5 => 10});

-$dbi->resist_filter(twice => sub { $_[0] * 2 });

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

 $dbi->update_all('table1', {key2 => 10}, {filter => {key2 => 'twice'}});

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

 $rows   = $result->fetch_hash_all;

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

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

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

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

-$dbi->resist_filter(twice => sub { $_[0] * 2 });

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

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

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

 $rows   = $result->fetch_hash_all;

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

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

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

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

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

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

             ->fetch_hash_all;

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

@@ -526,7 +526,7 @@ ok(!$query->filter, "$test : only cached sql and columns");

 test 'fetch filter';

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

-$dbi->resist_filter(

+$dbi->register_filter(

     twice       => sub { $_[0] * 2 },

     three_times => sub { $_[0] * 3 }

 );

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

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

-test 'resist_filters';

+test 'register_filters';

 $dbi = DBIx::Custom->new;

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

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

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

-test 'resist_formats';

+test 'register_formats';

 $dbi = DBIx::Custom->new;

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

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

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

 test 'Accessor';

@@ -220,22 +220,3 @@ $result->filter({key1 => 'three_times'});

 $rows = $result->fetch_hash_all;

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

-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");

-is($error[2], $sth->state, "$test list context state");

-

-$error = $result->error;

-is($error, $sth->errstr, "$test scalar context");

-

@@ -66,7 +66,7 @@ for (my $i = 0; $i < @$datas; $i++) {

 test 'Original tag processor';

 $sql_tmpl = DBIx::Custom::SQLTemplate->new;

-$ret_val = $sql_tmpl->resist_tag_processor(

+$ret_val = $sql_tmpl->register_tag_processor(

     p => sub {

         my ($tag_name, $args) = @_;

@@ -77,8 +77,8 @@ $ret_val = $sql_tmpl->resist_tag_processor(

 );

 $query = $sql_tmpl->create_query("{p a b}");

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

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

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

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

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

@@ -89,28 +89,28 @@ $sql_tmpl = DBIx::Custom::SQLTemplate->new;

 eval{$sql_tmpl->create_query("{a }")};

 like($@, qr/Tag '{a }' in SQL template is not exist/, "$test : tag_processor not exist");

-$sql_tmpl->resist_tag_processor({

+$sql_tmpl->register_tag_processor({

     q => 'string'

 });

 eval{$sql_tmpl->create_query("{q}", {})};

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

-$sql_tmpl->resist_tag_processor({

+$sql_tmpl->register_tag_processor({

    r => sub {} 

 });

 eval{$sql_tmpl->create_query("{r}")};

 like($@, qr/\QTag processor 'r' must return (\E\$expand\Q, \E\$columns\Q)/, "$test : tag processor return noting");

-$sql_tmpl->resist_tag_processor({

+$sql_tmpl->register_tag_processor({

    s => sub { return ("a", "")} 

 });

 eval{$sql_tmpl->create_query("{s}")};

 like($@, qr/\QTag processor 's' must return (\E\$expand\Q, \E\$columns\Q)/, "$test : tag processor return not array columns");

-$sql_tmpl->resist_tag_processor(

+$sql_tmpl->register_tag_processor(

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

 );

@@ -120,7 +120,7 @@ like($@, qr/Tag '{t }' arguments cannot contain '?'/, "$test : cannot contain '?

 test 'General error case';

 $sql_tmpl = DBIx::Custom::SQLTemplate->new;

-$sql_tmpl->resist_tag_processor(

+$sql_tmpl->register_tag_processor(

     a => sub {

         return ("? ? ?", [[],[]]);

     }