@@ -1,3 +1,8 @@

+0.1747

+    - fixed bug DBIx::Custom::Result fetch_hash_multi throw warnings

+      which cannnot fetch any more

+    - fixed bug DBIx::Custom::Result fetch_hash_multi throw warnings

+      which cannnot fetch any more

 0.1746

     - micro optimization

 0.1745

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

 package DBIx::Custom;

 use Object::Simple -base;

-our $VERSION = '0.1745';

+our $VERSION = '0.1747';

 use 5.008001;

 use Carp 'croak';

@@ -3401,6 +3401,15 @@ executed SQL and bind values are printed to STDERR.

 DEBUG output encoding. Default to UTF-8.

+=head2 C<DBIX_CUSTOM_TAG_PARSE>

+

+If you set DBIX_CUSTOM_TAG_PARSE to 0, tag parsing is off.

+

+=head2 C<DBIX_CUSTOM_DISABLE_MODEL_EXECUTE>

+

+If you set DBIX_CUSTOM_DISABLE_MODEL_EXECUTE to 1,

+L<DBIx::Custom::Model> execute method call L<DBIx::Custom> execute.

+

 =head1 DEPRECATED FUNCTIONALITY

 L<DBIx::Custom>

@@ -39,24 +39,6 @@ sub filter {

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

 }

-sub _cache {

-    my $self = shift;

-    $self->{_type_map} = {};

-    $self->{_pos} = {};

-    $self->{_columns} = {};

-    for (my $i = 0; $i < @{$self->{sth}->{NAME}}; $i++) {

-        my $type = lc $self->{sth}{TYPE}[$i];

-        my $name = $self->{sth}{NAME}[$i];

-        $self->{_type_map}{$type} ||= [];

-        push @{$self->{_type_map}{$type}}, $name;

-        $self->{_pos}{$name} ||= [];

-        push @{$self->{_pos}{$name}}, $i;

-        $self->{_columns}{$name} = 1;

-    }

-    $self->{_cache} = 1;

-}

-

-=pod

 sub fetch {

     my $self = shift;

@@ -68,41 +50,48 @@ sub fetch {

     return unless @row;

     # Type rule

-    if ((my $from = $self->type_rule->{from1}) && !$self->{type_rule_off} && !$self->{type_rule1_off}) {

+    if ($self->{type_rule}->{from1} && !$self->{type_rule_off} && !$self->{type_rule1_off}) {

+        my $from = $self->{type_rule}->{from1};

         for my $type (keys %$from) {

             for my $column (@{$self->{_type_map}->{$type}}) {

                 $row[$_] = $from->{$type}->($row[$_])

-                  for @{$self->{_pos}{$column}};

+                  for @{$self->{_pos}{$column} || []};

             }

         }

     }

-    if ((my $from = $self->type_rule->{from2}) && !$self->{type_rule_off} && !$self->{type_rule2_off}) {

+    if ($self->{type_rule}->{from2} && !$self->{type_rule_off} && !$self->{type_rule2_off}) {

+        my $from = $self->{type_rule}->{from2};

         for my $type (keys %$from) {

             for my $column (@{$self->{_type_map}->{$type}}) {

                 $row[$_] = $from->{$type}->($row[$_])

-                  for @{$self->{_pos}{$column}};

+                  for @{$self->{_pos}{$column} || []};

             }

         }

     }

     # Filter

     if (($self->{filter} || $self->{default_filter}) && !$self->{filter_off}) {

-        for my $column (keys %{$self->{filter}}) {

-            $row[$_] = ($self->{filter}->{$column} || $self->{default_filter} || sub { shift })

-                ->($row[$_])

-              for @{$self->{_pos}{$column}};

-        }

+         my @columns = $self->{default_filter} ? keys %{$self->{_columns}}

+           : keys %{$self->{filter}};

+         

+         for my $column (@columns) {

+             my $filter = exists $self->{filter}->{$column} ? $self->{filter}->{$column}

+               : $self->{default_filter};

+             next unless $filter;

+             $row[$_] = $filter->($row[$_])

+               for @{$self->{_pos}{$column} || []};

+         }

     }

     if ($self->{end_filter} && !$self->{filter_off}) {

          for my $column (keys %{$self->{end_filter}}) {

+             next unless $self->{end_filter}->{$column};

              $row[$_] = $self->{end_filter}->{$column}->($row[$_])

-               for @{$self->{_pos}{$column}};

+               for @{$self->{_pos}{$column} || []};

          }

     }

     return \@row;

 }

-=cut

 sub fetch_hash {

     my $self = shift;

@@ -154,48 +143,6 @@ sub fetch_hash {

     $row;

 }

-sub fetch {

-    my $self = shift;

-    

-    # Info

-    my $columns = $self->{sth}->{NAME};

-    my $types = $self->{sth}->{TYPE};

-    

-    # Fetch

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

-    return unless @row;

-    

-    # Filtering

-    my $type_rule1 = $self->type_rule->{from1} || {};

-    my $type_rule2 = $self->type_rule->{from2} || {};

-    my $filter = $self->filter;

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

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

-        

-        # Column

-        my $column = $columns->[$i];

-        

-        # Type rule

-        my $type_filter1 = $type_rule1->{lc($types->[$i])};

-        $row[$i] = $type_filter1->($row[$i])

-          if  $type_filter1 && !$self->{type_rule_off}

-           && !$self->{type_rule1_off};

-        my $type_filter2 = $type_rule2->{lc($types->[$i])};

-        $row[$i] = $type_filter2->($row[$i])

-          if  $type_filter2 && !$self->{type_rule_off}

-           && !$self->{type_rule2_off};

-        

-        # Filter

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

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

-          if $filter && !$self->{filter_off};

-        $row[$i] = $end_filter->{$column}->($row[$i])

-          if $end_filter->{$column} && !$self->{filter_off};

-    }

-

-    return \@row;

-}

-

 sub fetch_all {

     my $self = shift;

@@ -248,10 +195,16 @@ sub fetch_hash_multi {

     # Fetch multiple rows

     croak 'Row count must be specified ' . _subname

       unless $count;

+    

+    return if $self->{_finished};

+

     my $rows = [];

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

         my $row = $self->fetch_hash;

-        last unless $row;

+        unless ($row) {

+            $self->{_finished} = 1;

+            last;

+        }

         push @$rows, $row;

     }

@@ -266,11 +219,16 @@ sub fetch_multi {

     croak 'Row count must be specified ' . _subname

       unless $count;

+    return if $self->{_finished};

+    

     # Fetch multi rows

     my $rows = [];

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

         my $row = $self->fetch;

-        last unless $row;

+        unless ($row) {

+            $self->{_finished} = 1;

+            last;

+        }

         push @$rows, $row;

     }

@@ -347,6 +305,23 @@ sub type_rule2_on {

     return $self;

 }

+sub _cache {

+    my $self = shift;

+    $self->{_type_map} = {};

+    $self->{_pos} = {};

+    $self->{_columns} = {};

+    for (my $i = 0; $i < @{$self->{sth}->{NAME}}; $i++) {

+        my $type = lc $self->{sth}{TYPE}[$i];

+        my $name = $self->{sth}{NAME}[$i];

+        $self->{_type_map}{$type} ||= [];

+        push @{$self->{_type_map}{$type}}, $name;

+        $self->{_pos}{$name} ||= [];

+        push @{$self->{_pos}{$name}}, $i;

+        $self->{_columns}{$name} = 1;

+    }

+    $self->{_cache} = 1;

+}

+

 # DEPRECATED!

 sub filter_off {

     warn "filter_off method is DEPRECATED!";

@@ -1113,6 +1113,15 @@ $result->filter({$key1 => 'three_times'});

 $row = $result->one;

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

+$dbi->default_fetch_filter('twice');

+eval { $dbi->execute("drop table $table1") };

+$dbi->execute($create_table1);

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

+$result = $dbi->select(column => [$key1, $key1, $key2], table => $table1);

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

+$row = $result->fetch_first;

+is_deeply($row, [3, 3, 4], "default_fetch_filter and filter");

+

 test 'filters';

 $dbi = DBIx::Custom->new;

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

 $row = $result->fetch_first;

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

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

+eval { $dbi->execute("drop table $table1") };

+$dbi->execute($create_table1);

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

+$result = $dbi->select(column => [$key1, $key1, $key2], 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, 6, 40]);

+

 $dbi = DBIx::Custom->connect;

 eval { $dbi->execute("drop table $table1") };

 $dbi->execute($create_table1);

@@ -1498,6 +1517,13 @@ $result->end_filter($key1 => undef);

 $row = $result->one;

 is_deeply($row, {$key1 => 1, $key2 => 40}, 'apply_filter overwrite');

+$result = $dbi->select(column => [$key1, $key1, $key2], table => $table1);

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

+$result->filter($key1 => undef);

+$result->end_filter($key1 => undef);

+$row = $result->fetch;

+is_deeply($row, [1, 1, 40], 'apply_filter overwrite');

+

 test 'remove_end_filter and remove_filter';

 $dbi = DBIx::Custom->connect;

 eval { $dbi->execute("drop table $table1") };

@@ -3279,16 +3305,49 @@ is_deeply($rows, [{$key1 => 1, $key2 => 2}, {$key1 => 3, $key2 => 4}]);

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

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

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

-

 $rows = $result->fetch_all;

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

+$result = $dbi->select(column => [$key1, $key1, $key2], table => $table1);

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

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

+$rows = $result->fetch_all;

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

+

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

 $result->dbi->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}], "hash");

+test 'DBIx::Custom::Result fetch_multi';

+eval { $dbi->execute("drop table $table1") };

+$dbi->execute($create_table1);

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

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

+$dbi->insert({$key1 => 5, $key2 => 6}, table => $table1);

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

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

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

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

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

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

+ok(!$rows);

+

+test 'DBIx::Custom::Result fetch_hash_multi';

+eval { $dbi->execute("drop table $table1") };

+$dbi->execute($create_table1);

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

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

+$dbi->insert({$key1 => 5, $key2 => 6}, table => $table1);

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

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

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

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

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

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

+ok(!$rows);

+

 test "query_builder";

 $datas = [

     # Basic tests

@@ -3905,6 +3964,10 @@ $dbi->type_rule(

 $dbi->insert({$key1 => '2010-02-02'}, table => $table1);

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

 like($result->fetch->[0], qr/^2010-03-03/);

+$result = $dbi->select(column => [$key1, $key1], table => $table1);

+$row = $result->fetch;

+like($row->[0], qr/^2010-03-03/);

+like($row->[1], qr/^2010-03-03/);

 test 'type_rule and filter order';

 $dbi = DBIx::Custom->connect;