@@ -1,4 +1,5 @@

 0.1692

+    - added EXPERIMENTAL DBIx::Custom::Result type_rule

     - added EXPERIMENTAL available_type_name method 

     - EXPERIMENTAL type_rule_off is not passed form execute method 

       to DBIx::Custom::Result object

@@ -521,7 +521,7 @@ sub execute {

             default_filter => $self->{default_in_filter},

             filter => $filter->{in} || {},

             end_filter => $filter->{end} || {},

-            type_rule => $self->type_rule,

+            type_rule => \%{$self->type_rule->{from}},

         );

         return $result;

@@ -989,10 +989,14 @@ sub type_rule {

         $type_rule->{into} = _array_to_hash($type_rule->{into});

         $self->{type_rule} = $type_rule;

         $self->{_into} ||= {};

+        foreach my $type_name (keys %{$type_rule->{into} || {}}) {

+            croak qq{type name of into section must be lower case}

+              if $type_name =~ /[A-Z]/;

+        }

         $self->each_column(sub {

             my ($dbi, $table, $column, $column_info) = @_;

-            my $type_name = $column_info->{TYPE_NAME};

+            my $type_name = lc $column_info->{TYPE_NAME};

             if ($type_rule->{into} &&

                 (my $filter = $type_rule->{into}->{$type_name}))

             {

@@ -1014,6 +1018,8 @@ sub type_rule {

         # From

         $type_rule->{from} = _array_to_hash($type_rule->{from});

         foreach my $data_type (keys %{$type_rule->{from} || {}}) {

+            croak qq{data type of into section must be lower case or number}

+              if $data_type =~ /[A-Z]/;

             my $fname = $type_rule->{from}{$data_type};

             if (defined $fname && ref $fname ne 'CODE') {

                 croak qq{Filter "$fname" is not registered" } . _subname

@@ -5,7 +5,7 @@ use Object::Simple -base;

 use Carp 'croak';

 use DBIx::Custom::Util qw/_array_to_hash _subname/;

-has [qw/filters filter_off sth type_rule type_rule_off/],

+has [qw/filters filter_off sth type_rule_off/],

     stash => sub { {} };

 *all = \&fetch_hash_all;

@@ -68,9 +68,7 @@ sub fetch {

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

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

-        

-        if (!$self->type_rule_off && $type_rule->{from} &&

-            (my $rule = $type_rule->{from}->{$types->[$i]}))

+        if (!$self->type_rule_off && (my $rule = $type_rule->{lc($types->[$i])}))

         {

             $row[$i] = $rule->($row[$i]);

         }

@@ -139,8 +137,7 @@ sub fetch_hash {

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

         # Type rule

-        if (!$self->type_rule_off && $type_rule->{from} &&

-            (my $rule = $type_rule->{from}->{$types->[$i]}))

+        if (!$self->type_rule_off && (my $rule = $type_rule->{lc($types->[$i])}))

         {

             $row->[$i] = $rule->($row->[$i]);

         }

@@ -229,6 +226,36 @@ sub fetch_multi {

 *one = \&fetch_hash_first;

+sub type_rule {

+    my $self = shift;

+    

+    # Merge type rule

+    if (@_) {

+        my $type_rule = @_ == 1 ? $_[0] : [@_];

+        $type_rule = _array_to_hash($type_rule) || {};

+        foreach my $data_type (keys %{$type_rule || {}}) {

+            croak qq{data type of into section must be lower case or number}

+              if $data_type =~ /[A-Z]/;

+            my $fname = $type_rule->{$data_type};

+            if (defined $fname && ref $fname ne 'CODE') {

+                croak qq{Filter "$fname" is not registered" } . _subname

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

+                

+                $type_rule->{$data_type} = $self->filters->{$fname};

+            }

+        }

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

+    }

+    

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

+}

+

+sub clear_type_rule {

+    my $self = shift;

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

+    return $self;

+}

+

 # DEPRECATED!

 sub end_filter {

     my $self = shift;

@@ -501,6 +528,17 @@ Remove filter. End filter is not removed.

 Stash is hash reference to save your data.

+=head2 C<type_rule> EXPERIMENTAL

+

+    $result->type_rule(

+        # DATE

+        9 => sub { ... },

+        # DATETIME or TIMESTAMP

+        11 => sub { ... }

+    );

+

+This override L<DBIx::Custom>'s C<type_rule> C<from> section.

+

 =head2 C<remove_end_filter> DEPRECATED!

     $result->remove_end_filter;

@@ -2605,7 +2605,7 @@ test 'type_rule from';

 $dbi = DBIx::Custom->connect(dsn => 'dbi:SQLite:dbname=:memory:');

 $dbi->type_rule(

     from => {

-        Date => sub { uc $_[0] }

+        date => sub { uc $_[0] }

     }

 );

 $dbi->execute("create table table1 (key1 Date, key2 datetime)");

@@ -2622,7 +2622,7 @@ $dbi = DBIx::Custom->connect(dsn => 'dbi:SQLite:dbname=:memory:');

 $dbi->execute("create table table1 (key1 Date, key2 datetime)");

 $dbi->type_rule(

     into => {

-        Date => sub { uc $_[0] }

+        date => sub { uc $_[0] }

     }

 );

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

@@ -2630,10 +2630,10 @@ $result = $dbi->select(table => 'table1');

 is($result->one->{key1}, 'A');

 $dbi = DBIx::Custom->connect(dsn => 'dbi:SQLite:dbname=:memory:');

-$dbi->execute("create table table1 (key1 Date, key2 datetime)");

+$dbi->execute("create table table1 (key1 date, key2 datetime)");

 $dbi->type_rule(

     into => [

-         [qw/Date datetime/] => sub { uc $_[0] }

+         [qw/date datetime/] => sub { uc $_[0] }

     ]

 );

 $dbi->insert({key1 => 'a', key2 => 'b'}, table => 'table1');

@@ -2647,7 +2647,7 @@ $dbi->execute("create table table1 (key1 Date, key2 datetime)");

 $dbi->insert({key1 => 'a', key2 => 'B'}, table => 'table1');

 $dbi->type_rule(

     into => [

-        [qw/Date datetime/] => sub { uc $_[0] }

+        [qw/date datetime/] => sub { uc $_[0] }

     ]

 );

 $result = $dbi->execute(

@@ -2663,7 +2663,7 @@ $dbi->execute("create table table1 (key1 Date, key2 datetime)");

 $dbi->insert({key1 => 'A', key2 => 'B'}, table => 'table1');

 $dbi->type_rule(

     into => [

-        [qw/Date datetime/] => sub { uc $_[0] }

+        [qw/date datetime/] => sub { uc $_[0] }

     ]

 );

 $result = $dbi->execute(

@@ -2676,14 +2676,14 @@ is($row->{key1}, 'A');

 is($row->{key2}, 'B');

 $dbi = DBIx::Custom->connect(dsn => 'dbi:SQLite:dbname=:memory:');

-$dbi->execute("create table table1 (key1 Date, key2 datetime)");

+$dbi->execute("create table table1 (key1 date, key2 datetime)");

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

 $dbi->type_rule(

     from => {

-        Date => 'twice',

+        date => 'twice',

     },

     into => {

-        Date => 'twice',

+        date => 'twice',

     }

 );

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

@@ -2696,10 +2696,10 @@ $dbi = DBIx::Custom->connect(dsn => 'dbi:SQLite:dbname=:memory:');

 $dbi->execute("create table table1 (key1 Date, key2 datetime)");

 $dbi->type_rule(

     from => {

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

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

     },

     into => {

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

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

     }

 );

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

@@ -2711,22 +2711,50 @@ $dbi = DBIx::Custom->connect(dsn => 'dbi:SQLite:dbname=:memory:');

 $dbi->execute("create table table1 (key1 Date, key2 datetime)");

 $dbi->type_rule(

     from => {

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

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

     },

     into => {

-        DATE => sub { $_[0] * 3 },

+        date => sub { $_[0] * 3 },

     }

 );

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

 $result = $dbi->select(table => 'table1', type_rule_off => 1);

-is($result->one->{key1}, 2);

+is($result->one->{key1}, 4);

+

+$dbi = DBIx::Custom->connect(dsn => 'dbi:SQLite:dbname=:memory:');

+$dbi->execute("create table table1 (key1 Date, key2 datetime)");

+$dbi->type_rule(

+    from => {

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

+    },

+    into => {

+        date => sub { $_[0] * 3 },

+    }

+);

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

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

+is($result->one->{key1}, 12);

+

+$dbi = DBIx::Custom->connect(dsn => 'dbi:SQLite:dbname=:memory:');

+$dbi->execute("create table table1 (key1 Date, key2 datetime)");

+$dbi->type_rule(

+    from => {

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

+    },

+    into => {

+        date => sub { $_[0] * 3 },

+    }

+);

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

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

+is($result->fetch->[0], 12);

 $dbi = DBIx::Custom->connect(dsn => 'dbi:SQLite:dbname=:memory:');

 $dbi->execute("create table table1 (key1 Date, key2 datetime)");

 $dbi->register_filter(ppp => sub { uc $_[0] });

 $dbi->type_rule(

     into => {

-        Date => 'ppp'

+        date => 'ppp'

     }

 );

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

@@ -2735,11 +2763,98 @@ is($result->one->{key1}, 'A');

 eval{$dbi->type_rule(

     into => {

-        Date => 'pp'

+        date => 'pp'

     }

 )};

 like($@, qr/not registered/);

+$dbi = DBIx::Custom->connect(dsn => 'dbi:SQLite:dbname=:memory:');

+$dbi->execute("create table table1 (key1 Date, key2 datetime)");

+$dbi->type_rule(

+    from => {

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

+    },

+    into => {

+        date => sub { $_[0] * 3 },

+    }

+);

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

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

+delete $result->type_rule->{date};

+is($result->one->{key1}, 6);

+

+$dbi = DBIx::Custom->connect(dsn => 'dbi:SQLite:dbname=:memory:');

+$dbi->execute("create table table1 (key1 Date, key2 datetime)");

+eval {

+    $dbi->type_rule(

+        from => {

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

+        }

+    );

+};

+like($@, qr/lower/);

+

+eval {

+    $dbi->type_rule(

+        into => {

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

+        }

+    );

+};

+like($@, qr/lower/);

+

+$dbi = DBIx::Custom->connect(dsn => 'dbi:SQLite:dbname=:memory:');

+$dbi->execute("create table table1 (key1 Date, key2 datetime)");

+$dbi->type_rule(

+    from => {

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

+    },

+    into => {

+        date => sub { $_[0] * 3 },

+    }

+);

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

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

+$result->type_rule_off(1);

+is($result->one->{key1}, 6);

+

+$dbi = DBIx::Custom->connect(dsn => 'dbi:SQLite:dbname=:memory:');

+$dbi->execute("create table table1 (key1 Date, key2 datetime)");

+$dbi->type_rule(

+    from => {

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

+        datetime => sub { $_[0] * 4 },

+    },

+);

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

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

+$result->type_rule(date => sub { $_[0] * 3 });

+$row = $result->one;

+is($row->{key1}, 6);

+is($row->{key2}, 8);

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

+$result->type_rule({date => sub { $_[0] * 3 }});

+$row = $result->one;

+is($row->{key1}, 6);

+is($row->{key2}, 8);

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

+$result->type_rule([date => sub { $_[0] * 3 }]);

+$row = $result->one;

+is($row->{key1}, 6);

+is($row->{key2}, 8);

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

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

+$result->type_rule(date => 'fivetimes');

+$row = $result->one;

+is($row->{key1}, 10);

+is($row->{key2}, 8);

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

+$result->type_rule(date => undef);

+$row = $result->one;

+is($row->{key1}, 2);

+is($row->{key2}, 8);

+

+

 test 'result_filter';

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

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

@@ -142,12 +142,12 @@ $dbi->each_column(

 $dbi->type_rule(

     into => {

-        DATE=> sub {

+        date=> sub {

             my $date = shift;

             $date =~ s/aaaaa//g;

             return $date;

         },

-        DATETIME => sub {

+        datetime => sub {

             my $date = shift;

             $date =~ s/ccccc//g;

             return $date;