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

 0.1694

+    - EXPERIMENTAL type_rule argument format is changed

     - DBIx::Custom::Result type_rule method on setting return self 

     - reserved_word_quote is DEPRECATED! this is renamed to quote

     - DBIx::Custom::Model type attribute is DEPRECATED!

@@ -20,7 +20,7 @@ use constant DEBUG => $ENV{DBIX_CUSTOM_DEBUG} || 0;

 use constant DEBUG_ENCODING => $ENV{DBIX_CUSTOM_DEBUG_ENCODING} || 'UTF-8';

 our @COMMON_ARGS = qw/bind_type table query filter id primary_key

-                      type_rule_off type/;

+                      type_rule_off type_rule1_off type_rule2_off type/;

 has [qw/connector dsn password quote user/],

     cache => 0,

@@ -362,6 +362,10 @@ sub execute {

     my $bind_type = delete $args{bind_type} || delete $args{type};

     $bind_type = _array_to_hash($bind_type);

     my $type_rule_off = delete $args{type_rule_off};

+    my $type_rule_off_parts = {

+        1 => delete $args{type_rule1_off},

+        2 => delete $args{type_rule2_off}

+    };

     my $query_return = delete $args{query};

     # Check argument names

@@ -384,7 +388,7 @@ sub execute {

     }

     # Type rule

-    my $type_filter = {};

+    my $type_filters = {};

     unless ($type_rule_off) {

         foreach my $name (keys %$param) {

             my $table;

@@ -395,12 +399,16 @@ sub execute {

             }

             $table ||= $main_table;

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

-            if (defined $table && $into->{$table} &&

-                (my $rule = $into->{$table}->{$column}))

-            {

-                $type_filter->{$column} = $rule;

-                $type_filter->{"$table.$column"} = $rule;

+            foreach my $i (1 .. 2) {

+                unless ($type_rule_off_parts->{$i}) {

+                    my $into = $self->{"_into$i"} || {};

+                    if (defined $table && $into->{$table} &&

+                        (my $rule = $into->{$table}->{$column}))

+                    {

+                        $type_filters->{$i}->{$column} = $rule;

+                        $type_filters->{$i}->{"$table.$column"} = $rule;

+                    }

+                }

             }

         }

     }

@@ -433,7 +441,7 @@ sub execute {

         $param,

         $query->columns,

         $filter,

-        $type_filter,

+        $type_filters,

         $bind_type

     );

@@ -495,7 +503,10 @@ sub execute {

             default_filter => $self->{default_in_filter},

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

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

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

+            type_rule => {

+                from1 => $self->type_rule->{from1},

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

+            },

         );

         return $result;

@@ -960,46 +971,50 @@ sub type_rule {

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

         # Into

-        $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 = lc $column_info->{TYPE_NAME};

-            if ($type_rule->{into} &&

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

-            {

-                return unless exists $type_rule->{into}->{$type_name};

-                if  (defined $filter && ref $filter ne 'CODE') 

+        foreach my $i (1 .. 2) {

+            my $into = "into$i";

+            $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 = lc $column_info->{TYPE_NAME};

+                if ($type_rule->{$into} &&

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

                 {

-                    my $fname = $filter;

+                    return unless exists $type_rule->{$into}->{$type_name};

+                    if  (defined $filter && ref $filter ne 'CODE') 

+                    {

+                        my $fname = $filter;

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

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

+                        

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

+                    }

+

+                    $self->{"_$into"}{$table}{$column} = $filter;

+                }

+            });

+        }

+

+        # From

+        foreach my $i (1 .. 2) {

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

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

+                croak qq{data type of from$i section must be lower case or number}

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

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

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

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

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

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

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

                 }

-

-                $self->{_into}{$table}{$column} = $filter;

-            }

-        });

-        

-

-        # 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

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

-                

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

             }

         }

@@ -1177,7 +1192,7 @@ sub _apply_filter {

 }

 sub _create_bind_values {

-    my ($self, $params, $columns, $filter, $type_filter, $bind_type) = @_;

+    my ($self, $params, $columns, $filter, $type_filters, $bind_type) = @_;

     # Create bind values

     my $bind = [];

@@ -1210,8 +1225,11 @@ sub _create_bind_values {

         $value = $f->($value) if $f;

         # Type rule

-        my $tf = $type_filter->{$column};

-        $value = $tf->($value) if $tf;

+        foreach my $i (1 .. 2) {

+            my $type_filter = $type_filters->{$i};

+            my $tf = $type_filter->{$column};

+            $value = $tf->($value) if $tf;

+        }

         # Bind values

         push @$bind, {value => $value, bind_type => $bind_type->{$column}};

@@ -2104,7 +2122,19 @@ by C<insert()>, C<update()>, C<delete()>, C<select()>.

     type_rule_off => 1

-Trun type rule off.

+Turn C<into1> and C<into2> type rule off.

+

+=item C<type_rule1_off> EXPERIMENTAL

+

+    type_rule1_off => 1

+

+Turn C<into1> type rule off.

+

+=item C<type_rule2_off> EXPERIMENTAL

+

+    type_rule2_off => 1

+

+Turn C<into2> type rule off.

 =back

@@ -2168,6 +2198,18 @@ Same as C<execute> method's C<type> option.

 Same as C<execute> method's C<type_rule_off> option.

+=item C<type_rule1_off> EXPERIMENTAL

+

+    type_rule1_off => 1

+

+Same as C<execute> method's C<type_rule1_off> option.

+

+=item C<type_rule2_off> EXPERIMENTAL

+

+    type_rule2_off => 1

+

+Same as C<execute> method's C<type_rule2_off> option.

+

 =back

 =head2 C<delete_all>

@@ -2253,6 +2295,18 @@ Same as C<execute> method's C<type> option.

 Same as C<execute> method's C<type_rule_off> option.

+=item C<type_rule1_off> EXPERIMENTAL

+

+    type_rule1_off => 1

+

+Same as C<execute> method's C<type_rule1_off> option.

+

+=item C<type_rule2_off> EXPERIMENTAL

+

+    type_rule2_off => 1

+

+Same as C<execute> method's C<type_rule2_off> option.

+

 =back

 =over 4

@@ -2401,14 +2455,23 @@ Register filters, used by C<filter> option of many methods.

 =head2 C<type_rule> EXPERIMENTAL

     $dbi->type_rule(

-        into => {

+        into1 => {

             date => sub { ... },

             datetime => sub { ... }

         },

-        from => {

+        into2 => {

+            date => sub { ... },

+            datetime => sub { ... }

+        },

+        from1 => {

+            # DATE

+            9 => sub { ... },

+            # DATETIME or TIMESTAMP

+            11 => sub { ... },

+        }

+        from2 => {

             # DATE

             9 => sub { ... },

-            

             # DATETIME or TIMESTAMP

             11 => sub { ... },

         }

@@ -2417,12 +2480,17 @@ Register filters, used by C<filter> option of many methods.

 Filtering rule when data is send into and get from database.

 This has a little complex problem.

-In C<into> you can specify type name as same as type name defined

+In C<into1> and C<into2> you can specify

+type name as same as type name defined

 by create table, such as C<DATETIME> or C<DATE>.

-Type rule of C<into> is enabled on the following pattern.

+

+C<into2> is executed after C<into1>.

 Note that type name and data type don't contain upper case.

-If that contain upper case charactor, you specify it lower case.

+If these contain upper case charactor, you convert it to lower case.

+

+Type rule of C<into1> and C<into2> is enabled on the following

+column name.

 =over 4

@@ -2442,33 +2510,18 @@ You get all type name used in database by C<available_type_name>.

     print $dbi->available_type_name;

-In C<from> you can't specify type name defined by create table.

-You must specify data type, this is internal one.

+In C<from1> and C<from2> you data type, not type name.

+C<from2> is executed after C<from1>.

 You get all data type by C<available_data_type>.

     print $dbi->available_data_type;

-Type rule of C<from> is enabled on the following pattern.

-

-=item 4. table name and column name, separator is hyphen

-

-    book-issue_date

-    book-issue_datetime

-

-This is useful in HTML.

-

-=back

-

-You can also specify multiple types

+You can also specify multiple types at once.

     $dbi->type_rule(

-        into => [

+        into1 => [

             [qw/DATE DATETIME/] => sub { ... },

         ],

-        from => {

-            # DATE

-            [qw/9 11/] => sub { ... },

-        }

     );

 =head2 C<select>

@@ -2624,6 +2677,18 @@ Table name.

 Same as C<execute> method's C<type_rule_off> option.

+=item C<type_rule1_off> EXPERIMENTAL

+

+    type_rule1_off => 1

+

+Same as C<execute> method's C<type_rule1_off> option.

+

+=item C<type_rule2_off> EXPERIMENTAL

+

+    type_rule2_off => 1

+

+Same as C<execute> method's C<type_rule2_off> option.

+

 =item C<where>

     # Hash refrence

@@ -2729,7 +2794,19 @@ Same as C<execute> method's C<type> option.

 =item C<type_rule_off> EXPERIMENTAL

-Same as C<execute> method's <type_rule_off>.

+Same as C<execute> method's C<type_rule_off> option.

+

+=item C<type_rule1_off> EXPERIMENTAL

+

+    type_rule1_off => 1

+

+Same as C<execute> method's C<type_rule1_off> option.

+

+=item C<type_rule2_off> EXPERIMENTAL

+

+    type_rule2_off => 1

+

+Same as C<execute> method's C<type_rule2_off> option.

 =back

@@ -4,7 +4,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_off/];

+has [qw/filters filter_off sth type_rule_off type_rule1_off type_rule2_off/];

 has stash => sub { {} };

 *all = \&fetch_hash_all;

@@ -49,7 +49,8 @@ sub fetch {

     # Filtering

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

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

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

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

@@ -58,9 +59,14 @@ sub fetch {

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

         # Type rule

-        my $type_filter = $type_rule->{lc($types->[$i])};

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

-          if $type_filter && !$self->{type_rule_off};

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

@@ -109,18 +115,23 @@ sub fetch_hash {

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

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

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

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

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

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

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

         # Column

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

+        $hash_row->{$column} = $row->[$i];

         # Type rule

-        my $type_filter = $type_rule->{lc($types->[$i])};

-        if (!$self->{type_rule_off} && $type_filter) {

-            $hash_row->{$column} = $type_filter->($row->[$i]);

-        }

-        else { $hash_row->{$column} = $row->[$i] }

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

+        $hash_row->{$column} = $type_filter1->($hash_row->{$column})

+        if  !$self->{type_rule_off} && !$self->{type_rule1_off}

+         && $type_filter1;

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

+        $hash_row->{$column} = $type_filter2->($hash_row->{$column})

+        if  !$self->{type_rule_off} && !$self->{type_rule2_off}

+         && $type_filter2;

         # Filter

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

@@ -197,31 +208,30 @@ sub fetch_multi {

 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};

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

+

+        # From

+        foreach my $i (1 .. 2) {

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

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

+                croak qq{data type of from$i section must be lower case or number}

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

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

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

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

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

+                    

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

+                }

             }

         }

-        

-        # Replace

-        if (@_ == 1) { $self->{type_rule} = $type_rule }

-        # Merge

-        else { $self->{type_rule} = {%{$self->type_rule}, %$type_rule} }

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

         return $self;

     }

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

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

 }

 # DEPRECATED!

@@ -355,7 +365,21 @@ Statement handle of L<DBI>.

     my $type_rule_off = $result->type_rule_off;

     $result = $result->type_rule_off(1);

-Filtering by C<type_rule> is turned off.

+Turn C<from1> and C<from2> type rule off.

+

+=head2 C<type_rule1_off> EXPERIMENTAL

+

+    my $type_rule1_off = $result->type_rule1_off;

+    $result = $result->type_rule1_off(1);

+

+Turn C<from1> type rule off.

+

+=head2 C<type_rule2_off> EXPERIMENTAL

+

+    my $type_rule2_off = $result->type_rule2_off;

+    $result = $result->type_rule2_off(1);

+

+Turn C<from2> type rule off.

 =head1 METHODS

@@ -2648,7 +2648,7 @@ is_deeply($result->one,

 test 'type_rule from';

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

 $dbi->type_rule(

-    from => {

+    from1 => {

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

     }

 );

@@ -2665,7 +2665,7 @@ test 'type_rule into';

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

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

 $dbi->type_rule(

-    into => {

+    into1 => {

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

     }

 );

@@ -2676,7 +2676,7 @@ is($result->one->{key1}, 'A');

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

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

 $dbi->type_rule(

-    into => [

+    into1 => [

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

     ]

 );

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

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

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

 $dbi->type_rule(

-    into => [

+    into1 => [

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

     ]

 );

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

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

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

 $dbi->type_rule(

-    into => [

+    into1 => [

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

     ]

 );

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

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

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

 $dbi->type_rule(

-    from => {

+    from1 => {

         date => 'twice',

     },

-    into => {

+    into1 => {

         date => 'twice',

     }

 );

@@ -2738,26 +2738,55 @@ test 'type_rule and filter order';

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

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

 $dbi->type_rule(

-    into => {

+    into1 => {

         date => sub { $_[0] . 'b' }

     },

-    from => {

+    into2 => {

         date => sub { $_[0] . 'c' }

+    },

+    from1 => {

+        date => sub { $_[0] . 'd' }

+    },

+    from2 => {

+        date => sub { $_[0] . 'e' }

     }

 );

 $dbi->insert({key1 => '1'}, table => 'table1', filter => {key1 => sub { $_[0] . 'a' }});

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

-$result->filter(key1 => sub { $_[0] . 'd' });

-is($result->fetch_first->[0], '1abcd');

+$result->filter(key1 => sub { $_[0] . 'f' });

+is($result->fetch_first->[0], '1abcdef');

+

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

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

+$dbi->type_rule(

+    from1 => {

+        date => sub { $_[0] . 'p' }

+    },

+    from2 => {

+        date => sub { $_[0] . 'q' }

+    },

+);

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

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

+$result->type_rule(

+    from1 => {

+        date => sub { $_[0] . 'd' }

+    },

+    from2 => {

+        date => sub { $_[0] . 'e' }

+    }

+);

+$result->filter(key1 => sub { $_[0] . 'f' });

+is($result->fetch_first->[0], '1def');

 test 'type_rule_off';

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

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

 $dbi->type_rule(

-    from => {

+    from1 => {

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

     },

-    into => {

+    into1 => {

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

     }

 );

@@ -2768,10 +2797,10 @@ is($result->type_rule_off(1)->fetch->[0], 2);

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

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

 $dbi->type_rule(

-    from => {

+    from1 => {

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

     },

-    into => {

+    into1 => {

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

     }

 );

@@ -2782,10 +2811,10 @@ 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 => {

+    from1 => {

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

     },

-    into => {

+    into1 => {

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

     }

 );

@@ -2796,10 +2825,10 @@ 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 => {

+    from1 => {

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

     },

-    into => {

+    into1 => {

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

     }

 );

@@ -2811,7 +2840,7 @@ $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 => {

+    into1 => {

         date => 'ppp'

     }

 );

@@ -2820,32 +2849,17 @@ $result = $dbi->select(table => 'table1');

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

 eval{$dbi->type_rule(

-    into => {

+    into1 => {

         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 => {

+        from1 => {

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

         }

     );

@@ -2854,7 +2868,7 @@ like($@, qr/lower/);

 eval {

     $dbi->type_rule(

-        into => {

+        into1 => {

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

         }

     );

@@ -2864,10 +2878,10 @@ 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 => {

+    from1 => {

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

     },

-    into => {

+    into1 => {

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

     }

 );

@@ -2879,48 +2893,68 @@ 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 => {

+    from1 => {

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

+$result->type_rule(

+    from1 => {

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

+    }

+);

 $row = $result->one;

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

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

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

+

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

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

+$result->type_rule(

+    from1 => {

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

+    }

+);

 $row = $result->one;

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

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

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

+

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

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

+$result->type_rule(

+    from1 => {

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

+    }

+);

 $row = $result->one;

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

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

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

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

+$result->type_rule(

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

+);

 $row = $result->one;

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

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

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

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

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

+$result->type_rule(

+    from1 => [date => 'fivetimes']

+);

 $row = $result->one;

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

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

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

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

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

+$result->type_rule(

+    from1 => [date => undef]

+);

 $row = $result->one;

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

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

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

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

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

 $dbi->type_rule(

-    from => {

+    from1 => {

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

     },

 );

@@ -2932,7 +2966,7 @@ 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 => {

+    from1 => {

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

     },

 );

@@ -2941,6 +2975,69 @@ $result = $dbi->select(table => 'table1');

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

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

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

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

+$dbi->type_rule(

+    into1 => {

+        date => sub { $_[0] . 'b' }

+    },

+    into2 => {

+        date => sub { $_[0] . 'c' }

+    },

+    from1 => {

+        date => sub { $_[0] . 'd' }

+    },

+    from2 => {

+        date => sub { $_[0] . 'e' }

+    }

+);

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

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

+$result->type_rule_off(1);

+is($result->fetch_first->[0], '1');

+

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

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

+$dbi->type_rule(

+    into1 => {

+        date => sub { $_[0] . 'b' }

+    },

+    into2 => {

+        date => sub { $_[0] . 'c' }

+    },

+    from1 => {

+        date => sub { $_[0] . 'd' }

+    },

+    from2 => {

+        date => sub { $_[0] . 'e' }

+    }

+);

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

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

+$result->type_rule1_off(1);

+is($result->fetch_first->[0], '1ce');

+

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

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

+$dbi->type_rule(

+    into1 => {

+        date => sub { $_[0] . 'b' }

+    },

+    into2 => {

+        date => sub { $_[0] . 'c' }

+    },

+    from1 => {

+        date => sub { $_[0] . 'd' }

+    },

+    from2 => {

+        date => sub { $_[0] . 'e' }

+    }

+);

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

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

+$result->type_rule2_off(1);

+is($result->fetch_first->[0], '1bd');

+

 test 'separator';

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

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

@@ -141,7 +141,7 @@ $dbi->each_column(

 );

 $dbi->type_rule(

-    into => {

+    into1 => {

         date=> sub {

             my $date = shift;

             $date =~ s/aaaaa//g;

@@ -153,7 +153,7 @@ $dbi->type_rule(

             return $date;

         },

     },

-    from => {

+    from1 => {

         # DATE

         9 => sub {

                 my $date = shift;