@@ -1,3 +1,6 @@

+0.1631

+  added experimental DBIx::Custom::Result end_filter method

+  experimental extended select method's where option

 0.1630

   fix test bug

 0.1629

@@ -1,6 +1,6 @@

 package DBIx::Custom;

-our $VERSION = '0.1630';

+our $VERSION = '0.1631';

 use 5.008001;

 use strict;

@@ -165,7 +165,7 @@ The following SQL is executed.

 C<filter> argument can be specified.

 see also "METHODS" section.

-=head2 3. Fetch row

+=head2 3. Result manipulation

 C<select()> method return L<DBIx::Custom::Result> object.

 You can fetch row by various methods.

@@ -229,7 +229,7 @@ If you want to access statement handle of L<DBI>, use C<sth> attribute.

     my $sth = $result->sth;

-=head2 4. Hash parameter binding

+=head2 4. Parameter binding

 L<DBIx::Custom> provides hash parameter binding.

@@ -288,52 +288,70 @@ already perl escaped charactor, so you must write '\\'.

 =head2 5. Filtering

-Usually, Perl string is kept as internal string.

-If you want to save the string to database, You must encode the string.

-Filtering system help you to convert a data to another data

-when you save to the data and get the data form database.

-

-If you want to register filter, use C<register_filter()> method.

+If you want to filter the value, you can do this. For example,

+L<Time::Piece> object to database date format, or reverse.

     $dbi->register_filter(

-        to_upper_case => sub {

-            my $value = shift;

-            return uc $value;

+        tp_to_date => sub {

+            return shift->strftime('%Y-%m-%d');

+        },

+        date_to_tp => sub {

+            return Time::Piece->strptime(shift, '%Y-%m-%d');

         }

     );

+In this example, L<Time::Piece> object is converted to 'yyyy-mm-dd' format

+, and reverse.

+

+You can apply this filter to use C<apply_filter()> method.

+

+    $dbi->apply_filter('book',

+        puplication_date => {out => 'tp_to_date', in => 'date_to_tp'},

+        someting_date => {out => 'tp_to_date', in => 'date_to_tp'}

+    );

+

+In this case, C<book>'s C<publication_date> is automatically converted.

+C<out> means Perl to Database, C<in> means Database to Perl.

+These applied filters have effect C<insert>, C<update>, C<update_all>,

+C<delete>, C<delete_all>, C<select>

-You can specify these filters to C<filter> argument of C<execute()> method.

+    my $tp = Time::Piece::localtime;

+    $dbi->insert(

+        table => 'book',

+        param => {name => 'Perl', publication_date => $tp}

+    );

+    

+    my $result = $dbi->select(table => 'book');

+    my $tp = $result->{publication_date};

+    

+

+Note that this has'nt C<execute> method by default.

+If you want to have effect C<execute()> method, use C<table>

+option.

     my $result = $dbi->execute(

-        "select * from book where {= author} and {like title};"

-        param  => {author => 'Ken', title => '%Perl%'},

-        filter => {author => 'to_upper_case, title => 'encode_utf8'}

+        "select * from book where {= id};",

+         param => {id => 5},

+         table => ['book']

     );

-C<filter> argument can be specified to suger methods, such as

-C<insert()>, C<update()>, C<update_all()>,

-C<delete()>, C<delete_all()>, C<select()>.

-    # insert(), having filter argument

-    $dbi->insert(table  => 'book',

-                 param  => {title => 'Perl', author => 'Ken'},

-                 filter => {title => 'encode_utf8'});

+You can also specify registered filters to C<filter> option of

+C<insert()>, C<update()>, C<update_all()>, C<delete()>, C<delete_all()>,

+C<select()> C<execute()>. This is overwirte applied filter.

-    # select(), having filter argument

-    my $result = $dbi->select(

-        table  => 'book',

-        column => [qw/author title/],

-        where  => {author => 'Ken'},

-        append => 'order by id limit 1',

-        filter => {title => 'encode_utf8'}

+    $dbi->insert(

+        table => 'book',

+        param => {name => 'Perl', publication_date => $tp},

+        filter => {publication_date => 'tp_to_date'}

     );

-You can also specify filter when the row is fetched. This is reverse of bind filter.

+You can also specify C<DBIx::Custom::Result> object.

+This is overwrite applied filter.

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

-    $result->filter({title => 'decode_utf8', author => 'to_upper_case'});

+    $result->filter(publication_date => 'date_to_tp');

 B<Filter examples>

@@ -380,8 +398,50 @@ SQLite

     date_to_tp => sub {

         return Time::Piece->strptime(shift, $FORMATS->{db_date});

     }

-    

-=head2 6. Get high performance

+

+=head2 6.Create table object

+

+You can create table object which have methods.

+

+    $dbi->table('book');

+

+This class have C<insert()>, C<update()>, C<update_all()>,

+C<delete>, C<delete_all>, C<select().

+These is same as C<DBIx::Custom>'s methods except that 

+you don't have to specify table.

+

+    $dbi->table('book')->insert(

+        param => {author => 'Taro', name => 'Perl'}

+    );

+

+You can define method for table.

+

+    $dbi->table('book',

+        insert_multi => sub {

+            my $self = shift;

+            my $table = $self->name;

+            my $dbi = $self->dbi;

+            

+            # Do something

+        },

+        cross_summary => sub {

+            my $self = shift;

+            my $table = $self->name;

+            my $dbi = $self->dbi;

+            

+            # Do something

+        }

+    );

+

+Each method receive L<DBIx::Custom::Table> object as first argument.

+This class have C<name()> to get table name and C<dbi()>

+to get L<DBIx::Custom> object.

+

+Defined method is called from table class.

+

+    $dbi->table('book')->insert_multi(param => $param);

+

+=head2 7. Get high performance

 =head3 Use execute() method instead suger methods

@@ -418,7 +478,7 @@ Execute query repeatedly.

 This is faster than C<insert()> method.

-=head2 7. More features

+=head2 8. More features

 =head3 Get DBI object

@@ -25,19 +25,46 @@ sub filter {

             }

         }

-        $self->{filter} = {%{$self->filter || {}}, %$filter};

+        $self->{filter} = {%{$self->filter}, %$filter};

         return $self;

     }

-    return $self->{filter};

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

+}

+

+sub end_filter {

+    my $self = shift;

+    

+    if (@_) {

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

+        

+        foreach my $column (keys %$end_filter) {

+            my $fname = $end_filter->{$column};

+            unless (ref $fname eq 'CODE') {

+              croak qq{"$fname" is not registered"}

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

+              

+              $end_filter->{$column} = $self->filters->{$fname};

+            }

+        }

+        

+        $self->{end_filter} = {%{$self->end_filter}, %$end_filter};

+        

+        return $self;

+    }

+    

+    return $self->{end_filter} ||= {};

 }

 sub fetch {

     my $self = shift;

     # Filter

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

+    my $filter = $self->filter;

+    

+    # End filter

+    my $end_filter = $self->end_filter;

     # Fetch

     my @row = $self->{sth}->fetchrow_array;

@@ -54,9 +81,11 @@ sub fetch {

         my $f  = exists $filter->{$column}

                ? $filter->{$column}

                : $self->default_filter;

+        my $ef = $end_filter->{$column};

         # Filtering

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

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

     }

     return \@row;

@@ -92,7 +121,10 @@ sub fetch_hash {

     my $self = shift;

     # Filter

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

+    my $filter  = $self->filter;

+    

+    # End filter

+    my $end_filter = $self->end_filter;

     # Fetch

     my $row = $self->{sth}->fetchrow_arrayref;

@@ -110,9 +142,11 @@ sub fetch_hash {

         my $f  = exists $filter->{$column}

                ? $filter->{$column}

                : $self->default_filter;

+        my $ef = $end_filter->{$column};

         # Filtering

         $row_hash->{$column} = $f ? $f->($row->[$i]) : $row->[$i];

+        $row_hash->{$column} = $ef->($row_hash->{$column}) if $ef;

     }

     return $row_hash;

@@ -296,6 +330,15 @@ Statement handle of L<DBI>.

 L<DBIx::Custom::Result> inherits all methods from L<Object::Simple>

 and implements the following new ones.

+=head2 C<(experimental) end_filter>

+

+    $result    = $result->end_filter(title  => 'to_upper_case',

+                                     author => 'to_upper_case');

+

+End filters.

+These each filters is executed after the filters applied by C<apply_filter> of

+L<DBIx::Custom> or C<filter> method.

+

 =head2 C<fetch>

     my $row = $result->fetch;

@@ -348,8 +391,12 @@ Row count must be specified.

 =head2 C<filter>

-    $result    = $result->filter(title  => 'decode_utf8',

-                                 author => 'decode_utf8');

+    $result    = $result->filter(title  => 'to_upper_case',

+                                 author => 'to_upper_case');

+

+Filters.

+These each filters override the filters applied by C<apply_filter> of

+L<DBIx::Custom>.

 =head2 C<(deprecated) default_filter>

@@ -34,7 +34,7 @@ use Scalar::Util 'blessed';

     );

     $dbi->connect;

     ok(!$dbi->dbh->{AutoCommit});

-    ok($dbi->dbh->{mysql_enable_utf8});

+    #ok($dbi->dbh->{mysql_enable_utf8});

 }

 sub connect_info {

@@ -769,3 +769,20 @@ $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);

+

+

+test 'end_filter';

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

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

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

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

+$result->filter(key1 => sub { $_[0] * 2 }, key2 => sub { $_[0] * 4 });

+$result->end_filter(key1 => sub { $_[0] * 3 }, key2 => sub { $_[0] * 5 });

+$row = $result->fetch_first;

+is_deeply($row, [6, 40]);

+

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

+$result->filter(key1 => sub { $_[0] * 2 }, key2 => sub { $_[0] * 4 });

+$result->end_filter(key1 => sub { $_[0] * 3 }, key2 => sub { $_[0] * 5 });

+$row = $result->fetch_hash_first;

+is_deeply($row, {key1 => 6, key2 => 40});

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

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

 }

-my $test;

-sub test {

-    $test = shift;

-}

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

 sub query {

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

@@ -50,7 +47,7 @@ $result = query($dbh, $sql);

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

     push @rows, [@$row];

 }

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

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

 test 'fetch_hash';

@@ -59,28 +56,28 @@ $result = query($dbh, $sql);

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

     push @rows, {%$row};

 }

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

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

 test 'fetch_first';

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

 $row = $result->fetch_first;

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

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

 $row = $result->fetch;

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

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

 test 'fetch_hash_first';

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

 $row = $result->fetch_hash_first;

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

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

 $row = $result->fetch_hash;

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

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

 $result = query($dbh, 'create table table2 (key1, key2);');

 $result = query($dbh, 'select * from table2');

 $row = $result->fetch_hash_first;

-ok(!$row, "$test : no row fetch");

+ok(!$row, "no row fetch");

 test 'fetch_multi';

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

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

 $rows = $result->fetch_multi(2);

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

-                  [3, 4]], "$test : fetch_multi first");

+                  [3, 4]], "fetch_multi first");

 $rows = $result->fetch_multi(2);

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

-                  [7, 8]], "$test : fetch_multi secound");

+                  [7, 8]], "fetch_multi secound");

 $rows = $result->fetch_multi(2);

-is_deeply($rows, [[9, 10]], "$test : fetch_multi third");

+is_deeply($rows, [[9, 10]], "fetch_multi third");

 $rows = $result->fetch_multi(2);

 ok(!$rows);

@@ -103,19 +100,19 @@ ok(!$rows);

 test 'fetch_multi error';

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

 eval {$result->fetch_multi};

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

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

 test 'fetch_hash_multi';

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

 $rows = $result->fetch_hash_multi(2);

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

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

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

 $rows = $result->fetch_hash_multi(2);

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

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

+                  {key1 => 7, key2 => 8}], "fetch_multi secound");

 $rows = $result->fetch_hash_multi(2);

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

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

 $rows = $result->fetch_hash_multi(2);

 ok(!$rows);

@@ -123,7 +120,7 @@ ok(!$rows);

 test 'fetch_multi error';

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

 eval {$result->fetch_hash_multi};

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

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

 $dbh->do('delete from table1');

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

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

 test 'fetch_all';

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

 $rows = $result->fetch_all;

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

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

 test 'fetch_hash_all';

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

 $rows = $result->fetch_hash_all;

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

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

 test 'fetch filter';

@@ -146,11 +143,11 @@ $result->filters({three_times => sub { $_[0] * 3}});

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

 $rows = $result->fetch_all;

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

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

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

 $result->filters({three_times => sub { $_[0] * 3}});

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

 $rows = $result->fetch_hash_all;

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

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